bmp.h

Go to the documentation of this file.

#ifndef CTLDEF_H
#include "ctl/ctldef.h"
#endif
#ifndef OPC_H
#include "opc/opc.h"
#endif

#if !defined(_WINGDI_)
#pragma pack(push,1)
#define BI_RGB        0L
#define BI_RLE8       1L
#define BI_RLE4       2L
#define BI_BITFIELDS  3L
typedef struct tagBITMAPINFOHEADER
{
    uint32      biSize;             /* Specifies the number of bytes required by the structure. */
    int32       biWidth;            /* Specifies the width of the bitmap, in pixels. (Windows 98, Windows 2000: If biCompression is BI_JPEG or BI_PNG, the biWidth member specifies the width of the decompressed JPEG or PNG image file, respectively) */
    int32       biHeight;           /* Specifies the height of the bitmap, in pixels. If biHeight is positive, the bitmap is a bottom-up DIB and its origin is the lower-left corner. If biHeight is negative, the bitmap is a top-down DIB and its origin is the upper-left corner.  If biHeight is negative, indicating a top-down DIB, biCompression must be either BI_RGB or BI_BITFIELDS. Top-down DIBs cannot be compressed. */ 
    uint16      biPlanes;           /* Specifies the number of planes for the target device. This value must be set to 1. */ 
    uint16      biBitCount;         /* Number of bits in a pixel.  See Win32 SDK doco */ 
    uint32      biCompression;      /* BI_RGB,BI_RLE8,BI_RLE4,BI_BITFIELDS,BI_JPEG,BI_PNG */ 
    uint32      biSizeImage;        /* Specifies the size, in bytes, of the image. This may be set to zero for BI_RGB bitmaps.  */ 
    int32       biXPelsPerMeter;    /* Specifies the horizontal resolution, in pixels-per-meter, of the target device for the bitmap. An application can use this value to select a bitmap from a resource group that best matches the characteristics of the current device. */ 
    int32       biYPelsPerMeter;    /* Specifies the vertical resolution, in pixels-per-meter, of the target device for the bitmap.  */ 
    uint32      biClrUsed;          /* Specifies the number of color indexes in the color table that are actually used by the bitmap. If this value is zero, the bitmap uses the maximum number of colors corresponding to the value of the biBitCount member for the compression mode specified by biCompression. */
    uint32      biClrImportant;     /* Specifies the number of color indexes that are required for displaying the bitmap. If this value is zero, all colors are required.  */
} BITMAPINFOHEADER;
typedef struct tagRGBQUAD 
{
    uint8       rgbBlue;
    uint8       rgbGreen;
    uint8       rgbRed;
    uint8       rgbReserved;
} RGBQUAD;
typedef struct tagBITMAPINFO 
{
    BITMAPINFOHEADER    bmiHeader;
    RGBQUAD             bmiColors[1];
} BITMAPINFO;
typedef struct tagBITMAPFILEHEADER 
{
    uint16      bfType      __attribute__ ((packed));               /* Specifies the file type, must be "BM" */
    uint32      bfSize      __attribute__ ((packed));               /* Specifies the size, in bytes, of the bitmap file. */
    uint16      bfReserved1 __attribute__ ((packed));       /* Reserved: 0 */
    uint16      bfReserved2 __attribute__ ((packed));       /* Reserved: 0 */
    uint32      bfOffBits   __attribute__ ((packed));           /* Specifies the offset, in bytes, from the BITMAPFILEHEADER structure to the bitmap bits.  */
} BITMAPFILEHEADER;
#pragma pack(pop)
#endif 
/*
 * BITMAPINFO Macros
 *
 * Where 'bmi' is specified, the macro expects a pointer to a BITMAPINFO structure.
 *
 * BMI_Alloc()              Allocate a BITMAPINFO structure which will hold ANY format
 * BMI_Free(bmi)            Release a BITMAPINFO created with BMI_Alloc()
 * BMI_BMI_Copy(bmi)        Return a copy of a BITMAPINFO (typically to modify for translation)
 * BMI_UpsideDown(bmi)      Return TRUE if BITMAPINFO is in an upside-down format
 * BMI_Wide(bmi)            Return absolute width of bitmap
 * BMI_High(bmi)            Return absolute height of bitmap
 * BMI_Depth(bmi)           Return bit count of a bitmap
 * BMI_Compressed(bmi)      Return TRUE if this BITMAPINFO is in a compressed format
 * BMI_LineSize(bmi)        Returns the width of a bitmap line in bytes (bitmaps round to four byte alignment!)
 * BMI_BitmapSize(bmi)      Returns the size of a BITMAP 
 * BMI_ColorCount(bmi)      Returns count of colors in a BITMAP
 * BMI_Header(bmi)          Returns pointer to BITMAPINFOHEADER of BITMAPINFO
 * BMI_ColorData(bmi)       Returns first byte of color data
 * BMI_Origin(bmi,pMap)     Returns pointer to raster origin of uncompressed bitmap data 
 * BMI_LineOffset(bmi)      Returns the offset to the next raster coordinate line in a bitmap
 * BMI_Clip(bmi,rect)       Fills out rect as a clipping rectangle for a DIB bitmap
 * BMI_BMI_Size(bmi)        Returns size of a BITMAPINFO as it would appear in a file
 * BMI_SetColorIndexes(bmi) Set colors in BMI_ as indexes into a logical palette
 * BMI_ParseData(img,bmi,bits) Given an image of a bitmap in memory, get bmi and bits
 */
