source: PlatformSupport/User_IO/bmp16_to_rgb8/bmp16_to_rgb8.c

/* This program converts a 128x128 16-bit color BMP image to a 128x128 8-bit RGB array of pixel values
 * suitable for use on the WARP User I/O Board's LCD screen. It produces two output formats; for both formats
 * the pixles are re-arranged into 256 64-pixel blocks to accomodate the User I/O board controller's
 * character map pixel ordering.
 * 
 * See http://warp.rice.edu/trac/wiki/HardwareUsersGuides/UserIOBoard_v1.0/LCD for details
 * 
 * Output formats:
 * RGB: a binary file with exactly 128*128 1-byte pixel values (16KB); each pixel is stored as [RRRGGGBB]
 * C Header: a header file with  one variable (unsigned char imgArray[16384] defined)
 * 
 * This program has been tested on Mac OS X 10.5.4. It should work on any Unix-ish OS.
 * 
 * This code is not thoroughly tested, nor is it guaranteed error-free or even safe. Use it at your own risk.
 * 
 * This code is available under the Rice WARP license. See http://warp.rice.edu/license for details.
*/

#include <stdio.h>

#define BMP16_NUM_HEADER_BYTES 54

#define PIXCONV_RED_5b_TO_3b(c) ( (c>>12)&0x7 )
#define PIXCONV_GREEN_5b_TO_3b(c) ( (c>>7)&0x7 )
#define PIXCONV_BLUE_5b_TO_2b(c) ( (c>>3)&0x3 )

#define PIXCONV_16b_TO_8b(c) ( 0xFF & ( (PIXCONV_RED_5b_TO_3b(c)<<5) | (PIXCONV_GREEN_5b_TO_3b(c)<<2) | PIXCONV_BLUE_5b_TO_2b(c) ))

void print_usage(char* progName);

int main(int argc, char * argv[])
{
    int i, j, k, m, n;

    FILE *fp_in, *fp_outBin, *fp_outHeader;
    size_t bytesRead, bytesWritten;

    unsigned char outputHeader;
    
    unsigned char img_header[BMP16_NUM_HEADER_BYTES];
    
    unsigned short img_orig[128*128];
    unsigned char img_rgb8[128*128];

    //Check the command line arguments
    if(argc < 3 | argc > 4)
    {
        printf("Bad input arguments!\n");
        print_usage(argv[0]);
        return -1;
    }

    if(argc == 3)
    {
        //User specified an input file and output RGB file; don't print the C header file
        fp_in = fopen(argv[1], "r+b");
        fp_outBin = fopen(argv[2], "w+b");
        outputHeader = 0;
    }

    if(argc == 4)
    {
        //User specified an input file, output RGB file and output C header file
        fp_in = fopen(argv[1], "r+b");
        fp_outBin = fopen(argv[2], "w+b");
        fp_outHeader = fopen(argv[3], "w+");
        outputHeader = 1;
    }

    bytesRead = fread(&img_header, 1, BMP16_NUM_HEADER_BYTES, fp_in);
    if(bytesRead != BMP16_NUM_HEADER_BYTES)
    {
        printf("Error! - not enough bytes for the header\n");
        return -1;
    }

    bytesRead = fread(&img_orig, sizeof(short), 128*128, fp_in);
    if(bytesRead != (128*128))
    {
        printf("Error! - not enough bytes of image data (read %d)\n", bytesRead);
        return -1;
    }

    fclose(fp_in);

    //Now img_orig is a 128x128 array of 16-bit pixel values
    //We need an array of 16x16 64-pixel blocks, with each pixel occuping 1 byte
    //This is probably a really inefficient way to implement this re-ordering
    // but for 16K entries on a fast PC, who cares?
    m = 0;
    for(i=15; i>=0; i--)//Count down, since BMP files are stored last-line-first
    {
        for(j=0; j<16; j++)
        {
            for(k=7; k>=0; k--)//Count down, since BMP files are stored last-line-first
            {
                for(n=0; n<8; n++)
                {
                    img_rgb8[m++] = (unsigned char)PIXCONV_16b_TO_8b(img_orig[i*1024 + j*8 + k*128 + n]);
                }
            }
        }
    }

    if(outputHeader)
    {
        fprintf(fp_outHeader, "/***START imgArray ***/\nunsigned char imgArray[16384] = {");

        for(i=0; i<16384; i++)
        {
            fprintf(fp_outHeader, "0x%x", img_rgb8[i]);
            if(i < 16383) fprintf(fp_outHeader, ",");
            if(i!=0 & i%128==0) fprintf(fp_outHeader, "\n");
        }
        fprintf(fp_outHeader, "};\n/***END imgArray ***/\n");

        fclose(fp_outHeader);
    }

    bytesWritten = fwrite(&img_rgb8, 1, 128*128, fp_outBin);
    fclose(fp_outBin);

    if(bytesWritten != (128*128))
    {
        printf("Error! - not enough bytes of image data written (wrote %d)\n", bytesWritten);
        return -1;
    }

    //Return successfully
    return 0;
}

void print_usage(char* progName)
{
    printf("Usage: %s inputBitmap.bmp outputBinary.rgb <outputHeader.h>\n", progName);
}