quote:

---

Original post by krez
it isn't hard to look up what a DWORD really is... i wrote my own bitmap-loading structs in about 2 minutes (from specs i found on the internet), to avoid platform dependencies ("windows.h").

---

quote:

---

Original post by voodoo_john
Nice reference, but I'd like to see it more x-platform. For example, knock out the windows.h and substitute the appropriate types instead of DWORD etc

---

unsigned short header[9];
FILE * f = fopen("file.tga", "rb";
fread( header, 2, 9, f );
unsigned long * data = new unsigned long[ header[6]*header[7] ];
fread( data, 4*header[6], header[7], f );
fclose(f);
glTexImage2D( blah, header[6], header[7], blah, data );
delete[] data;
 

quote:

---

Original post by voodoo_john
Those that want to know how things work rather than use something blindly.

---

quote:

---

Original post by voodoo_john
SDL_image is crap, code your own routines and learn something.

---

//File information header

//provides general information about the file

typedef struct tagBITMAPFILEHEADER { 
	unsigned short	bfType; 
	unsigned long	bfSize; 
	unsigned short	bfReserved1; 
	unsigned short	bfReserved2; 
	unsigned long	bfOffBits; 
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;

//Bitmap information header

//provides information specific to the image data

typedef struct tagBITMAPINFOHEADER{
	unsigned long	biSize; 
	long		biWidth; 
	long		biHeight; 
	unsigned short	biPlanes; 
	unsigned short	biBitCount; 
	unsigned long	biCompression; 
	unsigned long	biSizeImage; 
	long		biXPelsPerMeter; 
	long		biYPelsPerMeter; 
	unsigned long	biClrUsed; 
	unsigned long	biClrImportant; 
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;

//Colour palette

typedef struct tagRGBQUAD {
	unsigned char	rgbBlue; 
	unsigned char	rgbGreen; 
	unsigned char	rgbRed; 
	unsigned char	rgbReserved; 
} RGBQUAD;

// assume little-endian storage on disk
struct NotAligned {
  unsigned short a;
  unsigned long b;
};

char buf[ sizeof( NotAligned ) ];
fread( buf, 1, sizeof( NotAligned ), f );
NotAligned out;
out.a = buf[0] | (buf[1]<<8);
out.b = buf[2] | (buf[3]<<8) | (buf[4]<<16) | (buf[5]<<24);
 

int j==size-3;
offset=padWidth-byteWidth;
for(int i=0;i<size;i+=3) {
   if((i+1)%padWidth==0) {
        i+=offset;
   }

   *(pixelData+j+2)=*(tempPixelData+i);
   *(pixelData+j+1)=*(tempPixelData+i+1);
   *(pixelData+j)=*(tempPixelData+i+2);
   j++;
}
 

//change pack(1) to 2 and 4 to see the difference

//different architectures may react differently as well.

#pragma pack(1)

#include <iostream>
using namespace std;

struct test {
	int a;
	int b;
	char c;
};

int main() {
	test t;

	t.a=0;
	cout << "size=" << sizeof(t) << endl;
	return 0;
}

#ifndef _BITMAP_H
#define _BITMAP_H

// Original code by Mark Bernard ( e-mail: mark.bernard@rogers.com )

// modified by David Henry ( e-mail: strad1238@hotmail.com )

// Copyright 2003



#include <iostream>
#include <cstdio>
#include <string>

using namespace std;

const short BITMAP_MAGIC_NUMBER = 19778;
const int RGB_BYTE_SIZE = 3;

#pragma pack(push, bitmap_data, 1)

// these structures make the class less platform dependent

//------------------------------------------

typedef struct tagRGBQuad 
{
	char rgbBlue;
	char rgbGreen;
	char rgbRed;
	char rgbReserved;
} RGBQuad;


//------------------------------------------

typedef struct tagBitmapFileHeader 
{
	unsigned short bfType;
	unsigned int bfSize;
	unsigned short bfReserved1;
	unsigned short bfReserved2;
	unsigned int bfOffBits;
} BitmapFileHeader;


//------------------------------------------

typedef struct tagBitmapInfoHeader 
{
	unsigned int biSize;
	int biWidth;
	int biHeight;
	unsigned short biPlanes;
	unsigned short biBitCount;
	unsigned int biCompression;
	unsigned int biSizeImage;
	int biXPelsPerMeter;
	int biYPelsPerMeter;
	unsigned int biClrUsed;
	unsigned int biClrImportant;
} BitmapInfoHeader;


//------------------------------------------


#pragma pack(pop, bitmap_data)

//--------------------------------------------------------------------------------------

class Bitmap 
{
public:
    Bitmap();
    Bitmap(char *fileName, ostream& logFile);
    ~Bitmap();

    bool loadBMP(char * fileName, ostream& logFile);

    RGBQuad *colours;						// the color pallete for 8-bit bitmaps

    char *data;								// Here is the BMP data

    bool loaded;							// loaded or not

    int width;								// width and height

	int height;	
    unsigned short bpp;						// bits per pixel

    string error;							// a field for error message


private:
	void init();							// initializes the main data fields

    void reset();							// resets all data in object

    bool convert24(char *tempData);			// convert to 24bit RGB bottom up data

    bool convert8(char *tempData);			// convert to 24bit RGB bottom up data

	void writeLog(ostream& OS, char *fileName);		// write log to file


    BitmapFileHeader bmfh;					// file header

    BitmapInfoHeader bmih;					// information header

    int byteWidth;							// the width in bytes of the image

    int padWidth;							// the width in bytes of the padded image

    unsigned int dataSize;					// size of the data in the file

};

//--------------------------------------------------------------------------------------



#endif //_BITMAP_H

// Original code by Mark Bernard ( e-mail: mark.bernard@rogers.com )

// modified by David Henry ( e-mail: strad1238@hotmail.com )

// Copyright 2003


#include "Bitmap.h"


////////////////////////////////////////////////////////////////////////////////////

Bitmap::Bitmap()					// basic constructor

{
    init();
}


////////////////////////////////////////////////////////////////////////////////////

Bitmap::Bitmap(char *file, ostream& logFile)	// constructor loads the bitmap

{
	init();
    loadBMP(file, logFile);
}


////////////////////////////////////////////////////////////////////////////////////

Bitmap::~Bitmap()					// destructor

{
    reset();
}


////////////////////////////////////////////////////////////////////////////////////

bool Bitmap::loadBMP(char *fileName, ostream& logFile) 	// loads a bitmap into memory

{
	FILE *in;					    // file stream for reading

    char *tempData;					// temp storage for image data

    int numColours;					// total available colours


    loaded = false;					// bitmap is not loaded yet

    
    in = fopen(fileName, "rb");			// open the file for reading in binary mode


    if(in == NULL) 					// if the file does not exist return in error

    {
		error = "File not found";
        fclose(in);
        return false;
    }


	//==========	read in the BITMAPFILEHEADER      ==========//


    fread(&bmfh, sizeof(BitmapFileHeader), 1, in);
  
    if(bmfh.bfType != BITMAP_MAGIC_NUMBER) 	// check magic number that says this is a bitmap

	{
		error = "File is not in DIB format";
        fclose(in);
        return false;
    }

	//==========     read in the BITMAPINFOHEADER     =========//


    fread(&bmih, sizeof(BitmapInfoHeader), 1, in);

	writeLog(logFile, fileName);			// write data to file



    width = bmih.biWidth;					// set object data fields

    height = bmih.biHeight;
    bpp = bmih.biBitCount;

    if(bpp < 8) 							// test for correct bit-per-pixel depth

    {
		error = "File is not 8 or 24 bits per pixel";
        fclose(in);
        return false;
    }
											// calculate the size of image data + padding

    dataSize = (width * height * (unsigned int)(bpp / 8.0) );

    if(bpp == 8) 							// load the color palette for 8 bits per pixel

	{
		numColours = 1 << bpp;				// calculate the number of available colours

		colours = new RGBQuad[numColours];					
    	fread(colours, sizeof(RGBQuad), numColours, in);	// read in the color palette

    }

    tempData = new char[dataSize];			// set up the temporary buffer for the image data


    if(tempData == NULL) 					// exit if there is not enough memory

	{
		error = "Not enough memory to allocate a temporary buffer";
        fclose(in);
        return false;
    }

    fread(tempData, sizeof(char), dataSize, in);	// read in the entire image


    fclose(in);								// close the file now that we have all the info


							// set both values to the byte total of the file, without padding

    byteWidth = padWidth = (int)( (float)width * (float)bpp / 8.0 );

    while(padWidth % 4 != 0) 				// adjust the width for padding as necessary

	{
		padWidth++;
    }

    if(bpp == 8) 							// change format from GBR to RGB

    {
		loaded = convert8(tempData);
   	}
    else if(bpp == 24) 
	{
    	loaded = convert24(tempData);
   	}

    delete [] tempData;					// clean up memory


    error = "Bitmap loaded";			// bitmap is now loaded


    return loaded;						// return success

}


////////////////////////////////////////////////////////////////////////////////////

void Bitmap::init(void) 				// function to set the inital values

{
	loaded = false;
    colours = 0;
    data = 0;
    error = "";
}


////////////////////////////////////////////////////////////////////////////////////

void Bitmap::reset(void)
{
    if(colours)							// clear the color pallete if required

	{	
        delete [] colours;
    }

    if(data)							// clear the data if required

	{
        delete [] data;
    }

	loaded = false;
    error = "";
}


////////////////////////////////////////////////////////////////////////////////////

bool Bitmap::convert24(char* tempData) 
{
	int offset;							// padding between data

	int dataSize;						// the size of the bitmap data


	dataSize = abs(width * height * RGB_BYTE_SIZE);
    
    data = new char[dataSize];			// allocate the buffer for the final image data


    if(data == NULL) 					// exit if there is not enough memory

    {
		error = "Not enough memory to allocate an image buffer";
        delete [] data;
        return false;
    }

    if(height > 0) 
	{
        offset = padWidth - byteWidth;			// find the difference

        
        for(int i = 0; i < dataSize; i += 3)	// count backwards until at front of image

        {
            if((i+1) % padWidth == 0)			// jump over the padding

			{
				i += offset;
            }
    
            *(data+i+2) = *(tempData+i);        // transfer the data in reverse order

            *(data+i+1) = *(tempData+i+1);		// in 3-color blocks of RGB

            *(data+i) = *(tempData+i+2);
        }
    }

    else										// image parser for a forward image

	{
        offset = padWidth - byteWidth;
        int j = dataSize - 3;

        for(int i = 0; i < dataSize; i += 3, j -= 3) 
		{
            if((i+1) % padWidth == 0)			// jump over padding

			{
                i += offset;
            }

            *(data+j+2) = *(tempData+i);		// transfer the data ||NOTE||

            *(data+j+1) = *(tempData+i+1);		// that final data is stored backwards now

            *(data+j) = *(tempData+i+2);		// due to the difference of i and j

        }
    }

    return true;
}


////////////////////////////////////////////////////////////////////////////////////

bool Bitmap::convert8(char* tempData) 
{
	int offset;							// padding between data

	int dataSize;						// the size of the bitmap data


	dataSize = abs(width * height * RGB_BYTE_SIZE);		// total memory required

    
    data = new char[dataSize];			// allocate the buffer for the final image data


    if(data == NULL)					// exit if there is not enough memory

	{
        error = "Not enough memory to allocate an image buffer";
        delete [] data;
        return false;
    }

    if(height > 0) 
	{
        offset = padWidth - byteWidth;
        int j = 0;
										//count backwards so you start at the front of the image

        for(int i = 0; i < dataSize * RGB_BYTE_SIZE; i += 3, j++) 
		{
            if((i+1) % padWidth == 0)						// jump over padding

			{
                i += offset;
            }

            *(data+i) = colours[*(tempData+j)].rgbRed;		// transfer the data

            *(data+i+1) = colours[*(tempData+j)].rgbGreen;
            *(data+i+2) = colours[*(tempData+j)].rgbBlue;
        }
    }

    else										// image parser for a forward image

	{
        offset = padWidth - byteWidth;
        int j = dataSize - 1;

										//count backwards until start at front of image

        for(int i = 0; i < dataSize * RGB_BYTE_SIZE; i += 3, j--) 
		{ 
            if((i+1) % padWidth == 0)						// jump over padding

			{
                i += offset;
            }

            *(data+i) = colours[*(tempData+j)].rgbRed;		// transfer the data,

            *(data+i+1) = colours[*(tempData+j)].rgbGreen;	// this time getting it

            *(data+i+2) = colours[*(tempData+j)].rgbBlue;	// from the color table

        }
    }
    return true;
}


////////////////////////////////////////////////////////////////////////////////////

void Bitmap::writeLog(ostream& OS, char* fileName)				// write log to file

{
	OS << "name of file    = " << fileName << endl;
	OS << "FileHeader Size = " << sizeof(BitmapFileHeader) << endl;
	OS << "InfoHeader Size = " << sizeof(BitmapInfoHeader) << endl;
	OS << "Size            = " << bmih.biSize << endl;
	OS << "Width           = " << bmih.biWidth << endl;
	OS << "Height          = " << bmih.biHeight << endl;
	OS << "Planes          = " << bmih.biPlanes << endl;
	OS << "BitCount        = " << bmih.biBitCount << endl;
	OS << "Compression     = " << bmih.biCompression << endl;
	OS << "ClrImportant    = " << bmih.biClrImportant << endl;
	OS << "ClrUsed         = " << bmih.biClrUsed << endl;
	OS << "SizeImage       = " << bmih.biSizeImage << endl;
	OS << "PixelsPerMeter  = " << bmih.biXPelsPerMeter << endl;
	OS << "PixelsPerMeter  = " << bmih.biYPelsPerMeter << endl;
	OS << endl;
}