#define BMI_SIZE                (sizeof(BITMAPINFO) + (255 * sizeof(RGBQUAD)))
#define BMI_Alloc()             ((BITMAPINFO *)calloc( 1, BMI_SIZE ))
#define BMI_Free(bmi)           free(bmi)
#define BMI_BMI_Copy(bmi)       memcpy( BMI_Alloc(), bmi, BMI_BMI_Size(bmi) )
#define BMI_UpsideDown(bmi)     ((bmi)->bmiHeader.biHeight > 0)
#define BMI_Wide(bmi)           (abs((bmi)->bmiHeader.biWidth))
#define BMI_High(bmi)           (abs((bmi)->bmiHeader.biHeight))
#define BMI_Depth(bmi)          ((bmi)->bmiHeader.biBitCount)
#define BMI_Compressed(bmi)     !((bmi)->bmiHeader.biCompression==BI_RGB||(bmi)->bmiHeader.biCompression==BI_BITFIELDS)
#define BMI_LineSize(bmi)       ((((BMI_Wide(bmi)*BMI_Depth(bmi))+31)&~31)>>3)
#define BMI_BitmapSize(bmi)     (BMI_Compressed(bmi)?(bmi)->bmiHeader.biSizeImage:(BMI_LineSize(bmi)*BMI_High(bmi)))
#define BMI_ColorCount(bmi)     ((bmi)->bmiHeader.biClrUsed ? (bmi)->bmiHeader.biClrUsed : (1 << BMI_Depth(bmi)))
#define BMI_Header(bmi)         (&(bmi)->bmiHeader)
#define BMI_ColorData(bmi)      ((bmi)->bmiColors)
#define BMI_Origin(bmi,bits)    ( BMI_UpsideDown(bmi) ? (void*)(((uint8 *)(bits)) + (BMI_LineSize(bmi)*(BMI_High(bmi)-1))) : (void*)(bits) )
#define BMI_LineOffset(bmi)     (BMI_UpsideDown(bmi)?-(int)BMI_LineSize(bmi):(int)BMI_LineSize(bmi))
#define BMI_LinePtr(bmi,bits,line) ((void *)((uint8 *)BMI_Origin(bmi,bits)+((line)*BMI_LineOffset(bmi))))
#define BMI_Clip(bmi,rect)      (((rect).left = (rect).top = 0),(rect).right=BMI_Wide(bmi),(rect).bottom=BMI_High(bmi))
#define BMI_BMI_Size(bmi)       ( (bmi)->bmiHeader.biSize + \
    ( ( (bmi)->bmiHeader.biBitCount <= 8 ) ? \
    ( ((bmi)->bmiHeader.biClrUsed ? (bmi)->bmiHeader.biClrUsed : (1 << (bmi)->bmiHeader.biBitCount)) * sizeof(RGBQUAD) ) : \
    ( ((bmi)->bmiHeader.biBitCount == 24 || (bmi)->bmiHeader.biCompression != BI_BITFIELDS) ? 0 : (3 * sizeof(uint32)) ) ) )
