Imatges i formats

 BITMAPFILEHEADER    bmfh ;             // File header (14 bytes)
 BITMAPINFOHEADER    bmih ;             // Info header (40 bytes)
 RGBQUAD             aColors [] ;       // called COLOR TABLE (not PALETTE).
 BYTE                aBitmapBits [] ;

typedef struct tagBITMAPFILEHEADER {    // 14 bytes :
  WORD    bfType ;                      // 2 bytes : "BM"
  DWORD   bfSize ;                      // 4 bytes : file size in bytes
  WORD    bfReserved1 ;                 // 2
  WORD    bfReserved2 ;                 // 2
  DWORD   bfOffBits ;                   // 4 : file offset to raster data
} BITMAPFILEHEADER, * PBITMAPFILEHEADER ;

 


typedef struct {                             // 14 bytes :
   unsigned short int type ;                 /* (2) Magic identifier            */
   unsigned int       size ;                 /* (4) File size in bytes          */
   unsigned short int reserved1, reserved2 ; // (2+2)
   unsigned int       offset ;               /* (4) Offset to image data, bytes */
} HEADER;

typedef struct tagBITMAPINFOHEADER { // 40 bytes :
  DWORD   biSize ;                   // 4 - size of InfoHeader = 40
  LONG    biWidth ;                  // 4 - bitmap width
  LONG    biHeight ;                 // 4 - bitmap height
  WORD    biPlanes ;                 // 2 - number of planes (=1)
  WORD    biBitCount ;               // 2 - bits per pixel
                                     //    1 = monochrome      => NumColors = 1
                                     //    4 = 4bit palletized => NumColors = 16
                                     //    8 = 8bit palletized => NumColors = 256
                                     //   16 = 16bit RGB       => NumColors = 65536
                                     //   24 = 24bit RGB       => NumColors = 16M
  DWORD   biCompression ;            // 4 - type of compression
                                     //   0 = BI_RBG, no compression
                                     //   1 = BI_RLE8, 8bit RLE (run length) encoding
                                     //   2 = BI_RLE4, 4bit RLE encoding
                                     //   3 = RGB bitmap with mask
  DWORD   biSizeImage ;              // 4 - compressed size of image
                                     //     can be set to 0 if Compression = 0
  LONG    biXPelsPerMeter ;          // 4 - horizontal resolution : pixels/meter
  LONG    biYPelsPerMeter ;          // 4 - vertical resolution : pixels/meter
  DWORD   biClrUsed ;                // 4 - number of actually used colors
  DWORD   biClrImportant ;           // 4 - number of important colors (0 = all)
} BITMAPINFOHEADER, * PBITMAPINFOHEADER ;

 


typedef struct {                             // 40 bytes
   unsigned int       size ;                 /* (4) Header size in bytes        */
   int                width, height ;        /* (4+4) Width and height of image */
   unsigned short int planes ;               /* (2) Number of colour planes     */
   unsigned short int bits ;                 /* (2) Bits per pixel              */
   unsigned int   compression ;              /* (4) Compression type            */
   unsigned int   imagesize ;                /* (4) Image size in bytes         */
   int            xresolution, yresolution ; /* (4+4) Pixels per meter          */
   unsigned int   ncolours ;                 /* (4) Number of colours           */
   unsigned int   importantcolours ;         /* (4) Important colours           */
} INFOHEADER;

typedef struct tagRGBQUAD {
  BYTE    rgbBlue ;      { 1 - specifies the blue  part of the color }
  BYTE    rgbGreen ;     { 1 - specifies the green part of the color }
  BYTE    rgbRed ;       { 1 - specifies the red   part of the color }
  BYTE    rgbReserved ;  { 1 - must always be set to zero }
} RGBQUAD;

Writing a bitmap to a BMP file is fairly simple if we have a handle to device-independent bitmap. We simply write BITMAPINFOHEADER information followed by the contents of the bitmap. The three fields that we have to set in the BITMAPINFOHEADER are the bfType which should always be "BM", the bfSize which is the size of the bitmap including the infoheader and the bfOffBits which is the offset to the bitmap bits from the start of the file.
If you have a device-dependent bitmap to begin with, you have to first create a DIB from it. Creating a DIB from a DDB has already been covered in another section.

// WriteDIB - Writes a DIB to file
// in :
//  szFile- Name of file to write to
//  hDIB- Handle of the DIB
// out :
//  Returns- TRUE on success

BOOL WriteDIB ( LPTSTR szFile, HANDLE hDIB ) {

 BITMAPFILEHEADER   hdr ;
 LPBITMAPINFOHEADER lpbi ;

     if ( ! hDIB )
          return FALSE ;

     CFile file ;
     if( ! file.Open ( szFile, CFile::modeWrite | CFile::modeCreate ) )
          return FALSE ;

     lpbi = (LPBITMAPINFOHEADER) hDIB ;

     int nColors = 1 << lpbi -> biBitCount ;

// Fill in the fields of the file header

     hdr.bfType = ((WORD) ('M' << 8) | 'B') ;      // is always "BM"
     hdr.bfSize = GlobalSize ( hDIB ) + sizeof( hdr ) ;
     hdr.bfReserved1 = 0 ;
     hdr.bfReserved2 = 0 ;
     hdr.bfOffBits = (DWORD) ( sizeof( hdr ) + lpbi -> biSize + nColors * sizeof( RGBQUAD ) ) ;

// Write the file header

     file.Write ( & hdr, sizeof ( hdr ) ) ;

// Write the DIB header and the bits

     file.Write ( lpbi, GlobalSize ( hDIB ) ) ;

     return TRUE ;
}

What made the BMP format successful was its support for indexing through 4 and 8-bit palettes. Rather than storing each of the necessary RGB values for each pixel, Microsoft instead added first a fixed and then a customisable palette to its BMP format. Each pixel's colour could then be defined by storing its associated index number rather than the much longer RGB value. This look-up table approach is inherently more efficient for handling images with up to 256 colours as each pixel can be stored in eight bits of information rather than twenty four. Microsoft was able to further optimise the BMP format by tying it even more closely to Windows' API, adding features such as control over which colours to dither when images are viewed on limited colour displays.

From here