Das große Problem ist eigentlich das Einlesen. Dazu verwende ich 2 Strukturen

struct BITMAPFILEHEADER {
    unsigned short bfType;
    unsigned long bfSize;
    unsigned short bfReserved1;
    unsigned short bfReserved2;
    unsigned long bfOffBits;
    };

    struct BITMAPINFOHEADER {
    unsigned long biSize;
    unsigned long biWidth;
    unsigned long biHeight;
    unsigned short biPlanes;
    unsigned short biBitCount;
    unsigned long biCompression;
    unsigned long biSizeImage;
    unsigned long biXPelsPerMeter;
    unsigned long biYPelsPerMeter;
    unsigned long biClrUsed;
    unsigned long biClrImportant;
    };

Mit

fp = fopen(filename, "rb")

öffne ich die Datei zum binären lesen und mit

fp = fopen(filename, "wb")

eine andere Datei zum binären schreiben.

Mit

fread(&FileHeader, sizeof(FileHeader), 1, fp)
fread(&InfoHeader, sizeof(InfoHeader), 1, fp)

lese ich dann das Bild ein.

Wenn ich aber dann mit

fwrite(&FileHeader, sizeof(FileHeader), 1, fp)

den Dateiheader in eine andere Datei übertrage, kommt nur das "MB" am Anfang an. Alles andere sieht eher zufällig aus, obwohl ich es vorher auf 0 gesetzt habe.

Ich hoffe, jemand hat nen Tip

Gruß
jabaa

void Bitmap::LoadBitmap(const char *filename){
FILE             *fp;
...}

zum einlesen und eine Methode

void Bitmap::SaveBitmap(const char *filename){
FILE             *fp;
...}

zum schreiben. Somit hat das eine fp nen anderen Gültigkeitsbereich als das andere fp

#ifndef BITMAP_H
#define BITMAP_H

typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef unsigned long LONG;

#include "fstream"
class Bitmap
{
 public:

	 void LoadBitmap(const char *Filename);
	 void SaveBitmap(const char *Filename);

	 void *bits;

	 //BITMAPFILEHEADER
	 typedef struct
	 {
	 WORD bfType;
	 DWORD bfSize;
	 DWORD bfReserved;
	 DWORD bfOffBits;
	 }BITMAPFILEHEADER;

	 //BITMAPINFOHEADER
	 typedef struct
	 {
	 DWORD biSize;
	 LONG biWidth;
	 LONG biHeight;
	 WORD biPlanes;
	 WORD biBitCount;
	 DWORD biCompression;
	 DWORD biSizeImage;
	 LONG biXPelsPerMeter;
	 LONG biYPelsPerMeter;
	 DWORD biClrUsed;
	 DWORD biClrImportant;
	 }BITMAPINFOHEADER;

	 BITMAPFILEHEADER FileHeader;
	 typedef struct
	 {
	 DWORD biSize;
	 LONG biWidth;
	 LONG biHeight;
	 WORD biPlanes;
	 WORD biBitCount;
	 DWORD biCompression;
	 DWORD biSizeImage;
	 LONG biXPelsPerMeter;
	 LONG biYPelsPerMeter;
	 DWORD biClrUsed;
	 DWORD biClrImportant;
	 }BITMAPINFOHEADER;

	 BITMAPFILEHEADER FileHeader;
	 BITMAPINFOHEADER InfoHeader;
};

#endif // BITMAP_H

Bitmap.cpp

#include "Bitmap.hpp"
#include <stdlib.h>
#include <iostream>

void Bitmap::LoadBitmap(const char *filename)    
{
    FILE             *fp;          
    int              bitsize;      
    int              infosize;     

    if ((fp = fopen(filename, "rb")) == NULL)
        return;

    if (fread(&FileHeader, sizeof(FileHeader), 1, fp) < 1)
    {
	fclose(fp);
        return;
    }

    if (FileHeader.bfType != 'MB')
    {
        fclose(fp);
        return;
    }

    infosize = FileHeader.bfOffBits - sizeof(FileHeader);

    infosize = 40;
    if (fread(&InfoHeader, infosize, 1,fp) < infosize)
    {
        fclose(fp);
        return;
    }

    if ((bitsize = InfoHeader.biSize) == 0)
        bitsize = (InfoHeader.biWidth *
                   InfoHeader.biBitCount + 7) / 8 *
  	           abs(InfoHeader.biHeight);

    if ((bits = malloc(bitsize)) == NULL)
    {
        fclose(fp);
        return;
    }

    if (fread(bits, 1, bitsize, fp) < bitsize)
    {
        fclose(fp);
        return;
    }

    fclose(fp);
    return;
}

void Bitmap::SaveBitmap(const char *Filename)
{
    FILE *File=NULL;

    File=fopen(Filename,"wb");
    fwrite(&FileHeader,sizeof(BITMAPFILEHEADER),1,File);

    fwrite(&InfoHeader,sizeof(BITMAPINFOHEADER),1,File);

    fclose(File);
};

main.cpp

#include <iostream>
    #include <fstream>
    #include <cstdlib>
    #include "Bitmap.hpp"

int main(){
 Bitmap bmp;

    bmp.LoadBitmap("penguins.bmp");
    bmp.SaveBitmap("penguins_cod.bmp");
return 0;
}

Original:
424D 36C0 0000 0000 0000 3600 0000 2800
0000 8000 0000 8000 0000 0100 1800 0000
0000 00C0 0000 130B 0000 130B 0000 0000 
0000 0000 0000

Kopie:
424D FE0A 0000 0000 0000 3600 0000 2800
0000 1E00 0000 1E00 0000 0100 1800 0000
0000 C80A 0000 0000 0000 0000 0000 0000
0000 0000 0000 7D7E

Stellenweise passt es. Aber allein dass der Header länger geworden ist ist sehr komisch

fwrite(&FileHeader, 1, sizeof(FileHeader), fp)

s. z.B. http://www.c-plusplus.net/forum/265354

infosize = FileHeader.bfOffBits - sizeof(FileHeader); 

    infosize = 40;

Du berechnest erst die Headergröße und überschreibst den Wert sofort wieder. Und beim Schreiben nimmst du auch wieder eine (möglicherweise andere) Header-Größe an.

PS: HAst du schon mal an fstream gedacht?

Mit fstream hab ichs auch versucht. Da kam ähnlicher Mist bei raus. Ganz ganz komisch. Gibt es keine fertigen Packete für sowas? Ich muss es ja nich unbedingt selbst schreiben. Aber ich kann auch im Internet nix finden.

Gruß
jabaa

hast du meinen Beitrag nicht gelesen oder aber nicht verstanden, was ich dir mit "Padding" nahelegen wollte?

So wie CStoll geschrieben hat, baut der Compiler (aus Performance-Gründen) einige Füll-Bytes ("Padding") ein, um z.B. Integer auf einer durch 4 teilbaren Adresse abzulegen.
Um das Abzustellen, gibt es die '#pragma pack(1)' - Direktive (aber wie schon geschrieben, je nach Compiler etwas modifiziert)...

Und mein Link zeigt eine Bitmap-Leseroutine aus diesem Forum...