#define BMI_SetColorIndexes( bmi ) \
{ \
    uint16 *pData = (uint16 *)BMI_ColorData(bmi); \
    int curr; \
    for( curr = 0; curr < 256; ++curr ) \
        *pData++ = curr; \
}

#define BMI_ParseData( image, bmi, bits )\
{\
    if( *((uint16 *)(image)) == *((uint16 *)"BM") ) \
    {\
        /* Loaded from a file; strip file header out */\
        (bmi) = (BITMAPINFO *)( (uint8 *)(image) + sizeof(BITMAPFILEHEADER) );\
        (bits) = (uint8 *)(image) + ((BITMAPFILEHEADER *)image)->bfOffBits;\
    }\
    else \
    {\
        /* <Probably> loaded from a resource */\
        (bmi) = (BITMAPINFO *)(image);\
        (bits) = (uint8 *)(bmi) + BMI_BMI_Size( bmi );\
    }\
}

#define BMI_Init( bmi, wide, high, bpp ) \
{\
    BITMAPINFOHEADER* pbmi = &(bmi)->bmiHeader;\
    pbmi->biSize = sizeof(BITMAPINFOHEADER);\
    pbmi->biWidth = (wide);\
    pbmi->biHeight = (high);\
    pbmi->biPlanes = 1;\
    pbmi->biBitCount = (bpp);\
    pbmi->biCompression = BI_RGB;\
    pbmi->biSizeImage = 0;\
    pbmi->biXPelsPerMeter = 0;\
    pbmi->biYPelsPerMeter = 0;\
    pbmi->biClrUsed = 0;\
    pbmi->biClrImportant = 0;\
}

#define BMI_Create( bmi, bits )     { (bits) = calloc( BMI_LineSize(bmi), BMI_High(bmi) ); }

#define BMI_Release( bmi, bits )    { free( bits ); }

/*
 * Iterate each row of BMI as RGBQUAD data
 */
#define BMI_foreach( bmi, bits, pixel ) \
    RGBQUAD pixel##_buff[2048];\
    int pixel##_row;\
    const RGBQUAD* pixel##_end = pixel##_buff + BMI_Wide(bmi);\
    RGBQUAD* pixel;\
    assert( BMI_Wide(bmi) < countof(pixel##_buff) );\
    for( pixel##_row = 0; BMI_ReadRow( pixel##_buff, bmi, bits, pixel##_row ); ++pixel##_row )\
    for( pixel = pixel##_buff; pixel < pixel##_end; ++pixel )\

int RGBQUAD_Nearest( const RGBQUAD* clut, size_t count, const RGBQUAD* color );
bool BMI_ReadRow( RGBQUAD* pixel, const BITMAPINFO* bmi, const void* bits, int row );
bool BMI_WriteRow( const BITMAPINFO* bmi, void* bits, const RGBQUAD* pixel, int row );
void BMI_Translate( const BITMAPINFO* dst, void* bdst, const BITMAPINFO* src, const void* bsrc );
void* BMI_Unpack( const BITMAPINFO* bmi, const void* bits );
size_t BMI_MakeClut( RGBQUAD* dstlut, size_t clut, const BITMAPINFO* bmi, const void* bits );

struct BMIClutEntry
{
    uint32  count;
    RGBQUAD rgb;
};
typedef struct BMIClut
{
    struct BMIClutEntry cluts[32768];
} BMIClut;
void BMI_Clut_Begin( BMIClut* clut );
void BMI_Clut_AddColor( BMIClut* clut, const RGBQUAD* rgb );
size_t BMI_Clut_Make( BMIClut* clut, RGBQUAD* dstlut, size_t cClut );

bool BMI_Save( const char* path, const BITMAPINFO* bmi, const void* bits );
bool BMI_Load( const char* path, BITMAPINFO** bmi, void** bits );
/*
 * Bind BMP to OPC library
 */
void BMI_OPC( OPC* opc, const BITMAPINFO* bmi, void* bits );