bmp.h File Reference

Simple windows bitmap handling. More...

#include "opc/opc.h"
#include "ctl/ctldef.h"

Include dependency graph for bmp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	BMI_SIZE   (sizeof(BITMAPINFO) + (255 * sizeof(RGBQUAD)))
#define	BMI_ParseData(image, bmi, bits)
	Given a pointer to a bitmap loaded into memory, find bmi, bits NOTE: Only valid on Wintel architecture.
#define	BMI_Init(bmi, wide, high, bpp)
	Initialize bmi as generic Windows bitmap.
#define	BMI_Create(bmi, bits)   { (bits) = calloc( BMI_LineSize(bmi), BMI_High(bmi) ); }
	Allocate a bitmap for 'bmi'.
#define	BMI_Release(bmi, bits)   { free( bits ); }
	Free image allocated with BMI_Create.
Functions
int	RGBQUAD_Nearest (const RGBQUAD *clut, size_t count, const RGBQUAD *color)
	Work out the best match in 'clut'.
bool	BMI_ReadRow (RGBQUAD *pixel, const BITMAPINFO *bmi, const void *bits, int row)
	Get color values from each pixel in a row of bmi/bits as an RGBQUAD Half of translation from one BMI format to another.
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)
	Copy/Translate src bitmap to target bitmap.
void *	BMI_Unpack (const BITMAPINFO *bmi, const void *bits)
	Unpack certain BMP formats.
size_t	BMI_MakeClut (RGBQUAD *dstlut, size_t clut, const BITMAPINFO *bmi, const void *bits)
	Build a color lookup table of a given size from true-color source pixels Truly an ugly and time-consuming ordeal, but this should make it "simple", or at least less horrible.
void	BMI_Clut_Begin (BMIClut *clut)
	Prepare palette accumulator for new data.
void	BMI_Clut_AddColor (BMIClut *clut, const RGBQUAD *rgb)
	Add a color to the accumulator.
size_t	BMI_Clut_Make (BMIClut *clut, RGBQUAD *dstlut, size_t cClut)
	Manufacutre the palette.
bool	BMI_Save (const char *path, const BITMAPINFO *bmi, const void *bits)
	Save a bitmap.
bool	BMI_Load (const char *path, BITMAPINFO **bmi, void **bits)
	Load a bitmap.
void	BMI_OPC (OPC *opc, const BITMAPINFO *bmi, void *bits)
	Convert bmi,bits to native OPC NOTE: Assumes OPC is same format as bmi,bits.

---

Detailed Description

Simple windows bitmap handling.

Author:

David Mace

Definition in file bmp.h.

---

Define Documentation

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

Allocate a bitmap for 'bmi'.

Parameters:

	bmi	Pointer to BITMAPINFO to containing description of bitmap
	bits	void Pointer to receive bitmap

Definition at line 160 of file bmp.h.

#define BMI_Init	(	bmi,
		wide,
		high,
		bpp		)

Value:

{\
    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;\
}

Initialize bmi as generic Windows bitmap.

Parameters:

	bmi	Pointer to BITMAPINFO to initialize
	wide	Width of bmp
	high	Height of bmp
	bpp	Bits per pixel, i.e. 1,4,8,16,24,32

Definition at line 140 of file bmp.h.

#define BMI_ParseData	(	image,
		bmi,
		bits		)

Value:

{\
    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 );\
    }\
}

Given a pointer to a bitmap loaded into memory, find bmi, bits NOTE: Only valid on Wintel architecture.

Parameters:

	image	Pointer to image to parse
	bmi	BITMAPINFO Pointer to be initialized
	bits	Pixel data

Definition at line 118 of file bmp.h.

Referenced by BMI_Load().

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

Free image allocated with BMI_Create.

Parameters:

	bmi	Pointer to BITMAPINFO to containing description of bitmap
	bits	Bits to free, allocated with BMI_Create

Definition at line 166 of file bmp.h.

#define BMI_SIZE   (sizeof(BITMAPINFO) + (255 * sizeof(RGBQUAD)))

defined(_WINGDI_)

Definition at line 82 of file bmp.h.

---

Function Documentation

void BMI_Clut_AddColor	(	BMIClut *	clut,
		const RGBQUAD *	rgb
	)

Add a color to the accumulator.

Parameters:

	clut	Instance of clut
	rgb	Color to add

