[c++] Wegschrijven structures

[Verwijderd]

Ik heb een probleempje met het wegschrijfen van mijn structures naar een bestand

Als ik de volgende 2 structures wegschrijf heb ik meer data in mijn bestand dan dat ik wegschrijf , maar als ik gebruik maak van de structures in de windows.h dan werkt het wel goed terwijl de structures hetzelfde zijn. Oh en ik maak gebruik van microsoft visual studio 2003.

C++:

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

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

BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;

bmpfile.write((char*)&bmfh, sizeof(bmfh));
bmpfile.write((char*)&bmih, sizeof(bmih)); 

[curry684]

Ik snap geen bal van je vraag. Hoezo heb je meer data dan je wegschrijft? Dat kan helemaal niet

* curry684 hint subtiel naar P&W FAQ - De "quickstart" en de editknop

[ Voor 47% gewijzigd door curry684 op 03-12-2004 14:39 ]

[Verwijderd]

Toch is het zo als ik mijn output bmp met de hex editor bekijk heb ik 2 bytes teveel. vervang ik nu mijn bitmapio.h door de windows.h dan gaat het wel goed terwijl de structures hetzelfde zijn.

hieronder een snel voorbeeld van de totale code

C++:

bitmapio.h

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

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


main.cpp

#include <iostream>
#include <fstream>
#include "BitmapIO.h" 


using namespace std;

int main()
{
    ofstream bmpfile("bitmap.bmp",ofstream::binary);
    BITMAPFILEHEADER bmfh;
    BITMAPINFOHEADER bmih;
    int width = 4;
    int height = 4;
    unsigned char x[60] = {0xff,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff};
    unsigned char *Buffer = x;
    long paddedsize = sizeof(x);
    
    // fill the fileheader with data
    bmfh.bfType = 0x4d42;       // 0x4d42 = 'BM'
    bmfh.bfReserved1 = 0;
    bmfh.bfReserved2 = 0;
    bmfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + paddedsize;
    bmfh.bfOffBits = 0x36;          
    // fill the bmihheader
    
    bmih.biSize = sizeof(BITMAPINFOHEADER);
    bmih.biWidth = width;
    bmih.biHeight = height;
    bmih.biPlanes = 1;          // we only have one bitplane
    bmih.biBitCount = 24;       // RGB mode is 24 bits
    bmih.biCompression = 0; 
    bmih.biSizeImage = 0;       // can be 0 for 24 bit images
    bmih.biXPelsPerMeter = 0x0ec4;     // paint and PSP use this values
    bmih.biYPelsPerMeter = 0x0ec4;     
    bmih.biClrUsed = 0;          
    bmih.biClrImportant = 0;    // all colors are important

    bmpfile.write((char*)&bmfh, sizeof(bmfh));
    bmpfile.write((char*)&bmih, sizeof(bmih));
                bmpfile.write((char*)Buffer, paddedsize); 

[curry684]

Kijk eens in de help bij 'structure packing size'

[Verwijderd]

Ik ben nog een beetje n00b met betrekking tot c++ ik zie dat het waarschijnlijk kan oplossen met pragma pack(n)

maar kan iemand mij uitleggen hoe dit precies werkt?

[curry684]

Als je kijkt naar de bitmapfileheader:

C++:

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

Deze is 2 longs van 4 bytes en 3 shorts van 2 bytes groot, dus theoretisch 14 bytes. Echter, hier komt de packing size kijken: "The alignment of a member will be on a boundary that is either a multiple of n or a multiple of the size of the member, whichever is smaller. " De default packing size van 8 heb je hier geen last van op zich, behalve dat het inhoudt dat de 2e member bfSize een long groot is en dus oftewel op een veelvoud van 4 of van 8 komt te staan, whichever is smaller, dus 4. Omdat er enkel een short van 2 bytes voor staat worden daar dus 2 'padding bytes' toegevoegd.

Je lost dit dus als volgt op:

C++:

#pragma pack(push, 1)

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

#pragma pack(pop)

[Verwijderd]

Thx de bitmapheader wordt nu inderdaad herkent als een juiste bitmap
en het is me een beetje duidelijker hoe packing werkt

topic kan gesloten worden.

[curry684]

Verwijderd schreef op vrijdag 03 december 2004 @ 15:31:
topic kan gesloten worden.

Waarom zou het op slot moeten, nu kunnen er tenminste nog mensen met andere tips en inzichten komen

We sluiten topics hier alleen als ze policies overtreden of anderszins zinloos zijn

[MSalters]

Misschien meteen erbij zeggen dat dit allemaal Visual Studio 32-bitsspecifiek is?

Of suggereer

C++:

struct BITMAPFILEHEADER  
{ 
    unsigned short  bfType; 
    unsigned short  bfSizeHigh; 
    unsigned short  bfSizeLow; 
    unsigned long   getSize() const { return bfSizeLow + (bfSizeHigh<<16UL); }
    unsigned short  bfReserved1; 
    unsigned short  bfReserved2; 
    unsigned short  bfOffBitsHigh;
    unsigned short  bfOffBitsLow;
    unsigned long   getOffBits() const { return bfSizeLow + (bfOffBitsLow<<16UL); }
} ;

PS. typedef struct x {...} is C, geen C++. windows.h is ook voor C, vandaar. In je eigen C++ code moet je dat niet doen.

[.oisyn]

Overigens zijn de bitmap structures van windows.h er toch ook gewoon op gemaakt dat ze 1:1 vertalen naar een bmp file?

[curry684]

.oisyn schreef op vrijdag 03 december 2004 @ 19:17:
Overigens zijn de bitmap structures van windows.h er toch ook gewoon op gemaakt dat ze 1:1 vertalen naar een bmp file?

Ja ik snap ook niet waarom ie herdefinieert eilijk

[Soultaker]

.oisyn schreef op vrijdag 03 december 2004 @ 19:17:
Overigens zijn de bitmap structures van windows.h er toch ook gewoon op gemaakt dat ze 1:1 vertalen naar een bmp file?

Alleen op een little endian machine (en dat is Windows natuurlijk) en met de Microsoft compiler dus. Maar ze zullen inderdaad niet voor niets gepacked zijn.

[ Voor 43% gewijzigd door Soultaker op 03-12-2004 19:38 ]

[curry684]

Gezien het feit dat het BMP-formaat van OS/2 gejat is zal het niet Windows-only zijn

[Soultaker]

Dat zei ik ook niet. Ik zeg alleen dat je zo'n packed struct niet op alle architecturen werkt (alleen toevallig wel op die waar DOS, Windows en OS/2 op draait). Behalve met endianess zit je ook met architecturen waar je geen unaligned data kan fetchen enzo (maar in theorie kan de compiler dat afhandelen, bedenk ik me nu, als je er vanuit gaat dat de structure zelf altijd aligned begint).

[ Voor 24% gewijzigd door Soultaker op 03-12-2004 19:45 ]