generalnmx
Playful/Fascist Mod
I'm having trouble reading bitmaps. The headers are read correctly, but it seems the image data either isn't being converted properly, or I need to do something with palletes. Right now, I'm using the GP32 SDK for simplicy (I'll optimize later as everything is wrapped). 
Here's my code:
	
	
	
		
	
	
	
		
				
			Here's my code:
		Code:
	
	#define CORRECT_BITMAP_TYPE 19778
/* File information header
 * provides general information about the file */
typedef struct tagBITMAPFILEHEADER { 
  uword16    bfType;  /* 00h: if this is not 19778, then it is not a bitmap (represents the 'BM') */
  udword32   bfSize;  /* 02h: total size of the file, including the headers */
  uword16    bfReserved1;	/* 06h: should contain all zeros */
  uword16    bfReserved2;	/* 08h: "  "  "	"  */
  udword32   bfOffBits;  /* 0Ah: offset to the image data, varies depending on if a pallete exists */
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;
/* Bitmap information header
 * provides information specific to the image data */
typedef struct tagBITMAPINFOHEADER{
  uword16   biSize;    /* 0Eh: size of remaining header. Should be 40 (size of BITMAPINFOHEADER). */
  udword32  biWidth;  	/* 12h: width of the image in pixels */
  udword32  biHeight;  	/* 16h: height of the image in pixels */
  uword16   biPlanes;  	/* 1Ah: number of bit planes, should be 1 */
  uword16   biBitCount;  	/* 1Ch: number of bits per pixel for colours */
  udword32  biCompression;  /* 1Eh: 0 for no compression */
  udword32  biSizeImage;  /* 22h: size of the image data (could be 0) */
  udword32  biXPelsPerMeter;	/* 26h: horizontal resolution in pixels per meter */
  udword32  biYPelsPerMeter;	/* 2Ah: vertical resolution in pixels per meter */
  udword32  biClrUsed;  	/* 2Eh: number of colours used from the pallete (24-bit has this as 0)*/
  udword32  biClrImportant;  /* 32h: number of colour indexes that are important (0 means all are important) */
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
/* Colour palette */
typedef struct tagRGBQUAD {
  ubyte8    rgbBlue;  /* number in blue range */ 
  ubyte8    rgbGreen;  /* number in green range */
  ubyte8    rgbRed;  	/* number in red range */
  ubyte8    rgbReserved;	/* reserved byte (should be 0) */
} RGBQUAD;
		Code:
	
	void* IGraphicsBitmapLoad(const_char8* filename, ubyte8 bbp, uint32* bitmap_width, uint32* bitmap_height)
{
	/* open file with read access */
	if ( ISystemFileOpen(filename, FILE_READ) )	/* check to make sure we could open the file */
	{
  BITMAPFILEHEADER bmfh;  /* see igraphics.h */
  BITMAPINFOHEADER bmih;
  RGBQUAD* pallete = NULL;	/* colour table */
  uint32 numColours;  	/* number of colours in pallete */
  void* pixelArray = NULL;	/* new pixel array to return */
  uint32 bytesRead = 0;
  uint32 byteWidth = 0, padWidth = 0;	/* to counteract byte padding */
  int32 j, i;	/* used in for loop below */
  /* read in the bitmap piece by piece (for crossplatform compatability) */
  /* bitmap header */
  bytesRead += ISystemFileRead(&bmfh.bfType, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmfh.bfSize, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmfh.bfReserved1, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmfh.bfReserved2, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmfh.bfOffBits, sizeof(udword32) );
  if (bmfh.bfType != CORRECT_BITMAP_TYPE)
  	return(NULL);
  /* image data (rest of header) */
  bytesRead = 0;
  bytesRead += ISystemFileRead(&bmih.biSize, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmfh.bfReserved1, sizeof(uword16) );	/* throw this away */
  bytesRead += ISystemFileRead(&bmih.biWidth, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biHeight, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biPlanes, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmih.biBitCount, sizeof(uword16) );
  bytesRead += ISystemFileRead(&bmih.biCompression, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biSizeImage, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biXPelsPerMeter, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biYPelsPerMeter, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biClrUsed, sizeof(udword32) );
  bytesRead += ISystemFileRead(&bmih.biClrImportant, sizeof(udword32) );
  /* given bit-per-pixel should equal the bit count */
  if (bbp != bmih.biBitCount)
  {
  	return(NULL);	
  }
  /* set the number of colours */
  numColours= 1 << bmih.biBitCount;
  /* load for 8 bits per pixel */
  if (bmih.biBitCount == 8)
  {
  	pallete = (RGBQUAD*)ISystemMemoryAllocate( sizeof(RGBQUAD) * numColours ); /* array of size numColours */
  	bytesRead = ISystemFileReadByBytes(pallete, sizeof(RGBQUAD), numColours);
  	if (bytesRead < numColours )
  	{
    ISystemMemoryFree(pallete);
    return(NULL);
  	}
  }
  ISystemMemoryFree(pallete);
  /* and here we would load up the pixel array */
  if (bbp == 8)
  {
  	ubyte8* tempPixelArray = NULL; /* temporary array, need to fix padding */
  	tempPixelArray = (ubyte8*)ISystemMemoryAllocate( sizeof(ubyte8) * (bmfh.bfSize-bmfh.bfOffBits) );
  	bytesRead = ISystemFileReadByBytes(tempPixelArray, sizeof(ubyte8), bmfh.bfSize-bmfh.bfOffBits);
  	if (bytesRead < bmfh.bfSize-bmfh.bfOffBits)
  	{
    ISystemMemoryFree(pallete);
    ISystemMemoryFree(tempPixelArray);
  	}
  	/* get actual width of bitmap */
  	byteWidth=padWidth=(udword32)((float)bmih.biWidth*(float)bmih.biBitCount/8.0f);
  	/* skip through padding */
  	while( (padWidth % 4) != 0 ) {
    padWidth++;
  	}
  	/* new array should be actual size (no padding) */
  	pixelArray = (ubyte8*)ISystemMemoryAllocate( sizeof(ubyte8) * (bmih.biHeight*byteWidth) );
  	/* to fix padding problems */
  	if (pixelArray && tempPixelArray && bmih.biHeight > 0) 
  	{
    j = (bmfh.bfSize-bmfh.bfOffBits)-3;
    for(i = 0; i < (bmfh.bfSize-bmfh.bfOffBits); i+=3) 
    {
    	if( ((i+1) % padWidth) == 0 ) {
      i += padWidth-byteWidth;
    	}
    *((ubyte8*)pixelArray+j+2)	= *(tempPixelArray+i);
    *((ubyte8*)pixelArray+j+1)	= *(tempPixelArray+i+1);
    *((ubyte8*)pixelArray+j)	= *(tempPixelArray+i+2);
     j++;
    } /* end of for loop */
  	} /* end of height check */
  } /* end of bbp == 8 check */
  /* assign bitmap size */
  if (bitmap_width) *bitmap_width = bmih.biWidth;
  if (bitmap_height) *bitmap_height = bmih.biHeight;
  return(pixelArray);
	}
	return(NULL);	/* could not open file! */
} 
	
 
 
		 
 
		