//
// bmp.cpp - source file / freeware
//
// David Henry - tfc_duke@hotmail.com
//
#include "bmp.h"
#include <stdio.h>
#include <libc/stubs.h>
extern "C"{
long filelength(int fhandle);
}
// --------------------------------------------------
// LoadFileBMP() - load a Windows/OS2 BITMAP image
// [.bmp].
//
// parameters :
// - filename [in] : image source file
// - pixels [out] : 32 bits rgb image data
// - width [out] : image width in pixels
// - height [out] : image height in pixels
// - flipvert [in] : flip vertically
//
// return value :
// - -1 : no image data
// - 0 : failure
// - 1 : success
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// accepted image formats :
// # RGB 1-4-8-24-32 bits WINDOWS - OS/2
// # RLE 4-8 bits WINDOWS
// --------------------------------------------------
int LoadFileBMP( const char *filename, unsigned char **pixels, int *width, int *height, bool flipvert )
{
FILE *file; // file stream
BITMAPFILEHEADER *bmfh; // bitmap file header
BITMAPINFOHEADER *bmih; // bitmap info header (windows)
BITMAPCOREHEADER *bmch; // bitmap core header (os/2)
RGBTRIPLE *os2_palette; // pointer to the color palette os/2
RGBQUAD *win_palette; // pointer to the color palette windows
char *buffer; // buffer storing the entire file
unsigned char *ptr; // pointer to pixels data
int bitCount; // number of bits per pixel
int compression; // compression type (rgb/rle)
int row, col, i; // temporary variables
int w, h; // width, height
/////////////////////////////////////////////////////
// read the entire file in the buffer
file = fopen(filename,"rb");
if( !file)
return 0;
long flen = filelength(fileno(file));
buffer = new char[ flen + 1 ];
int rd = fread(buffer, flen, 1, file);
char *pBuff = buffer;
fclose(file);
/////////////////////////////////////////////////////
// read the header
bmfh = (BITMAPFILEHEADER *)pBuff;
pBuff += sizeof( BITMAPFILEHEADER );
// verify that it's a BITMAP file
if( bmfh->bfType != BITMAP_ID )
{
delete [] buffer;
return 0;
}
bmch = (BITMAPCOREHEADER *)pBuff;
bmih = (BITMAPINFOHEADER *)pBuff;
if( (bmih->biCompression < 0) || (bmih->biCompression > 3) )
{
// OS/2 style
pBuff += sizeof( BITMAPCOREHEADER );
bitCount = bmch->bcBitCount;
compression = BI_OS2;
w = bmch->bcWidth;
h = bmch->bcHeight;
}
else
{
// WINDOWS style
pBuff += sizeof( BITMAPINFOHEADER );
bitCount = bmih->biBitCount;
compression = bmih->biCompression;
w = bmih->biWidth;
h = bmih->biHeight;
}
if( width )
*width = w;
if( height )
*height = h;
if( !pixels )
{
delete [] buffer;
return (-1);
}
/////////////////////////////////////////////////////
// read the palette
if( bitCount <= 8 )
{
// 24 and 32 bits images are not paletted
// ajust the palette pointer to the memory in the buffer
os2_palette = (RGBTRIPLE *)pBuff;
win_palette = (RGBQUAD *)pBuff;
// [number of colors in the palette] * [size of one pixel]
pBuff += (1 << bitCount) * (bitCount >> 3) * sizeof( unsigned char );
}
/////////////////////////////////////////////////////
// allocate memory to store pixel data
*pixels = new unsigned char[ w * h * 3 ];
ptr = &(*pixels)[0];
// move the pixel data pointer to the begening of bitmap data
pBuff = buffer + (bmfh->bfOffBits * sizeof( char ));
/////////////////////////////////////////////////////
// read pixel data following the image compression
// type and the number of bits per pixels
/////////////////////////////////////////////////////
switch( compression )
{
case BI_OS2:
case BI_RGB:
{
for( row = h - 1; row >= 0; row-- )
{
if( flipvert )
ptr = &(*pixels)[ row * w * 3 ];
switch( bitCount )
{
case 1:
{
// RGB 1 BITS
for( col = 0; col < (int)(w / 8); col++ )
{
// read the current pixel
unsigned char color = *((unsigned char *)(pBuff++));
for( i = 7; i >= 0; i--, ptr += 3 )
{
// convert indexed pixel (1 bit) into rgb (32 bits) pixel
int clrIdx = ((color & (1<<i)) > 0);
if( compression == BI_OS2 )
{
ptr[2] = os2_palette[ clrIdx ].rgbtRed;
ptr[1] = os2_palette[ clrIdx ].rgbtGreen;
ptr[0] = os2_palette[ clrIdx ].rgbtBlue;
}
else
{
ptr[2] = win_palette[ clrIdx ].rgbRed;
ptr[1] = win_palette[ clrIdx ].rgbGreen;
ptr[0] = win_palette[ clrIdx ].rgbBlue;
}
}
}
break;
}
case 4:
{
// RGB 4 BITS
for( col = 0; col < (int)(w / 2); col++, ptr += 6 )
{
// read the current pixel
unsigned char color = *((unsigned char *)(pBuff++));
// convert indexed pixel (4 bits) into rgb (32 bits) pixel
int clrIdx;
if( compression == BI_OS2 )
{
clrIdx = (color >> 4);
ptr[2] = os2_palette[ clrIdx ].rgbtRed;
ptr[1] = os2_palette[ clrIdx ].rgbtGreen;
ptr[0] = os2_palette[ clrIdx ].rgbtBlue;
clrIdx = (color & 0x0F);
ptr[6] = os2_palette[ clrIdx ].rgbtRed;
ptr[5] = os2_palette[ clrIdx ].rgbtGreen;
ptr[4] = os2_palette[ clrIdx ].rgbtBlue;
}
else
{
clrIdx = (color >> 4);
ptr[2] = win_palette[ clrIdx ].rgbRed;
ptr[1] = win_palette[ clrIdx ].rgbGreen;
ptr[0] = win_palette[ clrIdx ].rgbBlue;
clrIdx = (color & 0x0F);
ptr[6] = win_palette[ clrIdx ].rgbRed;
ptr[5] = win_palette[ clrIdx ].rgbGreen;
ptr[4] = win_palette[ clrIdx ].rgbBlue;
}
}
break;
}
case 8:
{
// RGB 8 BITS
for( col = 0; col < w; col++, ptr += 3 )
{
// read the current pixel
unsigned char color = *((unsigned char *)(pBuff++));
// convert indexed pixel (8 bits) into rgb (32 bits) pixel
if( compression == BI_OS2 )
{
ptr[2] = os2_palette[ color ].rgbtRed;
ptr[1] = os2_palette[ color ].rgbtGreen;
ptr[0] = os2_palette[ color ].rgbtBlue;
}
else
{
ptr[2] = win_palette[ color ].rgbRed;
ptr[1] = win_palette[ color ].rgbGreen;
ptr[0] = win_palette[ color ].rgbBlue;
}
}
break;
}
case 24:
{
// RGB 24 BITS
for( col = 0; col < w; col++, ptr += 3 )
{
// convert bgr pixel (24 bits) into rgb (32 bits) pixel
RGBTRIPLE *pix = (RGBTRIPLE *)pBuff;
pBuff += sizeof( RGBTRIPLE );
ptr[2] = pix->rgbtRed;
ptr[1] = pix->rgbtGreen;
ptr[0] = pix->rgbtBlue;
}
break;
}
case 32:
{
// RGB 32 BITS
for( col = 0; col < w; col++, ptr += 3 )
{
// // convert bgr pixel (32 bits) into rgb (32 bits) pixel
RGBQUAD *pix = (RGBQUAD *)pBuff;
pBuff += sizeof( RGBQUAD );
ptr[2] = pix->rgbRed;
ptr[1] = pix->rgbGreen;
ptr[0] = pix->rgbBlue;
}
break;
}
}
}
break;
}
case BI_RLE8:
{
// RLE 8 BITS
for( row = h - 1; row >= 0; row-- )
{
if( flipvert )
ptr = &(*pixels)[ row * w * 3 ];
for( col = 0; col < w; /* nothing */ )
{
// get one packet (2 bytes)
unsigned char byte1 = *((unsigned char *)(pBuff++));
unsigned char byte2 = *((unsigned char *)(pBuff++));
if( byte1 == RLE_COMMAND )
{
// absolute encoding
for( i = 0; i < byte2; i++, ptr += 3, col++ )
{
// read the current pixel
unsigned char color = *((unsigned char *)(pBuff++));
// convert indexed pixel (8 bits) into rgb (32 bits) pixel
ptr[2] = win_palette[ color ].rgbRed;
ptr[1] = win_palette[ color ].rgbGreen;
ptr[0] = win_palette[ color ].rgbBlue;
}
if( (byte2 % 2) == 1 )
pBuff++;
}
else
{
// read next pixels
for( i = 0; i < byte1; i++, ptr += 3, col++ )
{
// convert indexed pixel (8 bits) into rgb (32 bits) pixel
ptr[2] = win_palette[ byte2 ].rgbRed;
ptr[1] = win_palette[ byte2 ].rgbGreen;
ptr[0] = win_palette[ byte2 ].rgbBlue;
}
}
}
}
break;
}
case BI_RLE4:
{
// RLE 4 BITS
unsigned char color;
int bytesRead = 0; // number of bytes read
for( row = h - 1; row >= 0; row-- )
{
if( flipvert )
ptr = &(*pixels)[ row * w * 3 ];
for( col = 0; col < w; /* nothing */ )
{
// get one packet (2 bytes)
unsigned char byte1 = *((unsigned char *)(pBuff++));
unsigned char byte2 = *((unsigned char *)(pBuff++));
bytesRead += 2;
if( byte1 == RLE_COMMAND )
{
// absolute encoding
unsigned char databyte;
for( i = 0; i < byte2; i++, ptr += 3, col++ )
{
if( (i % 2) == 0 )
{
// read the current pixel
databyte = *((unsigned char *)(pBuff++));
bytesRead++;
color = (databyte >> 4); // 4 first bits
}
else
{
color = (databyte & 0x0F); // 4 last bits
}
// convert indexed pixel (4 bits) into rgb (32 bits) pixel
ptr[2] = win_palette[ color ].rgbRed;
ptr[1] = win_palette[ color ].rgbGreen;
ptr[0] = win_palette[ color ].rgbBlue;
}
while( (bytesRead % 2) != 0 )
{
pBuff++;
bytesRead++;
}
}
else
{
// read next pixels
for( i = 0; i < byte1; i++, ptr += 3, col++ )
{
if( (i % 2) == 0 )
color = (byte2 >> 4); // 4 first bits
else
color = (byte2 & 0x0F); // 4 last bits
// convert indexed pixel (4 bits) into rgb (32 bits) pixel
ptr[2] = win_palette[ color ].rgbRed;
ptr[1] = win_palette[ color ].rgbGreen;
ptr[0] = win_palette[ color ].rgbBlue;
}
}
}
}
break;
}
}
// free buffer memory
delete [] buffer;
// return success
return 1;
}