Definition at line 486 of file bmp.c.

References type_max.

Referenced by BMI_MakeClut().

{
    #define CLI(RGBQUAD) ( (((RGBQUAD).rgbBlue&0xf8)>>3) | (((RGBQUAD).rgbGreen&0xf8)<<2) | (((RGBQUAD).rgbRed&0xf8)<<7) )
    int index = CLI(*rgb);
    struct BMIClutEntry* curr = clut->cluts + index;
    curr->rgb = *rgb;
    if( curr->count < type_max(uint32) )
        curr->count++;
}

void BMI_Clut_Begin

(

BMIClut *

clut

)

Prepare palette accumulator for new data.

Parameters:

clut

Instance of clut to initialize

Definition at line 477 of file bmp.c.

Referenced by BMI_MakeClut().

{
    memset( clut->cluts, 0, sizeof(clut->cluts) );
}

size_t BMI_Clut_Make	(	BMIClut *	clut,
		RGBQUAD *	dstlut,
		size_t	cClut
	)

Manufacutre the palette.

Parameters:

	clut	Instance of clut
	dstlut	Array to receive official colors
	cClut	Number of colors array will accept

Definition at line 532 of file bmp.c.

References array_qsort, and countof.

Referenced by BMI_MakeClut().

{
    array_qsort( struct BMIClutEntry, clut->cluts, countof(clut->cluts), qsclutz );
    array_qsort( struct BMIClutEntry, clut->cluts, cClut, qspretty );
    {
        const struct BMIClutEntry* curr = clut->cluts;
        size_t remain = cClut;
        while( remain )
        {
            remain--;
            if( curr->count )
                *dstlut++ = (curr++)->rgb;
            else
                break;
        }
        cClut -= remain;
        return cClut;
    }
}

bool BMI_Load	(	const char *	path,
		BITMAPINFO **	bmi,
		void **	bits
	)

Load a bitmap.

Parameters:

	path	Path to reat file from
	bmi	Pointer to pointer to receive bitmap header
	bits	Pointer to pointer to receive bitmap content

Definition at line 735 of file bmp.c.

References BMI_ParseData, BMI_Unpack(), and ctl_mmap_open().

{
    /*
     * TODO: Replace with target independent code
     */
    ctl_mmap image;
    ctl_mmap_open( &image, path );
    if( ctl_mmap_ready(&image) )
    {
        const BITMAPINFO* bmiIn;
        const void* bitsIn;
        BMI_ParseData( ctl_mmap_ptr(&image), bmiIn, bitsIn );
        *bmi = BMI_BMI_Copy(bmiIn);
        *bits = BMI_Unpack( bmiIn, bitsIn );
        return true;
    }
    return false;
}

Here is the call graph for this function:

size_t BMI_MakeClut	(	RGBQUAD *	dstlut,
		size_t	cClut,
		const BITMAPINFO *	bmi,
		const void *	bits
	)

Build a color lookup table of a given size from true-color source pixels Truly an ugly and time-consuming ordeal, but this should make it "simple", or at least less horrible.

Parameters:

	dstlut	Buffer to receive color lookup table (sorted most to least popular)
	cClut	Maximum count of colors to match up
	bmi	BITMAPINFO we're generating a CLUT from
	bits	Bitmap data

Returns:

count of colors actually produced (<= clut)

Definition at line 462 of file bmp.c.

References BMI_Clut_AddColor(), BMI_Clut_Begin(), and BMI_Clut_Make().

{
    BMIClut clutz;
    BMI_Clut_Begin( &clutz );
    {
        BMI_foreach( bmi, bits, pixel )
            BMI_Clut_AddColor( &clutz, pixel );
    }
    return BMI_Clut_Make( &clutz, dstlut, cClut );
}

Here is the call graph for this function:

void BMI_OPC	(	OPC *	opc,
		const BITMAPINFO *	bmi,
		void *	bits
	)

Convert bmi,bits to native OPC NOTE: Assumes OPC is same format as bmi,bits.

Parameters:

	opc	OPC to be filled in with data from bmi, bits
	bmi	BITMAPINFO describing size/format of data
	bits	Pointer to pixel data

Definition at line 20 of file bmp.c.

References Rect::bottom, OPC::clip, Rect::left, OPC::origin, OPC::pitch, Rect::right, and Rect::top.

{
    OPC* out = (opc);
    const BITMAPINFO* bmin = (bmi);
    out->origin = (uint8*)BMI_Origin(bmin,bits);
    out->pitch = BMI_LineOffset(bmin);
    out->clip.left = out->clip.top = 0;
    out->clip.right = BMI_Wide(bmin);
    out->clip.bottom = BMI_High(bmin);
}

bool BMI_ReadRow	(	RGBQUAD *	pixel,
		const BITMAPINFO *	bmi,
		const void *	bits,
		int	row
	)

Get color values from each pixel in a row of bmi/bits as an RGBQUAD Half of translation from one BMI format to another.

Parameters:

	pixel	Buffer to receive pixels, must have at least BMI_Wide(bmi) members
	bmi	bitmap header
	bits	bitmap content
	row	Row from bitmap to get data from

Returns:

true if data was actually read, false (and pixel buffer filled black) if not

Definition at line 100 of file bmp.c.

References assert.

Referenced by BMI_Translate().

{
    /* Don't choke on bad row */
    assert(bmi);
    assert(bits);
    if( row < 0 || row >= BMI_High(bmi) || (bmi->bmiHeader.biCompression != BI_RGB && bmi->bmiHeader.biCompression != BI_BITFIELDS && bmi->bmiHeader.biCompression != BI_RLE4 && bmi->bmiHeader.biCompression != BI_RLE8) )
    {
        memset( pixel, 0, sizeof(RGBQUAD)*BMI_Wide(bmi) );
        return false;
    }
    switch( bmi->bmiHeader.biBitCount )
    {
    case 1:
        {
            const RGBQUAD* colors = BMI_ColorData(bmi);
            const uint8* pixels = (const uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen )
            {
                uint8 bit = 0x80;
                while( bit && wordlen )
                {
                    *pixel++ = colors[0 != (*pixels & bit)];
                    wordlen--;
                    bit >>= 1;
                }
                pixels++;
            }
        }
        return true;

    case 4:
        {
            const RGBQUAD* colors = BMI_ColorData(bmi);
            const uint8* pixels = (const uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            int curr;
            for( curr = 0; curr < wordlen; ++curr )
            {
                if( curr&1 )
                {
                    *pixel++ = colors[*pixels&0xf];
                    pixels++;
                }
                else
                {
                    *pixel++ = colors[(*pixels>>4)&0xf];
                }
            }
        }
        return true;

    case 8:
        {
            const RGBQUAD* colors = BMI_ColorData(bmi);
            const uint8* pixels = (const uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
                *pixel++ = colors[*pixels++];
        }
        return true;

    case 16:
        if( bmi->bmiHeader.biCompression == BI_BITFIELDS )
        {
            const uint32* masks = (const uint32*)BMI_ColorData(bmi);
            uint16 mRed = (uint16)masks[0];
            uint16 mGreen = (uint16)masks[1];
            uint16 mBlue = (uint16)masks[2];
            int bRed = lsb(mRed);
            int bGreen = lsb(mGreen);
            int bBlue = lsb(mBlue);
            int nRed = nbits( mRed );
            int nGreen = nbits( mGreen );
            int nBlue = nbits( mBlue );
            const uint16* pixels = (const uint16*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                pixel->rgbBlue = (uint8)(((mBlue & *pixels) >> bBlue) << (8-nBlue));
                pixel->rgbGreen = (uint8)(((mGreen & *pixels) >> bGreen) << (8-nGreen));
                pixel->rgbRed = (uint8)(((mRed & *pixels) >> bRed) << (8-nRed));
                pixel->rgbReserved = 0;
                pixel++;
                pixels++;
            }
        }
        else
        {
            const uint16* pixels = (const uint16*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                pixel->rgbBlue = (uint8)((*pixels & 0x1f) << 3);
                pixel->rgbGreen = (uint8)(((*pixels >> 5) & 0x1f) << 3);
                pixel->rgbRed = (uint8)(((*pixels >> 10) & 0x1f) << 3);
                pixel->rgbReserved = 0;
                pixels++;
                pixel++;
            }
        }
        return true;

    case 24:
        {
            const uint8* pixels = (const uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                pixel->rgbBlue = *pixels++;
                pixel->rgbGreen = *pixels++;
                pixel->rgbRed = *pixels++;
                pixel->rgbReserved = 0;
                pixel++;
            }
        }
        return true;

    case 32:
        if( bmi->bmiHeader.biCompression == BI_BITFIELDS )
        {
            const uint32* masks = (const uint32*)BMI_ColorData(bmi);
            uint32 mRed = (uint32)masks[0];
            uint32 mGreen = (uint32)masks[1];
            uint32 mBlue = (uint32)masks[2];
            int bRed = lsb(mRed);
            int bGreen = lsb(mGreen);
            int bBlue = lsb(mBlue);
            int nRed = nbits( mRed );
            int nGreen = nbits( mGreen );
            int nBlue = nbits( mBlue );
            const uint32* pixels = (const uint32*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                pixel->rgbBlue = (uint8)(((mBlue & *pixels) >> bBlue) << (8-nBlue));
                pixel->rgbGreen = (uint8)(((mGreen & *pixels) >> bGreen) << (8-nGreen));
                pixel->rgbRed = (uint8)(((mRed & *pixels) >> bRed) << (8-nRed));
                pixel->rgbReserved = 0;
                pixels++;
                pixel++;
            }
        }
        else
        {
            const uint8* pixels = (const uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                pixel->rgbBlue = *pixels++;
                pixel->rgbGreen = *pixels++;
                pixel->rgbRed = *pixels++;
                pixel->rgbReserved = 0;
                pixel++;
                pixels++;
            }
        }
        return true;

    default:
        break;
    }
    return false;
}

bool BMI_Save	(	const char *	path,
		const BITMAPINFO *	bmi,
		const void *	bits
	)

Save a bitmap.

Parameters:

	path	Path to write file to
	bmi	bitmap header
	bits	bitmap content

Definition at line 677 of file bmp.c.

References assert.

{
    /*
     * TODO: Replace with target independent code
     */
    /* Save BMI/bits as a BITMAP */
    FILE *fp = fopen( path, "wb" );
    assert( bmi );
    assert( bits );
    assert( bmi->bmiHeader.biWidth > 0 );
    assert( bmi->bmiHeader.biHeight );
    if( fp )
    {
        BITMAPFILEHEADER bmf;
        bmf.bfType = *((uint16 *)"BM");
        bmf.bfSize = sizeof(bmf) + BMI_BMI_Size(bmi) + BMI_BitmapSize(bmi);
        bmf.bfReserved1 = 0;
        bmf.bfReserved2 = 0;
        bmf.bfOffBits = sizeof(bmf) + BMI_BMI_Size(bmi);
        if( 1 != fwrite( &bmf, sizeof(bmf), 1, fp ) )
        {
            fclose( fp );
            return false;
        }
        {
            /* Tell it form is 'rightside up' */
            BITMAPINFO *bmiScratch = BMI_Alloc();
            memcpy( bmiScratch, bmi, BMI_BMI_Size(bmi) );
            bmiScratch->bmiHeader.biHeight = abs(bmiScratch->bmiHeader.biHeight);
            if( 1 != fwrite( bmiScratch, BMI_BMI_Size(bmiScratch), 1, fp ) )
            {
                fclose( fp );
                return false;
            }
            BMI_Free(bmiScratch);
        }
        {
            /* Always write image upside-down */
            int line = BMI_High(bmi);
            while( line-- )
            {
                if( 1 != fwrite( BMI_LinePtr(bmi,bits,line), BMI_LineSize(bmi), 1, fp ) )
                    break;
            }
        }
        fclose( fp );
        return true;
    }
    return false;
}

void BMI_Translate	(	const BITMAPINFO *	dst,
		void *	bdst,
		const BITMAPINFO *	src,
		const void *	bsrc
	)

Copy/Translate src bitmap to target bitmap.

Parameters:

	dst	Destination bitmap definition
	bdst	Destination bitmap data
	src	Source bitmap definition
	bsrc	Source bitmap data

Definition at line 560 of file bmp.c.

References BMI_ReadRow(), and BMI_WriteRow().

{
    RGBQUAD* colors = (RGBQUAD*)malloc( sizeof(RGBQUAD) * max(BMI_Wide(dst),BMI_Wide(src)) );
    int rowCurr = min( BMI_High(dst), BMI_High(src) );
    while( rowCurr-- )
    {
        BMI_ReadRow( colors, src, bsrc, rowCurr );
        BMI_WriteRow( dst, bdst, colors, rowCurr );
    }
    free(colors);
}

Here is the call graph for this function:

void* BMI_Unpack	(	const BITMAPINFO *	bmi,
		const void *	bits
	)

Unpack certain BMP formats.

Parameters:

	bmi	Describes BMP format
	bits	(Presumably) packed source data

Returns:

New (unpacked) image, and modifies bmi to 'unpacked' version, or NULL if unmodified/unhandled

Definition at line 579 of file bmp.c.

Referenced by BMI_Load().

{
    switch( bmi->bmiHeader.biCompression )
    {
    default:
    case BI_BITFIELDS:
    case BI_RGB:
        return NULL;

    case BI_RLE4:
    case BI_RLE8:
        {
            size_t current = BMI_BitmapSize(bmi);
            size_t lineSize = BMI_LineSize(bmi);
            size_t needs = lineSize * BMI_High(bmi);
            void* ret = malloc(needs);
            const uint8* pSrc = (const uint8*)bits;
            const uint8* pEnd = pSrc + current;
            uint8* pDstEdge = (uint8*)ret;
            uint8* pDst = pDstEdge;
            const uint8* pdEnd = pDst + needs;
            while( pSrc < pEnd )
            {
                int count = *pSrc++;
                if( count )
                {
                    uint8 fill = *pSrc++;
                    count = min(count,(int)(pdEnd-pDst));
                    if( bmi->bmiHeader.biCompression == BI_RLE8 )
                    {
                        memset( pDst, fill, count );
                        pDst += count;
                    }
                    else
                    {
                        count>>=1;
                        memset( pDst, fill, count );
                        pDst += count;
                    }
                }
                else /* Escape */
                {
                    count = *pSrc++;    /* Get code */
                    if( count == 0 )
                    {
                        pDst = pDstEdge += lineSize;
                    }
                    else if( count == 1 )
                        break;
                    else if( count == 2 )
                    {
                        int x = *pSrc++;
                        int y = *pSrc++;
                        pDstEdge += (lineSize*y);
                        pDst = pDstEdge + x;
                    }
                    else
                    {
                        count = min(count,(int)(pdEnd-pDst));
                        count = min(count,(int)(pEnd-pSrc));
                        if( bmi->bmiHeader.biCompression == BI_RLE4 )
                        {
                            memcpy( pDst, pSrc, count>>1 );
                            pDst += count>>1;
                            pSrc += count;
                        }
                        else
                        {
                            memcpy( pDst, pSrc, count );
                            pDst += count;
                            pSrc += count;
                        }
                        /* Read mysterious excess byte */
                        if( bmi->bmiHeader.biCompression == BI_RLE8 )
                        {
                            if( count & 1 )
                                pSrc++;
                        }
                        else
                        {
                            if( (count & 3) == 1 || (count & 3) == 2 )
                                pSrc++;
                        }
                    }
                }
            }
            return ret;
        }
        break;
    }
}

bool BMI_WriteRow	(	const BITMAPINFO *	bmi,
		void *	bits,
		const RGBQUAD *	pixel,
		int	row
	)

Set color values from a line of RGBQUADs to whatever format map Half of translation from one BMI format to another

Parameters:

	pixel	Buffer containing colors to write, must have at least BMI_Wide(bmi) members
	bmi	bitmap header
	bits	bitmap content
	row	Row in bitmap to put data in

Returns:

true if data was actually written, false if not

Definition at line 275 of file bmp.c.

References assert, and RGBQUAD_Nearest().

Referenced by BMI_Translate().

{
    /* Don't choke on bad row */
    assert(bmi);
    assert(bits);
    if( row < 0 || row >= BMI_High(bmi) || (bmi->bmiHeader.biCompression != BI_RGB && bmi->bmiHeader.biCompression != BI_BITFIELDS) )
    {
        return false;
    }
    switch( bmi->bmiHeader.biBitCount )
    {
    case 1:
        {
            /* 1 bit color indexes */
            const RGBQUAD* colors = BMI_ColorData(bmi);
            uint8* pixels = (uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen )
            {
                uint8 bit = 0x80;
                *pixels = 0;
                while( bit && wordlen )
                {
                    if( RGBQUAD_Nearest( colors, 2, pixel++ ) )
                        *pixels |= bit;
                    bit>>=1;
                    wordlen--;
                }
                pixels++;
            }
        }
        return true;

    case 4:
        {
            const RGBQUAD* colors = BMI_ColorData(bmi);
            uint8* pixels = (uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            int curr;
            for( curr = 0; curr < wordlen; ++curr )
            {
                unsigned index = (unsigned)RGBQUAD_Nearest( colors, 16, pixel++ );
                if( wordlen & 1 )
                    *pixels++ = (uint8)index;
                else
                    *pixels |= (uint8)(index<<4);
            }
        }
        return true;

    case 8:
        {
            /* 8 bit color indexes */
            const RGBQUAD* colors = BMI_ColorData(bmi);
            uint8* pixels = (uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
                *pixels++ = (uint8)RGBQUAD_Nearest( colors, 256, pixel++ );
        }
        return true;

    case 16:
        if( bmi->bmiHeader.biCompression == BI_BITFIELDS )
        {
            /* 16 bit masks */
            const uint32* masks = (const uint32*)BMI_ColorData(bmi);
            uint16 mRed = (uint16)masks[0];
            uint16 mGreen = (uint16)masks[1];
            uint16 mBlue = (uint16)masks[2];
            int bRed = lsb(mRed);
            int bGreen = lsb(mGreen);
            int bBlue = lsb(mBlue);
            int nRed = nbits( mRed );
            int nGreen = nbits( mGreen );
            int nBlue = nbits( mBlue );
            uint16* pixels = (uint16*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                *pixels = 0;
                *pixels |= (((uint16)pixel->rgbBlue & ((1<<nBlue)-1)) >> (8-nBlue)) << bBlue;
                *pixels |= (((uint16)pixel->rgbGreen & ((1<<nGreen)-1)) >> (8-nGreen)) << bGreen;
                *pixels |= (((uint16)pixel->rgbRed & ((1<<nRed)-1)) >> (8-nRed)) << bRed;
                pixel++;
                pixels++;
            }
        }
        else
        {
            /* lsb 5 bits of blue, green, red, msb=0 */
            uint16* pixels = (uint16*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                *pixels = 0;
                *pixels |= ((uint16)pixel->rgbBlue & 0xf8) >> 3;
                *pixels |= ((uint16)pixel->rgbGreen & 0xf8) << 2;
                *pixels |= ((uint16)pixel->rgbRed & 0xf8) << 7;
                pixels++;
                pixel++;
            }
        }
        return true;

    case 24:
        {
            /* 24 bits of blue,green,red */
            uint8* pixels = (uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                *pixels++ = pixel->rgbBlue;
                *pixels++ = pixel->rgbGreen;
                *pixels++ = pixel->rgbRed;
                pixel++;
            }
        }
        return true;

    case 32:
        if( bmi->bmiHeader.biCompression == BI_BITFIELDS )
        {
            /* 32 bit masks */
            const uint32* masks = (const uint32*)BMI_ColorData(bmi);
            uint32 mRed = (uint32)masks[0];
            uint32 mGreen = (uint32)masks[1];
            uint32 mBlue = (uint32)masks[2];
            int bRed = lsb(mRed);
            int bGreen = lsb(mGreen);
            int bBlue = lsb(mBlue);
            int nRed = nbits( mRed );
            int nGreen = nbits( mGreen );
            int nBlue = nbits( mBlue );
            uint32* pixels = (uint32*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                *pixels = 0;
                *pixels |= (((uint32)pixel->rgbBlue & ((1<<nBlue)-1)) >> (8-nBlue)) << bBlue;
                *pixels |= (((uint32)pixel->rgbGreen & ((1<<nGreen)-1)) >> (8-nGreen)) << bGreen;
                *pixels |= (((uint32)pixel->rgbRed & ((1<<nRed)-1)) >> (8-nRed)) << bRed;
                pixel++;
                pixels++;
            }
        }
        else
        {
            /* Default is 8 bits each of blue, green, red */
            uint8* pixels = (uint8*)BMI_LinePtr(bmi,bits,row);
            int wordlen = BMI_Wide(bmi);
            while( wordlen-- )
            {
                *pixels++ = pixel->rgbBlue;
                *pixels++ = pixel->rgbGreen;
                *pixels++ = pixel->rgbRed;
                *pixels++ = 0;
                pixel++;
            }
        }
        return true;

    default:
        break;
    }
    return false;
}

Here is the call graph for this function: