Brennan Hill / Mbed 2 deprecated mbed_4180_lab4

Simplified Doodle Jump game for mbed

Dependencies:   4DGL-uLCD-SE LSM9DS1_Library_cal SDFileSystem mbed-rtos mbed wave_player

myBMP/myBMP.cpp@3:141c57be5a2d, 2016-03-15 (annotated)

Committer:
bhill42
Date:
Tue Mar 15 02:34:14 2016 +0000
Revision:
3:141c57be5a2d
Parent:
1:bdeb188cb474 
Final

Who changed what in which revision?

UserRevisionLine numberNew contents of line
bhill42 1:bdeb188cb474 1 #include "myBMP.h"
bhill42 1:bdeb188cb474 2
bhill42 1:bdeb188cb474 3 int BitDepth = 1;
bhill42 1:bdeb188cb474 4 int Width = 1;
bhill42 1:bdeb188cb474 5 int Height = 1;
bhill42 1:bdeb188cb474 6 RGBApixel *Colors;
bhill42 1:bdeb188cb474 7
bhill42 1:bdeb188cb474 8 bool SafeFread( char* buffer, int size, int number, FILE* fp )
bhill42 1:bdeb188cb474 9 {
bhill42 1:bdeb188cb474 10 using namespace std;
bhill42 1:bdeb188cb474 11 int ItemsRead;
bhill42 1:bdeb188cb474 12 if( feof(fp) )
bhill42 1:bdeb188cb474 13 { return false; }
bhill42 1:bdeb188cb474 14 ItemsRead = (int) fread( buffer , size , number , fp );
bhill42 1:bdeb188cb474 15 if( ItemsRead < number )
bhill42 1:bdeb188cb474 16 { return false; }
bhill42 1:bdeb188cb474 17 return true;
bhill42 1:bdeb188cb474 18 }
bhill42 1:bdeb188cb474 19
bhill42 1:bdeb188cb474 20
bhill42 1:bdeb188cb474 21 RGBApixel GetColor( int ColorNumber)
bhill42 1:bdeb188cb474 22 {
bhill42 1:bdeb188cb474 23 RGBApixel Output;
bhill42 1:bdeb188cb474 24 Output.Red = 255;
bhill42 1:bdeb188cb474 25 Output.Green = 255;
bhill42 1:bdeb188cb474 26 Output.Blue = 255;
bhill42 1:bdeb188cb474 27 Output.Alpha = 0;
bhill42 1:bdeb188cb474 28
bhill42 1:bdeb188cb474 29 if( BitDepth != 1 && BitDepth != 4 && BitDepth != 8 )
bhill42 1:bdeb188cb474 30 {
bhill42 1:bdeb188cb474 31 return Output;
bhill42 1:bdeb188cb474 32 }
bhill42 1:bdeb188cb474 33 if( !Colors )
bhill42 1:bdeb188cb474 34 {
bhill42 1:bdeb188cb474 35 return Output;
bhill42 1:bdeb188cb474 36 }
bhill42 1:bdeb188cb474 37 Output = Colors[ColorNumber];
bhill42 1:bdeb188cb474 38 return Output;
bhill42 1:bdeb188cb474 39 }
bhill42 1:bdeb188cb474 40
bhill42 1:bdeb188cb474 41 bool Read8bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 42 {
bhill42 1:bdeb188cb474 43 int i;
bhill42 1:bdeb188cb474 44 if( Width > BufferSize )
bhill42 1:bdeb188cb474 45 { return false; }
bhill42 1:bdeb188cb474 46 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 47 {
bhill42 1:bdeb188cb474 48 int Index = Buffer[i];
bhill42 1:bdeb188cb474 49 //Blue, Green, Red, Alpha
bhill42 1:bdeb188cb474 50 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 51 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 52 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+Row,color);
bhill42 1:bdeb188cb474 53 }
bhill42 1:bdeb188cb474 54 return true;
bhill42 1:bdeb188cb474 55 }
bhill42 1:bdeb188cb474 56
bhill42 1:bdeb188cb474 57 bool Read4bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 58 {
bhill42 1:bdeb188cb474 59 int Shifts[2] = {4 ,0 };
bhill42 1:bdeb188cb474 60 int Masks[2] = {240,15};
bhill42 1:bdeb188cb474 61
bhill42 1:bdeb188cb474 62 int i=0;
bhill42 1:bdeb188cb474 63 int j;
bhill42 1:bdeb188cb474 64 int k=0;
bhill42 1:bdeb188cb474 65 if( Width > 2*BufferSize )
bhill42 1:bdeb188cb474 66 { return false; }
bhill42 1:bdeb188cb474 67 while( i < Width )
bhill42 1:bdeb188cb474 68 {
bhill42 1:bdeb188cb474 69 j=0;
bhill42 1:bdeb188cb474 70 while( j < 2 && i < Width )
bhill42 1:bdeb188cb474 71 {
bhill42 1:bdeb188cb474 72 int Index = (int) ( (Buffer[k]&Masks[j]) >> Shifts[j]);
bhill42 1:bdeb188cb474 73 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 74 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 75 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+Row,color);
bhill42 1:bdeb188cb474 76 i++; j++;
bhill42 1:bdeb188cb474 77 }
bhill42 1:bdeb188cb474 78 k++;
bhill42 1:bdeb188cb474 79 }
bhill42 1:bdeb188cb474 80 return true;
bhill42 1:bdeb188cb474 81 }
bhill42 1:bdeb188cb474 82
bhill42 1:bdeb188cb474 83
bhill42 1:bdeb188cb474 84
bhill42 1:bdeb188cb474 85
bhill42 1:bdeb188cb474 86
bhill42 1:bdeb188cb474 87
bhill42 1:bdeb188cb474 88
bhill42 1:bdeb188cb474 89
bhill42 1:bdeb188cb474 90
bhill42 1:bdeb188cb474 91 bool Read32bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd, int x, int y)
bhill42 1:bdeb188cb474 92 {
bhill42 1:bdeb188cb474 93 int i;
bhill42 1:bdeb188cb474 94 char Colors[4];
bhill42 1:bdeb188cb474 95 if( Width*4 > BufferSize )
bhill42 1:bdeb188cb474 96 { return false; }
bhill42 1:bdeb188cb474 97 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 98 {
bhill42 1:bdeb188cb474 99 memcpy( (char*) &(Colors), (char*) Buffer+4*i, 4 );
bhill42 1:bdeb188cb474 100 //Blue, Green, Red, Alpha
bhill42 1:bdeb188cb474 101 int color = 0x00000000 | (Colors[2] << 16) | (Colors[1] << 8) | (Colors[0]);
bhill42 1:bdeb188cb474 102 (*lcd).pixel(x+i,y+Row,color);
bhill42 1:bdeb188cb474 103 }
bhill42 1:bdeb188cb474 104 return true;
bhill42 1:bdeb188cb474 105 }
bhill42 1:bdeb188cb474 106
bhill42 1:bdeb188cb474 107
bhill42 1:bdeb188cb474 108 bool Read24bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd, int x, int y)
bhill42 1:bdeb188cb474 109 {
bhill42 1:bdeb188cb474 110 int i;
bhill42 1:bdeb188cb474 111 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 112 {
bhill42 1:bdeb188cb474 113 int color = 0x00000000 | (Buffer[3*i+2] << 16) | (Buffer[3*i+1] << 8) | (Buffer[3*i+0]);
bhill42 1:bdeb188cb474 114 (*lcd).pixel(x+i,y+Row,color);
bhill42 1:bdeb188cb474 115 }
bhill42 1:bdeb188cb474 116 return true;
bhill42 1:bdeb188cb474 117 }
bhill42 1:bdeb188cb474 118
bhill42 1:bdeb188cb474 119
bhill42 1:bdeb188cb474 120 bool Read8bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd, int x, int y)
bhill42 1:bdeb188cb474 121 {
bhill42 1:bdeb188cb474 122 int i;
bhill42 1:bdeb188cb474 123 if( Width > BufferSize )
bhill42 1:bdeb188cb474 124 { return false; }
bhill42 1:bdeb188cb474 125 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 126 {
bhill42 1:bdeb188cb474 127 int Index = Buffer[i];
bhill42 1:bdeb188cb474 128 //Blue, Green, Red, Alpha
bhill42 1:bdeb188cb474 129 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 130 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 131 (*lcd).pixel(x+i,y+Row,color);
bhill42 1:bdeb188cb474 132 }
bhill42 1:bdeb188cb474 133 return true;
bhill42 1:bdeb188cb474 134 }
bhill42 1:bdeb188cb474 135
bhill42 1:bdeb188cb474 136
bhill42 1:bdeb188cb474 137 bool Read4bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd, int x, int y)
bhill42 1:bdeb188cb474 138 {
bhill42 1:bdeb188cb474 139 int Shifts[2] = {4 ,0 };
bhill42 1:bdeb188cb474 140 int Masks[2] = {240,15};
bhill42 1:bdeb188cb474 141
bhill42 1:bdeb188cb474 142 int i=0;
bhill42 1:bdeb188cb474 143 int j;
bhill42 1:bdeb188cb474 144 int k=0;
bhill42 1:bdeb188cb474 145 if( Width > 2*BufferSize )
bhill42 1:bdeb188cb474 146 { return false; }
bhill42 1:bdeb188cb474 147 while( i < Width )
bhill42 1:bdeb188cb474 148 {
bhill42 1:bdeb188cb474 149 j=0;
bhill42 1:bdeb188cb474 150 while( j < 2 && i < Width )
bhill42 1:bdeb188cb474 151 {
bhill42 1:bdeb188cb474 152 int Index = (int) ( (Buffer[k]&Masks[j]) >> Shifts[j]);
bhill42 1:bdeb188cb474 153 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 154 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 155 (*lcd).pixel(x+i,y+Row,color);
bhill42 1:bdeb188cb474 156 i++; j++;
bhill42 1:bdeb188cb474 157 }
bhill42 1:bdeb188cb474 158 k++;
bhill42 1:bdeb188cb474 159 }
bhill42 1:bdeb188cb474 160 return true;
bhill42 1:bdeb188cb474 161 }
bhill42 1:bdeb188cb474 162
bhill42 1:bdeb188cb474 163
bhill42 1:bdeb188cb474 164 bool Read1bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd, int x, int y)
bhill42 1:bdeb188cb474 165 {
bhill42 1:bdeb188cb474 166 int Shifts[8] = {7 ,6 ,5 ,4 ,3,2,1,0};
bhill42 1:bdeb188cb474 167 int Masks[8] = {128,64,32,16,8,4,2,1};
bhill42 1:bdeb188cb474 168
bhill42 1:bdeb188cb474 169 int i=0;
bhill42 1:bdeb188cb474 170 int j;
bhill42 1:bdeb188cb474 171 int k=0;
bhill42 1:bdeb188cb474 172
bhill42 1:bdeb188cb474 173 if( Width > 8*BufferSize )
bhill42 1:bdeb188cb474 174 { return false; }
bhill42 1:bdeb188cb474 175 while( i < Width )
bhill42 1:bdeb188cb474 176 {
bhill42 1:bdeb188cb474 177 j=0;
bhill42 1:bdeb188cb474 178 while( j < 8 && i < Width )
bhill42 1:bdeb188cb474 179 {
bhill42 1:bdeb188cb474 180 int Index = (int) ( (Buffer[k]&Masks[j]) >> Shifts[j]);
bhill42 1:bdeb188cb474 181 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 182 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 183 (*lcd).pixel(x+i,y+Row,color);
bhill42 1:bdeb188cb474 184 i++; j++;
bhill42 1:bdeb188cb474 185 }
bhill42 1:bdeb188cb474 186 k++;
bhill42 1:bdeb188cb474 187 }
bhill42 1:bdeb188cb474 188 return true;
bhill42 1:bdeb188cb474 189 }
bhill42 1:bdeb188cb474 190
bhill42 1:bdeb188cb474 191
bhill42 1:bdeb188cb474 192
bhill42 1:bdeb188cb474 193
bhill42 1:bdeb188cb474 194
bhill42 1:bdeb188cb474 195
bhill42 1:bdeb188cb474 196 bool Read32bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 197 {
bhill42 1:bdeb188cb474 198 int i;
bhill42 1:bdeb188cb474 199 char Colors[4];
bhill42 1:bdeb188cb474 200 if( Width*4 > BufferSize )
bhill42 1:bdeb188cb474 201 { return false; }
bhill42 1:bdeb188cb474 202 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 203 {
bhill42 1:bdeb188cb474 204 memcpy( (char*) &(Colors), (char*) Buffer+4*i, 4 );
bhill42 1:bdeb188cb474 205 //Blue, Green, Red, Alpha
bhill42 1:bdeb188cb474 206 int color = 0x00000000 | (Colors[2] << 16) | (Colors[1] << 8) | (Colors[0]);
bhill42 1:bdeb188cb474 207 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+Row,color);
bhill42 1:bdeb188cb474 208 }
bhill42 1:bdeb188cb474 209 return true;
bhill42 1:bdeb188cb474 210 }
bhill42 1:bdeb188cb474 211
bhill42 1:bdeb188cb474 212 bool Read24bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 213 {
bhill42 1:bdeb188cb474 214 int i;
bhill42 1:bdeb188cb474 215 char Colors[4];
bhill42 1:bdeb188cb474 216 if( Width*3 > BufferSize )
bhill42 1:bdeb188cb474 217 { return false; }
bhill42 1:bdeb188cb474 218 for( i=0 ; i < Width ; i++ )
bhill42 1:bdeb188cb474 219 {
bhill42 1:bdeb188cb474 220 memcpy( (char*) &(Colors), (char*) Buffer+3*i, 3 );
bhill42 1:bdeb188cb474 221 //Blue, Green, Red, Alpha
bhill42 1:bdeb188cb474 222 int color = 0x00000000 | (Colors[2] << 16) | (Colors[1] << 8) | (Colors[0]);
bhill42 1:bdeb188cb474 223 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+Row,color);
bhill42 1:bdeb188cb474 224 }
bhill42 1:bdeb188cb474 225 return true;
bhill42 1:bdeb188cb474 226 }
bhill42 1:bdeb188cb474 227
bhill42 1:bdeb188cb474 228
bhill42 1:bdeb188cb474 229 bool Read1bitRow( ebmpBYTE* Buffer, int BufferSize, int Row, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 230 {
bhill42 1:bdeb188cb474 231 int Shifts[8] = {7 ,6 ,5 ,4 ,3,2,1,0};
bhill42 1:bdeb188cb474 232 int Masks[8] = {128,64,32,16,8,4,2,1};
bhill42 1:bdeb188cb474 233
bhill42 1:bdeb188cb474 234 int i=0;
bhill42 1:bdeb188cb474 235 int j;
bhill42 1:bdeb188cb474 236 int k=0;
bhill42 1:bdeb188cb474 237
bhill42 1:bdeb188cb474 238 if( Width > 8*BufferSize )
bhill42 1:bdeb188cb474 239 { return false; }
bhill42 1:bdeb188cb474 240 while( i < Width )
bhill42 1:bdeb188cb474 241 {
bhill42 1:bdeb188cb474 242 j=0;
bhill42 1:bdeb188cb474 243 while( j < 8 && i < Width )
bhill42 1:bdeb188cb474 244 {
bhill42 1:bdeb188cb474 245 int Index = (int) ( (Buffer[k]&Masks[j]) >> Shifts[j]);
bhill42 1:bdeb188cb474 246 RGBApixel colors = GetColor(Index);
bhill42 1:bdeb188cb474 247 int color = 0x00000000 | (colors.Red<< 16) | (colors.Blue << 8) | (colors.Green);
bhill42 1:bdeb188cb474 248 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+Row,color);
bhill42 1:bdeb188cb474 249 i++; j++;
bhill42 1:bdeb188cb474 250 }
bhill42 1:bdeb188cb474 251 k++;
bhill42 1:bdeb188cb474 252 }
bhill42 1:bdeb188cb474 253 return true;
bhill42 1:bdeb188cb474 254 }
bhill42 1:bdeb188cb474 255
bhill42 1:bdeb188cb474 256 int TellNumberOfColors( int BitDepth )
bhill42 1:bdeb188cb474 257 {
bhill42 1:bdeb188cb474 258 int output = 1 << BitDepth;
bhill42 1:bdeb188cb474 259 if( BitDepth == 32 )
bhill42 1:bdeb188cb474 260 { output = 1 << 24; }
bhill42 1:bdeb188cb474 261 return output;
bhill42 1:bdeb188cb474 262 }
bhill42 1:bdeb188cb474 263
bhill42 1:bdeb188cb474 264 bool ReadBMPFromFile( const char* FileName, RGBApixel *Colors, uLCD_4DGL *lcd)
bhill42 1:bdeb188cb474 265 {
bhill42 1:bdeb188cb474 266 FILE* fp = fopen( FileName, "rb" );
bhill42 1:bdeb188cb474 267 if( fp == NULL )
bhill42 1:bdeb188cb474 268 {
bhill42 1:bdeb188cb474 269 return false;
bhill42 1:bdeb188cb474 270 }
bhill42 1:bdeb188cb474 271
bhill42 1:bdeb188cb474 272 // read the file header
bhill42 1:bdeb188cb474 273
bhill42 1:bdeb188cb474 274 BMFH bmfh;
bhill42 1:bdeb188cb474 275 bool NotCorrupted = true;
bhill42 1:bdeb188cb474 276
bhill42 1:bdeb188cb474 277 NotCorrupted &= SafeFread( (char*) &(bmfh.bfType) , sizeof(ebmpWORD), 1, fp);
bhill42 1:bdeb188cb474 278
bhill42 1:bdeb188cb474 279 bool IsBitmap = false;
bhill42 1:bdeb188cb474 280
bhill42 1:bdeb188cb474 281 if( bmfh.bfType == 19778 )
bhill42 1:bdeb188cb474 282 { IsBitmap = true; }
bhill42 1:bdeb188cb474 283
bhill42 1:bdeb188cb474 284 if( !IsBitmap )
bhill42 1:bdeb188cb474 285 {
bhill42 1:bdeb188cb474 286 fclose( fp );
bhill42 1:bdeb188cb474 287 return false;
bhill42 1:bdeb188cb474 288 }
bhill42 1:bdeb188cb474 289
bhill42 1:bdeb188cb474 290 NotCorrupted &= SafeFread( (char*) &(bmfh.bfSize) , sizeof(ebmpDWORD) , 1, fp);
bhill42 1:bdeb188cb474 291 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved1) , sizeof(ebmpWORD) , 1, fp);
bhill42 1:bdeb188cb474 292 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved2) , sizeof(ebmpWORD) , 1, fp);
bhill42 1:bdeb188cb474 293 NotCorrupted &= SafeFread( (char*) &(bmfh.bfOffBits) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 294
bhill42 1:bdeb188cb474 295 // read the info header
bhill42 1:bdeb188cb474 296
bhill42 1:bdeb188cb474 297 BMIH bmih;
bhill42 1:bdeb188cb474 298
bhill42 1:bdeb188cb474 299 NotCorrupted &= SafeFread( (char*) &(bmih.biSize) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 300 NotCorrupted &= SafeFread( (char*) &(bmih.biWidth) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 301 NotCorrupted &= SafeFread( (char*) &(bmih.biHeight) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 302 NotCorrupted &= SafeFread( (char*) &(bmih.biPlanes) , sizeof(ebmpWORD) , 1, fp);
bhill42 1:bdeb188cb474 303 NotCorrupted &= SafeFread( (char*) &(bmih.biBitCount) , sizeof(ebmpWORD) , 1, fp);
bhill42 1:bdeb188cb474 304
bhill42 1:bdeb188cb474 305 NotCorrupted &= SafeFread( (char*) &(bmih.biCompression) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 306 NotCorrupted &= SafeFread( (char*) &(bmih.biSizeImage) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 307 NotCorrupted &= SafeFread( (char*) &(bmih.biXPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 308 NotCorrupted &= SafeFread( (char*) &(bmih.biYPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 309 NotCorrupted &= SafeFread( (char*) &(bmih.biClrUsed) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 310 NotCorrupted &= SafeFread( (char*) &(bmih.biClrImportant) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 1:bdeb188cb474 311
bhill42 1:bdeb188cb474 312 // a safety catch: if any of the header information didn't read properly, abort
bhill42 1:bdeb188cb474 313 // future idea: check to see if at least most is self-consistent
bhill42 1:bdeb188cb474 314
bhill42 1:bdeb188cb474 315 if( !NotCorrupted )
bhill42 1:bdeb188cb474 316 {
bhill42 1:bdeb188cb474 317 fclose(fp);
bhill42 1:bdeb188cb474 318 return false;
bhill42 1:bdeb188cb474 319 }
bhill42 1:bdeb188cb474 320
bhill42 1:bdeb188cb474 321 // if bmih.biCompression 1 or 2, then the file is RLE compressed
bhill42 1:bdeb188cb474 322
bhill42 1:bdeb188cb474 323 if( bmih.biCompression == 1 || bmih.biCompression == 2 )
bhill42 1:bdeb188cb474 324 {
bhill42 1:bdeb188cb474 325 fclose(fp);
bhill42 1:bdeb188cb474 326 return false;
bhill42 1:bdeb188cb474 327 }
bhill42 1:bdeb188cb474 328
bhill42 1:bdeb188cb474 329 // if bmih.biCompression > 3, then something strange is going on
bhill42 1:bdeb188cb474 330 // it's probably an OS2 bitmap file.
bhill42 1:bdeb188cb474 331
bhill42 1:bdeb188cb474 332 if( bmih.biCompression > 3 )
bhill42 1:bdeb188cb474 333 {
bhill42 1:bdeb188cb474 334 fclose(fp);
bhill42 1:bdeb188cb474 335 return false;
bhill42 1:bdeb188cb474 336 }
bhill42 1:bdeb188cb474 337
bhill42 1:bdeb188cb474 338 if( bmih.biCompression == 3 && bmih.biBitCount != 16 )
bhill42 1:bdeb188cb474 339 {
bhill42 1:bdeb188cb474 340 fclose(fp);
bhill42 1:bdeb188cb474 341 return false;
bhill42 1:bdeb188cb474 342 }
bhill42 1:bdeb188cb474 343
bhill42 1:bdeb188cb474 344 // set the bit depth
bhill42 1:bdeb188cb474 345
bhill42 1:bdeb188cb474 346 int TempBitDepth = (int) bmih.biBitCount;
bhill42 1:bdeb188cb474 347 if( TempBitDepth != 1 && TempBitDepth != 4
bhill42 1:bdeb188cb474 348 && TempBitDepth != 8 && TempBitDepth != 16
bhill42 1:bdeb188cb474 349 && TempBitDepth != 24 && TempBitDepth != 32 )
bhill42 1:bdeb188cb474 350 {
bhill42 1:bdeb188cb474 351 fclose(fp);
bhill42 1:bdeb188cb474 352 return false;
bhill42 1:bdeb188cb474 353 }
bhill42 1:bdeb188cb474 354 BitDepth = (int)bmih.biBitCount;
bhill42 1:bdeb188cb474 355 // set the size
bhill42 1:bdeb188cb474 356
bhill42 1:bdeb188cb474 357 if( (int) bmih.biWidth <= 0 || (int) bmih.biHeight <= 0 )
bhill42 1:bdeb188cb474 358 {
bhill42 1:bdeb188cb474 359 fclose(fp);
bhill42 1:bdeb188cb474 360 return false;
bhill42 1:bdeb188cb474 361 }
bhill42 1:bdeb188cb474 362 Width = (int) bmih.biWidth;
bhill42 1:bdeb188cb474 363 Height = (int) bmih.biHeight;
bhill42 1:bdeb188cb474 364 // some preliminaries
bhill42 1:bdeb188cb474 365
bhill42 1:bdeb188cb474 366 double dBytesPerPixel = ( (double) BitDepth ) / 8.0;
bhill42 1:bdeb188cb474 367 double dBytesPerRow = dBytesPerPixel * (Width+0.0);
bhill42 1:bdeb188cb474 368 dBytesPerRow = ceil(dBytesPerRow);
bhill42 1:bdeb188cb474 369
bhill42 1:bdeb188cb474 370 int BytePaddingPerRow = 4 - ( (int) (dBytesPerRow) )% 4;
bhill42 1:bdeb188cb474 371 if( BytePaddingPerRow == 4 )
bhill42 1:bdeb188cb474 372 { BytePaddingPerRow = 0; }
bhill42 1:bdeb188cb474 373
bhill42 1:bdeb188cb474 374 // if < 16 bits, read the palette
bhill42 1:bdeb188cb474 375
bhill42 1:bdeb188cb474 376 if( BitDepth < 16 )
bhill42 1:bdeb188cb474 377 {
bhill42 1:bdeb188cb474 378 // determine the number of colors specified in the
bhill42 1:bdeb188cb474 379 // color table
bhill42 1:bdeb188cb474 380
bhill42 1:bdeb188cb474 381 int NumberOfColorsToRead = ((int) bmfh.bfOffBits - 54 )/4;
bhill42 1:bdeb188cb474 382 if( NumberOfColorsToRead > (1 << BitDepth) )
bhill42 1:bdeb188cb474 383 { NumberOfColorsToRead = (1 << BitDepth); }
bhill42 1:bdeb188cb474 384
bhill42 1:bdeb188cb474 385 int n;
bhill42 1:bdeb188cb474 386 for( n=0; n < NumberOfColorsToRead ; n++ )
bhill42 1:bdeb188cb474 387 {
bhill42 1:bdeb188cb474 388 SafeFread( (char*) &(Colors[n]) , 4 , 1 , fp);
bhill42 1:bdeb188cb474 389 }
bhill42 1:bdeb188cb474 390 for( n=NumberOfColorsToRead ; n < TellNumberOfColors(BitDepth) ; n++ )
bhill42 1:bdeb188cb474 391 {
bhill42 1:bdeb188cb474 392 RGBApixel HWITE;
bhill42 1:bdeb188cb474 393 HWITE.Red = 255;
bhill42 1:bdeb188cb474 394 HWITE.Green = 255;
bhill42 1:bdeb188cb474 395 HWITE.Blue = 255;
bhill42 1:bdeb188cb474 396 HWITE.Alpha = 0;
bhill42 1:bdeb188cb474 397 Colors[n] = HWITE;
bhill42 1:bdeb188cb474 398 }
bhill42 1:bdeb188cb474 399 }
bhill42 1:bdeb188cb474 400
bhill42 1:bdeb188cb474 401 // skip blank data if bfOffBits so indicates
bhill42 1:bdeb188cb474 402
bhill42 1:bdeb188cb474 403 int BytesToSkip = bmfh.bfOffBits - 54;;
bhill42 1:bdeb188cb474 404 if( BitDepth < 16 )
bhill42 1:bdeb188cb474 405 { BytesToSkip -= 4*(1 << BitDepth); }
bhill42 1:bdeb188cb474 406 if( BitDepth == 16 && bmih.biCompression == 3 )
bhill42 1:bdeb188cb474 407 { BytesToSkip -= 3*4; }
bhill42 1:bdeb188cb474 408 if( BytesToSkip < 0 )
bhill42 1:bdeb188cb474 409 { BytesToSkip = 0; }
bhill42 1:bdeb188cb474 410 if( BytesToSkip > 0 && BitDepth != 16 )
bhill42 1:bdeb188cb474 411 {
bhill42 1:bdeb188cb474 412 ebmpBYTE* TempSkipBYTE;
bhill42 1:bdeb188cb474 413 TempSkipBYTE = new ebmpBYTE [BytesToSkip];
bhill42 1:bdeb188cb474 414 SafeFread( (char*) TempSkipBYTE , BytesToSkip , 1 , fp);
bhill42 1:bdeb188cb474 415 delete [] TempSkipBYTE;
bhill42 1:bdeb188cb474 416 }
bhill42 1:bdeb188cb474 417
bhill42 1:bdeb188cb474 418 // This code reads 1, 4, 8, 24, and 32-bpp files
bhill42 1:bdeb188cb474 419 // with a more-efficient buffered technique.
bhill42 1:bdeb188cb474 420
bhill42 1:bdeb188cb474 421 int i,j;
bhill42 1:bdeb188cb474 422 if( BitDepth != 16 )
bhill42 1:bdeb188cb474 423 {
bhill42 1:bdeb188cb474 424 int BufferSize = (int) ( (Width*BitDepth) / 8.0 );
bhill42 1:bdeb188cb474 425 while( 8*BufferSize < Width*BitDepth )
bhill42 1:bdeb188cb474 426 { BufferSize++; }
bhill42 1:bdeb188cb474 427 while( BufferSize % 4 )
bhill42 1:bdeb188cb474 428 { BufferSize++; }
bhill42 1:bdeb188cb474 429 ebmpBYTE* Buffer;
bhill42 1:bdeb188cb474 430 Buffer = new ebmpBYTE [BufferSize];
bhill42 1:bdeb188cb474 431 j= Height-1;
bhill42 1:bdeb188cb474 432 while( j > -1 )
bhill42 1:bdeb188cb474 433 {
bhill42 1:bdeb188cb474 434 int BytesRead = (int) fread( (char*) Buffer, 1, BufferSize, fp );
bhill42 1:bdeb188cb474 435 if( BytesRead < BufferSize )
bhill42 1:bdeb188cb474 436 {
bhill42 1:bdeb188cb474 437 j = -1;
bhill42 1:bdeb188cb474 438 }
bhill42 1:bdeb188cb474 439 else
bhill42 1:bdeb188cb474 440 {
bhill42 1:bdeb188cb474 441 bool Success = false;
bhill42 1:bdeb188cb474 442 if( BitDepth == 1 )
bhill42 1:bdeb188cb474 443 { Success = Read1bitRow( Buffer, BufferSize, j , lcd); }
bhill42 1:bdeb188cb474 444 if( BitDepth == 4 )
bhill42 1:bdeb188cb474 445 { Success = Read4bitRow( Buffer, BufferSize, j , lcd); }
bhill42 1:bdeb188cb474 446 if( BitDepth == 8 )
bhill42 1:bdeb188cb474 447 { Success = Read8bitRow( Buffer, BufferSize, j , lcd); }
bhill42 1:bdeb188cb474 448 if( BitDepth == 24 )
bhill42 1:bdeb188cb474 449 { Success = Read24bitRow( Buffer, BufferSize, j , lcd); }
bhill42 1:bdeb188cb474 450 if( BitDepth == 32 )
bhill42 1:bdeb188cb474 451 { Success = Read32bitRow( Buffer, BufferSize, j , lcd); }
bhill42 1:bdeb188cb474 452 if( !Success )
bhill42 1:bdeb188cb474 453 {
bhill42 1:bdeb188cb474 454 j = -1;
bhill42 1:bdeb188cb474 455 }
bhill42 1:bdeb188cb474 456 }
bhill42 1:bdeb188cb474 457 j--;
bhill42 1:bdeb188cb474 458 }
bhill42 1:bdeb188cb474 459 delete [] Buffer;
bhill42 1:bdeb188cb474 460 }
bhill42 1:bdeb188cb474 461
bhill42 1:bdeb188cb474 462 if( BitDepth == 16 )
bhill42 1:bdeb188cb474 463 {
bhill42 1:bdeb188cb474 464 int DataBytes = Width*2;
bhill42 1:bdeb188cb474 465 int PaddingBytes = ( 4 - DataBytes % 4 ) % 4;
bhill42 1:bdeb188cb474 466
bhill42 1:bdeb188cb474 467 // set the default mask
bhill42 1:bdeb188cb474 468
bhill42 1:bdeb188cb474 469 ebmpWORD BlueMask = 31; // bits 12-16
bhill42 1:bdeb188cb474 470 ebmpWORD GreenMask = 992; // bits 7-11
bhill42 1:bdeb188cb474 471 ebmpWORD RedMask = 31744; // bits 2-6
bhill42 1:bdeb188cb474 472
bhill42 1:bdeb188cb474 473 // read the bit fields, if necessary, to
bhill42 1:bdeb188cb474 474 // override the default 5-5-5 mask
bhill42 1:bdeb188cb474 475
bhill42 1:bdeb188cb474 476 if( bmih.biCompression != 0 )
bhill42 1:bdeb188cb474 477 {
bhill42 1:bdeb188cb474 478 // read the three bit masks
bhill42 1:bdeb188cb474 479
bhill42 1:bdeb188cb474 480 ebmpWORD TempMaskWORD;
bhill42 1:bdeb188cb474 481
bhill42 1:bdeb188cb474 482 SafeFread( (char*) &RedMask , 2 , 1 , fp );
bhill42 1:bdeb188cb474 483 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 1:bdeb188cb474 484
bhill42 1:bdeb188cb474 485 SafeFread( (char*) &GreenMask , 2 , 1 , fp );
bhill42 1:bdeb188cb474 486 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 1:bdeb188cb474 487
bhill42 1:bdeb188cb474 488 SafeFread( (char*) &BlueMask , 2 , 1 , fp );
bhill42 1:bdeb188cb474 489 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 1:bdeb188cb474 490 }
bhill42 1:bdeb188cb474 491
bhill42 1:bdeb188cb474 492 // read and skip any meta data
bhill42 1:bdeb188cb474 493
bhill42 1:bdeb188cb474 494 if( BytesToSkip > 0 )
bhill42 1:bdeb188cb474 495 {
bhill42 1:bdeb188cb474 496 ebmpBYTE* TempSkipBYTE;
bhill42 1:bdeb188cb474 497 TempSkipBYTE = new ebmpBYTE [BytesToSkip];
bhill42 1:bdeb188cb474 498 SafeFread( (char*) TempSkipBYTE , BytesToSkip , 1 , fp);
bhill42 1:bdeb188cb474 499 delete [] TempSkipBYTE;
bhill42 1:bdeb188cb474 500 }
bhill42 1:bdeb188cb474 501
bhill42 1:bdeb188cb474 502 // determine the red, green and blue shifts
bhill42 1:bdeb188cb474 503
bhill42 1:bdeb188cb474 504 int GreenShift = 0;
bhill42 1:bdeb188cb474 505 ebmpWORD TempShiftWORD = GreenMask;
bhill42 1:bdeb188cb474 506 while( TempShiftWORD > 31 )
bhill42 1:bdeb188cb474 507 { TempShiftWORD = TempShiftWORD>>1; GreenShift++; }
bhill42 1:bdeb188cb474 508 int BlueShift = 0;
bhill42 1:bdeb188cb474 509 TempShiftWORD = BlueMask;
bhill42 1:bdeb188cb474 510 while( TempShiftWORD > 31 )
bhill42 1:bdeb188cb474 511 { TempShiftWORD = TempShiftWORD>>1; BlueShift++; }
bhill42 1:bdeb188cb474 512 int RedShift = 0;
bhill42 1:bdeb188cb474 513 TempShiftWORD = RedMask;
bhill42 1:bdeb188cb474 514 while( TempShiftWORD > 31 )
bhill42 1:bdeb188cb474 515 { TempShiftWORD = TempShiftWORD>>1; RedShift++; }
bhill42 1:bdeb188cb474 516
bhill42 1:bdeb188cb474 517 // read the actual pixels
bhill42 1:bdeb188cb474 518
bhill42 1:bdeb188cb474 519 for( j=Height-1 ; j >= 0 ; j-- )
bhill42 1:bdeb188cb474 520 {
bhill42 1:bdeb188cb474 521 i=0;
bhill42 1:bdeb188cb474 522 int ReadNumber = 0;
bhill42 1:bdeb188cb474 523 while( ReadNumber < DataBytes )
bhill42 1:bdeb188cb474 524 {
bhill42 1:bdeb188cb474 525 ebmpWORD TempWORD;
bhill42 1:bdeb188cb474 526 SafeFread( (char*) &TempWORD , 2 , 1 , fp );
bhill42 1:bdeb188cb474 527 ReadNumber += 2;
bhill42 1:bdeb188cb474 528
bhill42 1:bdeb188cb474 529 ebmpWORD Red = RedMask & TempWORD;
bhill42 1:bdeb188cb474 530 ebmpWORD Green = GreenMask & TempWORD;
bhill42 1:bdeb188cb474 531 ebmpWORD Blue = BlueMask & TempWORD;
bhill42 1:bdeb188cb474 532
bhill42 1:bdeb188cb474 533 ebmpBYTE BlueBYTE = (ebmpBYTE) 8*(Blue>>BlueShift);
bhill42 1:bdeb188cb474 534 ebmpBYTE GreenBYTE = (ebmpBYTE) 8*(Green>>GreenShift);
bhill42 1:bdeb188cb474 535 ebmpBYTE RedBYTE = (ebmpBYTE) 8*(Red>>RedShift);
bhill42 1:bdeb188cb474 536
bhill42 1:bdeb188cb474 537 int color = 0x00000000 | (RedBYTE << 16) | (GreenBYTE << 8) | (BlueBYTE);
bhill42 1:bdeb188cb474 538 (*lcd).pixel((130-Width)/2+i,(130-Height)/2+j,color);
bhill42 1:bdeb188cb474 539 i++;
bhill42 1:bdeb188cb474 540 }
bhill42 1:bdeb188cb474 541 ReadNumber = 0;
bhill42 1:bdeb188cb474 542 while( ReadNumber < PaddingBytes )
bhill42 1:bdeb188cb474 543 {
bhill42 1:bdeb188cb474 544 ebmpBYTE TempBYTE;
bhill42 1:bdeb188cb474 545 SafeFread( (char*) &TempBYTE , 1, 1, fp);
bhill42 1:bdeb188cb474 546 ReadNumber++;
bhill42 1:bdeb188cb474 547 }
bhill42 1:bdeb188cb474 548 }
bhill42 1:bdeb188cb474 549
bhill42 1:bdeb188cb474 550 }
bhill42 1:bdeb188cb474 551
bhill42 1:bdeb188cb474 552 fclose(fp);
bhill42 1:bdeb188cb474 553 return true;
bhill42 1:bdeb188cb474 554 }
bhill42 1:bdeb188cb474 555
bhill42 3:141c57be5a2d 556 bool ReadColorsFromFile(const char * FileName, RGBApixel *Colors, int * color_array, int x, int y)
bhill42 1:bdeb188cb474 557 {
bhill42 3:141c57be5a2d 558 FILE* fp = fopen( FileName, "rb" );
bhill42 3:141c57be5a2d 559 if( fp == NULL )
bhill42 3:141c57be5a2d 560 {
bhill42 3:141c57be5a2d 561 return false;
bhill42 3:141c57be5a2d 562 }
bhill42 3:141c57be5a2d 563
bhill42 3:141c57be5a2d 564 // read the file header
bhill42 3:141c57be5a2d 565
bhill42 3:141c57be5a2d 566 BMFH bmfh;
bhill42 3:141c57be5a2d 567 bool NotCorrupted = true;
bhill42 3:141c57be5a2d 568
bhill42 3:141c57be5a2d 569 NotCorrupted &= SafeFread( (char*) &(bmfh.bfType) , sizeof(ebmpWORD), 1, fp);
bhill42 3:141c57be5a2d 570
bhill42 3:141c57be5a2d 571 bool IsBitmap = false;
bhill42 3:141c57be5a2d 572
bhill42 3:141c57be5a2d 573 if( bmfh.bfType == 19778 )
bhill42 3:141c57be5a2d 574 { IsBitmap = true; }
bhill42 3:141c57be5a2d 575
bhill42 3:141c57be5a2d 576 if( !IsBitmap )
bhill42 3:141c57be5a2d 577 {
bhill42 3:141c57be5a2d 578 fclose( fp );
bhill42 3:141c57be5a2d 579 return false;
bhill42 3:141c57be5a2d 580 }
bhill42 1:bdeb188cb474 581
bhill42 3:141c57be5a2d 582 NotCorrupted &= SafeFread( (char*) &(bmfh.bfSize) , sizeof(ebmpDWORD) , 1, fp);
bhill42 3:141c57be5a2d 583 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved1) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 584 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved2) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 585 NotCorrupted &= SafeFread( (char*) &(bmfh.bfOffBits) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 586
bhill42 3:141c57be5a2d 587 // read the info header
bhill42 3:141c57be5a2d 588
bhill42 3:141c57be5a2d 589 BMIH bmih;
bhill42 1:bdeb188cb474 590
bhill42 3:141c57be5a2d 591 NotCorrupted &= SafeFread( (char*) &(bmih.biSize) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 592 NotCorrupted &= SafeFread( (char*) &(bmih.biWidth) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 593 NotCorrupted &= SafeFread( (char*) &(bmih.biHeight) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 594 NotCorrupted &= SafeFread( (char*) &(bmih.biPlanes) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 595 NotCorrupted &= SafeFread( (char*) &(bmih.biBitCount) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 596
bhill42 3:141c57be5a2d 597 NotCorrupted &= SafeFread( (char*) &(bmih.biCompression) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 598 NotCorrupted &= SafeFread( (char*) &(bmih.biSizeImage) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 599 NotCorrupted &= SafeFread( (char*) &(bmih.biXPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 600 NotCorrupted &= SafeFread( (char*) &(bmih.biYPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 601 NotCorrupted &= SafeFread( (char*) &(bmih.biClrUsed) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 602 NotCorrupted &= SafeFread( (char*) &(bmih.biClrImportant) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 603
bhill42 3:141c57be5a2d 604 // a safety catch: if any of the header information didn't read properly, abort
bhill42 3:141c57be5a2d 605 // future idea: check to see if at least most is self-consistent
bhill42 1:bdeb188cb474 606
bhill42 3:141c57be5a2d 607 if( !NotCorrupted )
bhill42 3:141c57be5a2d 608 {
bhill42 3:141c57be5a2d 609 fclose(fp);
bhill42 3:141c57be5a2d 610 return false;
bhill42 3:141c57be5a2d 611 }
bhill42 3:141c57be5a2d 612
bhill42 3:141c57be5a2d 613 // if bmih.biCompression 1 or 2, then the file is RLE compressed
bhill42 3:141c57be5a2d 614
bhill42 3:141c57be5a2d 615 if( bmih.biCompression == 1 || bmih.biCompression == 2 )
bhill42 3:141c57be5a2d 616 {
bhill42 3:141c57be5a2d 617 fclose(fp);
bhill42 3:141c57be5a2d 618 return false;
bhill42 3:141c57be5a2d 619 }
bhill42 3:141c57be5a2d 620
bhill42 3:141c57be5a2d 621 // if bmih.biCompression > 3, then something strange is going on
bhill42 3:141c57be5a2d 622 // it's probably an OS2 bitmap file.
bhill42 3:141c57be5a2d 623
bhill42 3:141c57be5a2d 624 if( bmih.biCompression > 3 )
bhill42 3:141c57be5a2d 625 {
bhill42 3:141c57be5a2d 626 fclose(fp);
bhill42 3:141c57be5a2d 627 return false;
bhill42 3:141c57be5a2d 628 }
bhill42 3:141c57be5a2d 629
bhill42 3:141c57be5a2d 630 if( bmih.biCompression == 3 && bmih.biBitCount != 16 )
bhill42 3:141c57be5a2d 631 {
bhill42 3:141c57be5a2d 632 fclose(fp);
bhill42 3:141c57be5a2d 633 return false;
bhill42 3:141c57be5a2d 634 }
bhill42 1:bdeb188cb474 635
bhill42 3:141c57be5a2d 636 // set the bit depth
bhill42 3:141c57be5a2d 637
bhill42 3:141c57be5a2d 638 int TempBitDepth = (int) bmih.biBitCount;
bhill42 3:141c57be5a2d 639 if( TempBitDepth != 1 && TempBitDepth != 4
bhill42 3:141c57be5a2d 640 && TempBitDepth != 8 && TempBitDepth != 16
bhill42 3:141c57be5a2d 641 && TempBitDepth != 24 && TempBitDepth != 32 )
bhill42 3:141c57be5a2d 642 {
bhill42 3:141c57be5a2d 643 fclose(fp);
bhill42 3:141c57be5a2d 644 return false;
bhill42 3:141c57be5a2d 645 }
bhill42 3:141c57be5a2d 646 BitDepth = (int)bmih.biBitCount;
bhill42 3:141c57be5a2d 647 // set the size
bhill42 3:141c57be5a2d 648
bhill42 3:141c57be5a2d 649 if( (int) bmih.biWidth <= 0 || (int) bmih.biHeight <= 0 )
bhill42 3:141c57be5a2d 650 {
bhill42 3:141c57be5a2d 651 fclose(fp);
bhill42 3:141c57be5a2d 652 return false;
bhill42 3:141c57be5a2d 653 }
bhill42 3:141c57be5a2d 654 Width = (int) bmih.biWidth;
bhill42 3:141c57be5a2d 655 Height = (int) bmih.biHeight;
bhill42 3:141c57be5a2d 656 // some preliminaries
bhill42 3:141c57be5a2d 657
bhill42 3:141c57be5a2d 658 double dBytesPerPixel = ( (double) BitDepth ) / 8.0;
bhill42 3:141c57be5a2d 659 double dBytesPerRow = dBytesPerPixel * (Width+0.0);
bhill42 3:141c57be5a2d 660 dBytesPerRow = ceil(dBytesPerRow);
bhill42 3:141c57be5a2d 661
bhill42 3:141c57be5a2d 662 int BytePaddingPerRow = 4 - ( (int) (dBytesPerRow) )% 4;
bhill42 3:141c57be5a2d 663 if( BytePaddingPerRow == 4 )
bhill42 3:141c57be5a2d 664 { BytePaddingPerRow = 0; }
bhill42 3:141c57be5a2d 665
bhill42 3:141c57be5a2d 666 // if < 16 bits, read the palette
bhill42 1:bdeb188cb474 667
bhill42 3:141c57be5a2d 668 if( BitDepth < 16 )
bhill42 3:141c57be5a2d 669 {
bhill42 3:141c57be5a2d 670 // determine the number of colors specified in the
bhill42 3:141c57be5a2d 671 // color table
bhill42 3:141c57be5a2d 672
bhill42 3:141c57be5a2d 673 int NumberOfColorsToRead = ((int) bmfh.bfOffBits - 54 )/4;
bhill42 3:141c57be5a2d 674 if( NumberOfColorsToRead > (1 << BitDepth) )
bhill42 3:141c57be5a2d 675 { NumberOfColorsToRead = (1 << BitDepth); }
bhill42 1:bdeb188cb474 676
bhill42 3:141c57be5a2d 677 int n;
bhill42 3:141c57be5a2d 678 for( n=0; n < NumberOfColorsToRead ; n++ )
bhill42 3:141c57be5a2d 679 {
bhill42 3:141c57be5a2d 680 SafeFread( (char*) &(Colors[n]) , 4 , 1 , fp);
bhill42 3:141c57be5a2d 681 }
bhill42 3:141c57be5a2d 682 for( n=NumberOfColorsToRead ; n < TellNumberOfColors(BitDepth) ; n++ )
bhill42 1:bdeb188cb474 683 {
bhill42 3:141c57be5a2d 684 RGBApixel HWITE;
bhill42 3:141c57be5a2d 685 HWITE.Red = 255;
bhill42 3:141c57be5a2d 686 HWITE.Green = 255;
bhill42 3:141c57be5a2d 687 HWITE.Blue = 255;
bhill42 3:141c57be5a2d 688 HWITE.Alpha = 0;
bhill42 3:141c57be5a2d 689 Colors[n] = HWITE;
bhill42 3:141c57be5a2d 690 }
bhill42 1:bdeb188cb474 691 }
bhill42 1:bdeb188cb474 692
bhill42 3:141c57be5a2d 693 // skip blank data if bfOffBits so indicates
bhill42 1:bdeb188cb474 694
bhill42 3:141c57be5a2d 695 int BytesToSkip = bmfh.bfOffBits - 54;;
bhill42 3:141c57be5a2d 696 if( BitDepth < 16 )
bhill42 3:141c57be5a2d 697 { BytesToSkip -= 4*(1 << BitDepth); }
bhill42 3:141c57be5a2d 698 if( BitDepth == 16 && bmih.biCompression == 3 )
bhill42 3:141c57be5a2d 699 { BytesToSkip -= 3*4; }
bhill42 3:141c57be5a2d 700 if( BytesToSkip < 0 )
bhill42 3:141c57be5a2d 701 { BytesToSkip = 0; }
bhill42 3:141c57be5a2d 702 if( BytesToSkip > 0 && BitDepth != 16 )
bhill42 3:141c57be5a2d 703 {
bhill42 3:141c57be5a2d 704 ebmpBYTE* TempSkipBYTE;
bhill42 3:141c57be5a2d 705 TempSkipBYTE = new ebmpBYTE [BytesToSkip];
bhill42 3:141c57be5a2d 706 SafeFread( (char*) TempSkipBYTE , BytesToSkip , 1 , fp);
bhill42 3:141c57be5a2d 707 delete [] TempSkipBYTE;
bhill42 3:141c57be5a2d 708 }
bhill42 1:bdeb188cb474 709
bhill42 3:141c57be5a2d 710 // This code reads 1, 4, 8, 24, and 32-bpp files
bhill42 3:141c57be5a2d 711 // with a more-efficient buffered technique.
bhill42 1:bdeb188cb474 712
bhill42 3:141c57be5a2d 713 int i,j;
bhill42 3:141c57be5a2d 714 if( BitDepth != 16 )
bhill42 3:141c57be5a2d 715 {
bhill42 3:141c57be5a2d 716 int BufferSize = (int) ( (Width*BitDepth) / 8.0 );
bhill42 3:141c57be5a2d 717 while( 8*BufferSize < Width*BitDepth )
bhill42 3:141c57be5a2d 718 { BufferSize++; }
bhill42 3:141c57be5a2d 719 while( BufferSize % 4 )
bhill42 3:141c57be5a2d 720 { BufferSize++; }
bhill42 3:141c57be5a2d 721 ebmpBYTE* Buffer;
bhill42 3:141c57be5a2d 722 Buffer = new ebmpBYTE [BufferSize];
bhill42 3:141c57be5a2d 723 j= Height-1;
bhill42 3:141c57be5a2d 724 while( j > -1 )
bhill42 3:141c57be5a2d 725 {
bhill42 3:141c57be5a2d 726 int BytesRead = (int) fread( (char*) Buffer, 1, BufferSize, fp );
bhill42 3:141c57be5a2d 727 if( BytesRead < BufferSize )
bhill42 3:141c57be5a2d 728 {
bhill42 3:141c57be5a2d 729 j = -1;
bhill42 3:141c57be5a2d 730 }
bhill42 3:141c57be5a2d 731 else
bhill42 3:141c57be5a2d 732 {
bhill42 3:141c57be5a2d 733 bool Success = false;
bhill42 3:141c57be5a2d 734 if( BitDepth == 1 )
bhill42 3:141c57be5a2d 735 { return -1; }
bhill42 3:141c57be5a2d 736 if( BitDepth == 4 )
bhill42 3:141c57be5a2d 737 { return -1; }
bhill42 3:141c57be5a2d 738 if( BitDepth == 8 )
bhill42 3:141c57be5a2d 739 { return -1; }
bhill42 3:141c57be5a2d 740 if( BitDepth == 24 )
bhill42 3:141c57be5a2d 741 {
bhill42 3:141c57be5a2d 742 // don't do BufferSize bounds checking, also NOTE: only bothering for 24 because that is what our image uses
bhill42 3:141c57be5a2d 743 Success = true;
bhill42 3:141c57be5a2d 744 for(int i=0 ; i < Width ; i++ )
bhill42 3:141c57be5a2d 745 {
bhill42 3:141c57be5a2d 746 int color = 0x00000000 | (Buffer[3*i+2] << 16) | (Buffer[3*i+1] << 8) | (Buffer[3*i+0]);
bhill42 3:141c57be5a2d 747 color_array[Width*j + i] = color; // width * row + col
bhill42 3:141c57be5a2d 748 //(*lcd).pixel(x+i,y+j,color);
bhill42 3:141c57be5a2d 749 }
bhill42 3:141c57be5a2d 750 }
bhill42 3:141c57be5a2d 751 if( BitDepth == 32 )
bhill42 3:141c57be5a2d 752 { return -1; }
bhill42 3:141c57be5a2d 753 if( !Success )
bhill42 3:141c57be5a2d 754 {
bhill42 3:141c57be5a2d 755 j = -1;
bhill42 3:141c57be5a2d 756 }
bhill42 3:141c57be5a2d 757 }
bhill42 3:141c57be5a2d 758 j--;
bhill42 3:141c57be5a2d 759 }
bhill42 3:141c57be5a2d 760 delete [] Buffer;
bhill42 3:141c57be5a2d 761 }
bhill42 1:bdeb188cb474 762
bhill42 3:141c57be5a2d 763 if( BitDepth == 16 )
bhill42 3:141c57be5a2d 764 {
bhill42 3:141c57be5a2d 765 return -1;
bhill42 3:141c57be5a2d 766 }
bhill42 3:141c57be5a2d 767
bhill42 3:141c57be5a2d 768 fclose(fp);
bhill42 3:141c57be5a2d 769 return true;
bhill42 3:141c57be5a2d 770 }
bhill42 3:141c57be5a2d 771
bhill42 3:141c57be5a2d 772 void DrawColorstoLCD(int * color_array, uLCD_4DGL *lcd, int x, int y, int w, int h)
bhill42 3:141c57be5a2d 773 {
bhill42 3:141c57be5a2d 774 for (int i = 0; i < w; i++)
bhill42 3:141c57be5a2d 775 {
bhill42 3:141c57be5a2d 776 for (int j = 0; j < h; j++)
bhill42 3:141c57be5a2d 777 {
bhill42 3:141c57be5a2d 778 (*lcd).pixel(x+i,y+j,color_array[w*j + i]);
bhill42 3:141c57be5a2d 779 }
bhill42 3:141c57be5a2d 780 }
bhill42 1:bdeb188cb474 781 }
bhill42 1:bdeb188cb474 782
bhill42 1:bdeb188cb474 783
bhill42 1:bdeb188cb474 784 BMIH::BMIH()
bhill42 1:bdeb188cb474 785 {
bhill42 1:bdeb188cb474 786 biPlanes = 1;
bhill42 1:bdeb188cb474 787 biCompression = 0;
bhill42 1:bdeb188cb474 788 biXPelsPerMeter = DefaultXPelsPerMeter;
bhill42 1:bdeb188cb474 789 biYPelsPerMeter = DefaultYPelsPerMeter;
bhill42 1:bdeb188cb474 790 biClrUsed = 0;
bhill42 1:bdeb188cb474 791 biClrImportant = 0;
bhill42 1:bdeb188cb474 792 }
bhill42 1:bdeb188cb474 793
bhill42 1:bdeb188cb474 794 BMFH::BMFH()
bhill42 1:bdeb188cb474 795 {
bhill42 1:bdeb188cb474 796 bfType = 19778;
bhill42 1:bdeb188cb474 797 bfReserved1 = 0;
bhill42 1:bdeb188cb474 798 bfReserved2 = 0;
bhill42 3:141c57be5a2d 799 }
bhill42 3:141c57be5a2d 800
bhill42 3:141c57be5a2d 801
bhill42 3:141c57be5a2d 802 bool ReadBMPFromFile(const char * FileName, RGBApixel *Colors, uLCD_4DGL *lcd, int x, int y)
bhill42 3:141c57be5a2d 803 {
bhill42 3:141c57be5a2d 804 FILE* fp = fopen( FileName, "rb" );
bhill42 3:141c57be5a2d 805 if( fp == NULL )
bhill42 3:141c57be5a2d 806 {
bhill42 3:141c57be5a2d 807 return false;
bhill42 3:141c57be5a2d 808 }
bhill42 3:141c57be5a2d 809
bhill42 3:141c57be5a2d 810 // read the file header
bhill42 3:141c57be5a2d 811
bhill42 3:141c57be5a2d 812 BMFH bmfh;
bhill42 3:141c57be5a2d 813 bool NotCorrupted = true;
bhill42 3:141c57be5a2d 814
bhill42 3:141c57be5a2d 815 NotCorrupted &= SafeFread( (char*) &(bmfh.bfType) , sizeof(ebmpWORD), 1, fp);
bhill42 3:141c57be5a2d 816
bhill42 3:141c57be5a2d 817 bool IsBitmap = false;
bhill42 3:141c57be5a2d 818
bhill42 3:141c57be5a2d 819 if( bmfh.bfType == 19778 )
bhill42 3:141c57be5a2d 820 { IsBitmap = true; }
bhill42 3:141c57be5a2d 821
bhill42 3:141c57be5a2d 822 if( !IsBitmap )
bhill42 3:141c57be5a2d 823 {
bhill42 3:141c57be5a2d 824 fclose( fp );
bhill42 3:141c57be5a2d 825 return false;
bhill42 3:141c57be5a2d 826 }
bhill42 3:141c57be5a2d 827
bhill42 3:141c57be5a2d 828 NotCorrupted &= SafeFread( (char*) &(bmfh.bfSize) , sizeof(ebmpDWORD) , 1, fp);
bhill42 3:141c57be5a2d 829 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved1) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 830 NotCorrupted &= SafeFread( (char*) &(bmfh.bfReserved2) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 831 NotCorrupted &= SafeFread( (char*) &(bmfh.bfOffBits) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 832
bhill42 3:141c57be5a2d 833 // read the info header
bhill42 3:141c57be5a2d 834
bhill42 3:141c57be5a2d 835 BMIH bmih;
bhill42 3:141c57be5a2d 836
bhill42 3:141c57be5a2d 837 NotCorrupted &= SafeFread( (char*) &(bmih.biSize) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 838 NotCorrupted &= SafeFread( (char*) &(bmih.biWidth) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 839 NotCorrupted &= SafeFread( (char*) &(bmih.biHeight) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 840 NotCorrupted &= SafeFread( (char*) &(bmih.biPlanes) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 841 NotCorrupted &= SafeFread( (char*) &(bmih.biBitCount) , sizeof(ebmpWORD) , 1, fp);
bhill42 3:141c57be5a2d 842
bhill42 3:141c57be5a2d 843 NotCorrupted &= SafeFread( (char*) &(bmih.biCompression) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 844 NotCorrupted &= SafeFread( (char*) &(bmih.biSizeImage) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 845 NotCorrupted &= SafeFread( (char*) &(bmih.biXPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 846 NotCorrupted &= SafeFread( (char*) &(bmih.biYPelsPerMeter) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 847 NotCorrupted &= SafeFread( (char*) &(bmih.biClrUsed) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 848 NotCorrupted &= SafeFread( (char*) &(bmih.biClrImportant) , sizeof(ebmpDWORD) , 1 , fp);
bhill42 3:141c57be5a2d 849
bhill42 3:141c57be5a2d 850 // a safety catch: if any of the header information didn't read properly, abort
bhill42 3:141c57be5a2d 851 // future idea: check to see if at least most is self-consistent
bhill42 3:141c57be5a2d 852
bhill42 3:141c57be5a2d 853 if( !NotCorrupted )
bhill42 3:141c57be5a2d 854 {
bhill42 3:141c57be5a2d 855 fclose(fp);
bhill42 3:141c57be5a2d 856 return false;
bhill42 3:141c57be5a2d 857 }
bhill42 3:141c57be5a2d 858
bhill42 3:141c57be5a2d 859 // if bmih.biCompression 1 or 2, then the file is RLE compressed
bhill42 3:141c57be5a2d 860
bhill42 3:141c57be5a2d 861 if( bmih.biCompression == 1 || bmih.biCompression == 2 )
bhill42 3:141c57be5a2d 862 {
bhill42 3:141c57be5a2d 863 fclose(fp);
bhill42 3:141c57be5a2d 864 return false;
bhill42 3:141c57be5a2d 865 }
bhill42 3:141c57be5a2d 866
bhill42 3:141c57be5a2d 867 // if bmih.biCompression > 3, then something strange is going on
bhill42 3:141c57be5a2d 868 // it's probably an OS2 bitmap file.
bhill42 3:141c57be5a2d 869
bhill42 3:141c57be5a2d 870 if( bmih.biCompression > 3 )
bhill42 3:141c57be5a2d 871 {
bhill42 3:141c57be5a2d 872 fclose(fp);
bhill42 3:141c57be5a2d 873 return false;
bhill42 3:141c57be5a2d 874 }
bhill42 3:141c57be5a2d 875
bhill42 3:141c57be5a2d 876 if( bmih.biCompression == 3 && bmih.biBitCount != 16 )
bhill42 3:141c57be5a2d 877 {
bhill42 3:141c57be5a2d 878 fclose(fp);
bhill42 3:141c57be5a2d 879 return false;
bhill42 3:141c57be5a2d 880 }
bhill42 3:141c57be5a2d 881
bhill42 3:141c57be5a2d 882 // set the bit depth
bhill42 3:141c57be5a2d 883
bhill42 3:141c57be5a2d 884 int TempBitDepth = (int) bmih.biBitCount;
bhill42 3:141c57be5a2d 885 if( TempBitDepth != 1 && TempBitDepth != 4
bhill42 3:141c57be5a2d 886 && TempBitDepth != 8 && TempBitDepth != 16
bhill42 3:141c57be5a2d 887 && TempBitDepth != 24 && TempBitDepth != 32 )
bhill42 3:141c57be5a2d 888 {
bhill42 3:141c57be5a2d 889 fclose(fp);
bhill42 3:141c57be5a2d 890 return false;
bhill42 3:141c57be5a2d 891 }
bhill42 3:141c57be5a2d 892 BitDepth = (int)bmih.biBitCount;
bhill42 3:141c57be5a2d 893 // set the size
bhill42 3:141c57be5a2d 894
bhill42 3:141c57be5a2d 895 if( (int) bmih.biWidth <= 0 || (int) bmih.biHeight <= 0 )
bhill42 3:141c57be5a2d 896 {
bhill42 3:141c57be5a2d 897 fclose(fp);
bhill42 3:141c57be5a2d 898 return false;
bhill42 3:141c57be5a2d 899 }
bhill42 3:141c57be5a2d 900 Width = (int) bmih.biWidth;
bhill42 3:141c57be5a2d 901 Height = (int) bmih.biHeight;
bhill42 3:141c57be5a2d 902 // some preliminaries
bhill42 3:141c57be5a2d 903
bhill42 3:141c57be5a2d 904 double dBytesPerPixel = ( (double) BitDepth ) / 8.0;
bhill42 3:141c57be5a2d 905 double dBytesPerRow = dBytesPerPixel * (Width+0.0);
bhill42 3:141c57be5a2d 906 dBytesPerRow = ceil(dBytesPerRow);
bhill42 3:141c57be5a2d 907
bhill42 3:141c57be5a2d 908 int BytePaddingPerRow = 4 - ( (int) (dBytesPerRow) )% 4;
bhill42 3:141c57be5a2d 909 if( BytePaddingPerRow == 4 )
bhill42 3:141c57be5a2d 910 { BytePaddingPerRow = 0; }
bhill42 3:141c57be5a2d 911
bhill42 3:141c57be5a2d 912 // if < 16 bits, read the palette
bhill42 3:141c57be5a2d 913
bhill42 3:141c57be5a2d 914 if( BitDepth < 16 )
bhill42 3:141c57be5a2d 915 {
bhill42 3:141c57be5a2d 916 // determine the number of colors specified in the
bhill42 3:141c57be5a2d 917 // color table
bhill42 3:141c57be5a2d 918
bhill42 3:141c57be5a2d 919 int NumberOfColorsToRead = ((int) bmfh.bfOffBits - 54 )/4;
bhill42 3:141c57be5a2d 920 if( NumberOfColorsToRead > (1 << BitDepth) )
bhill42 3:141c57be5a2d 921 { NumberOfColorsToRead = (1 << BitDepth); }
bhill42 3:141c57be5a2d 922
bhill42 3:141c57be5a2d 923 int n;
bhill42 3:141c57be5a2d 924 for( n=0; n < NumberOfColorsToRead ; n++ )
bhill42 3:141c57be5a2d 925 {
bhill42 3:141c57be5a2d 926 SafeFread( (char*) &(Colors[n]) , 4 , 1 , fp);
bhill42 3:141c57be5a2d 927 }
bhill42 3:141c57be5a2d 928 for( n=NumberOfColorsToRead ; n < TellNumberOfColors(BitDepth) ; n++ )
bhill42 3:141c57be5a2d 929 {
bhill42 3:141c57be5a2d 930 RGBApixel HWITE;
bhill42 3:141c57be5a2d 931 HWITE.Red = 255;
bhill42 3:141c57be5a2d 932 HWITE.Green = 255;
bhill42 3:141c57be5a2d 933 HWITE.Blue = 255;
bhill42 3:141c57be5a2d 934 HWITE.Alpha = 0;
bhill42 3:141c57be5a2d 935 Colors[n] = HWITE;
bhill42 3:141c57be5a2d 936 }
bhill42 3:141c57be5a2d 937 }
bhill42 3:141c57be5a2d 938
bhill42 3:141c57be5a2d 939 // skip blank data if bfOffBits so indicates
bhill42 3:141c57be5a2d 940
bhill42 3:141c57be5a2d 941 int BytesToSkip = bmfh.bfOffBits - 54;;
bhill42 3:141c57be5a2d 942 if( BitDepth < 16 )
bhill42 3:141c57be5a2d 943 { BytesToSkip -= 4*(1 << BitDepth); }
bhill42 3:141c57be5a2d 944 if( BitDepth == 16 && bmih.biCompression == 3 )
bhill42 3:141c57be5a2d 945 { BytesToSkip -= 3*4; }
bhill42 3:141c57be5a2d 946 if( BytesToSkip < 0 )
bhill42 3:141c57be5a2d 947 { BytesToSkip = 0; }
bhill42 3:141c57be5a2d 948 if( BytesToSkip > 0 && BitDepth != 16 )
bhill42 3:141c57be5a2d 949 {
bhill42 3:141c57be5a2d 950 ebmpBYTE* TempSkipBYTE;
bhill42 3:141c57be5a2d 951 TempSkipBYTE = new ebmpBYTE [BytesToSkip];
bhill42 3:141c57be5a2d 952 SafeFread( (char*) TempSkipBYTE , BytesToSkip , 1 , fp);
bhill42 3:141c57be5a2d 953 delete [] TempSkipBYTE;
bhill42 3:141c57be5a2d 954 }
bhill42 3:141c57be5a2d 955
bhill42 3:141c57be5a2d 956 // This code reads 1, 4, 8, 24, and 32-bpp files
bhill42 3:141c57be5a2d 957 // with a more-efficient buffered technique.
bhill42 3:141c57be5a2d 958
bhill42 3:141c57be5a2d 959 int i,j;
bhill42 3:141c57be5a2d 960 if( BitDepth != 16 )
bhill42 3:141c57be5a2d 961 {
bhill42 3:141c57be5a2d 962 int BufferSize = (int) ( (Width*BitDepth) / 8.0 );
bhill42 3:141c57be5a2d 963 while( 8*BufferSize < Width*BitDepth )
bhill42 3:141c57be5a2d 964 { BufferSize++; }
bhill42 3:141c57be5a2d 965 while( BufferSize % 4 )
bhill42 3:141c57be5a2d 966 { BufferSize++; }
bhill42 3:141c57be5a2d 967 ebmpBYTE* Buffer;
bhill42 3:141c57be5a2d 968 Buffer = new ebmpBYTE [BufferSize];
bhill42 3:141c57be5a2d 969 j= Height-1;
bhill42 3:141c57be5a2d 970 while( j > -1 )
bhill42 3:141c57be5a2d 971 {
bhill42 3:141c57be5a2d 972 int BytesRead = (int) fread( (char*) Buffer, 1, BufferSize, fp );
bhill42 3:141c57be5a2d 973 if( BytesRead < BufferSize )
bhill42 3:141c57be5a2d 974 {
bhill42 3:141c57be5a2d 975 j = -1;
bhill42 3:141c57be5a2d 976 }
bhill42 3:141c57be5a2d 977 else
bhill42 3:141c57be5a2d 978 {
bhill42 3:141c57be5a2d 979 bool Success = false;
bhill42 3:141c57be5a2d 980 if( BitDepth == 1 )
bhill42 3:141c57be5a2d 981 { Success = Read1bitRow( Buffer, BufferSize, j , lcd, x, y); }
bhill42 3:141c57be5a2d 982 if( BitDepth == 4 )
bhill42 3:141c57be5a2d 983 { Success = Read4bitRow( Buffer, BufferSize, j , lcd, x, y); }
bhill42 3:141c57be5a2d 984 if( BitDepth == 8 )
bhill42 3:141c57be5a2d 985 { Success = Read8bitRow( Buffer, BufferSize, j , lcd, x, y); }
bhill42 3:141c57be5a2d 986 if( BitDepth == 24 )
bhill42 3:141c57be5a2d 987 { Success = Read24bitRow( Buffer, BufferSize, j , lcd, x, y); }
bhill42 3:141c57be5a2d 988 if( BitDepth == 32 )
bhill42 3:141c57be5a2d 989 { Success = Read32bitRow( Buffer, BufferSize, j , lcd, x, y); }
bhill42 3:141c57be5a2d 990 if( !Success )
bhill42 3:141c57be5a2d 991 {
bhill42 3:141c57be5a2d 992 j = -1;
bhill42 3:141c57be5a2d 993 }
bhill42 3:141c57be5a2d 994 }
bhill42 3:141c57be5a2d 995 j--;
bhill42 3:141c57be5a2d 996 }
bhill42 3:141c57be5a2d 997 delete [] Buffer;
bhill42 3:141c57be5a2d 998 }
bhill42 3:141c57be5a2d 999
bhill42 3:141c57be5a2d 1000 if( BitDepth == 16 )
bhill42 3:141c57be5a2d 1001 {
bhill42 3:141c57be5a2d 1002 int DataBytes = Width*2;
bhill42 3:141c57be5a2d 1003 int PaddingBytes = ( 4 - DataBytes % 4 ) % 4;
bhill42 3:141c57be5a2d 1004
bhill42 3:141c57be5a2d 1005 // set the default mask
bhill42 3:141c57be5a2d 1006
bhill42 3:141c57be5a2d 1007 ebmpWORD BlueMask = 31; // bits 12-16
bhill42 3:141c57be5a2d 1008 ebmpWORD GreenMask = 992; // bits 7-11
bhill42 3:141c57be5a2d 1009 ebmpWORD RedMask = 31744; // bits 2-6
bhill42 3:141c57be5a2d 1010
bhill42 3:141c57be5a2d 1011 // read the bit fields, if necessary, to
bhill42 3:141c57be5a2d 1012 // override the default 5-5-5 mask
bhill42 3:141c57be5a2d 1013
bhill42 3:141c57be5a2d 1014 if( bmih.biCompression != 0 )
bhill42 3:141c57be5a2d 1015 {
bhill42 3:141c57be5a2d 1016 // read the three bit masks
bhill42 3:141c57be5a2d 1017
bhill42 3:141c57be5a2d 1018 ebmpWORD TempMaskWORD;
bhill42 3:141c57be5a2d 1019
bhill42 3:141c57be5a2d 1020 SafeFread( (char*) &RedMask , 2 , 1 , fp );
bhill42 3:141c57be5a2d 1021 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 3:141c57be5a2d 1022
bhill42 3:141c57be5a2d 1023 SafeFread( (char*) &GreenMask , 2 , 1 , fp );
bhill42 3:141c57be5a2d 1024 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 3:141c57be5a2d 1025
bhill42 3:141c57be5a2d 1026 SafeFread( (char*) &BlueMask , 2 , 1 , fp );
bhill42 3:141c57be5a2d 1027 SafeFread( (char*) &TempMaskWORD , 2, 1, fp );
bhill42 3:141c57be5a2d 1028 }
bhill42 3:141c57be5a2d 1029
bhill42 3:141c57be5a2d 1030 // read and skip any meta data
bhill42 3:141c57be5a2d 1031
bhill42 3:141c57be5a2d 1032 if( BytesToSkip > 0 )
bhill42 3:141c57be5a2d 1033 {
bhill42 3:141c57be5a2d 1034 ebmpBYTE* TempSkipBYTE;
bhill42 3:141c57be5a2d 1035 TempSkipBYTE = new ebmpBYTE [BytesToSkip];
bhill42 3:141c57be5a2d 1036 SafeFread( (char*) TempSkipBYTE , BytesToSkip , 1 , fp);
bhill42 3:141c57be5a2d 1037 delete [] TempSkipBYTE;
bhill42 3:141c57be5a2d 1038 }
bhill42 3:141c57be5a2d 1039
bhill42 3:141c57be5a2d 1040 // determine the red, green and blue shifts
bhill42 3:141c57be5a2d 1041
bhill42 3:141c57be5a2d 1042 int GreenShift = 0;
bhill42 3:141c57be5a2d 1043 ebmpWORD TempShiftWORD = GreenMask;
bhill42 3:141c57be5a2d 1044 while( TempShiftWORD > 31 )
bhill42 3:141c57be5a2d 1045 { TempShiftWORD = TempShiftWORD>>1; GreenShift++; }
bhill42 3:141c57be5a2d 1046 int BlueShift = 0;
bhill42 3:141c57be5a2d 1047 TempShiftWORD = BlueMask;
bhill42 3:141c57be5a2d 1048 while( TempShiftWORD > 31 )
bhill42 3:141c57be5a2d 1049 { TempShiftWORD = TempShiftWORD>>1; BlueShift++; }
bhill42 3:141c57be5a2d 1050 int RedShift = 0;
bhill42 3:141c57be5a2d 1051 TempShiftWORD = RedMask;
bhill42 3:141c57be5a2d 1052 while( TempShiftWORD > 31 )
bhill42 3:141c57be5a2d 1053 { TempShiftWORD = TempShiftWORD>>1; RedShift++; }
bhill42 3:141c57be5a2d 1054
bhill42 3:141c57be5a2d 1055 // read the actual pixels
bhill42 3:141c57be5a2d 1056
bhill42 3:141c57be5a2d 1057 for( j=Height-1 ; j >= 0 ; j-- )
bhill42 3:141c57be5a2d 1058 {
bhill42 3:141c57be5a2d 1059 i=0;
bhill42 3:141c57be5a2d 1060 int ReadNumber = 0;
bhill42 3:141c57be5a2d 1061 while( ReadNumber < DataBytes )
bhill42 3:141c57be5a2d 1062 {
bhill42 3:141c57be5a2d 1063 ebmpWORD TempWORD;
bhill42 3:141c57be5a2d 1064 SafeFread( (char*) &TempWORD , 2 , 1 , fp );
bhill42 3:141c57be5a2d 1065 ReadNumber += 2;
bhill42 3:141c57be5a2d 1066
bhill42 3:141c57be5a2d 1067 ebmpWORD Red = RedMask & TempWORD;
bhill42 3:141c57be5a2d 1068 ebmpWORD Green = GreenMask & TempWORD;
bhill42 3:141c57be5a2d 1069 ebmpWORD Blue = BlueMask & TempWORD;
bhill42 3:141c57be5a2d 1070
bhill42 3:141c57be5a2d 1071 ebmpBYTE BlueBYTE = (ebmpBYTE) 8*(Blue>>BlueShift);
bhill42 3:141c57be5a2d 1072 ebmpBYTE GreenBYTE = (ebmpBYTE) 8*(Green>>GreenShift);
bhill42 3:141c57be5a2d 1073 ebmpBYTE RedBYTE = (ebmpBYTE) 8*(Red>>RedShift);
bhill42 3:141c57be5a2d 1074
bhill42 3:141c57be5a2d 1075 int color = 0x00000000 | (RedBYTE << 16) | (GreenBYTE << 8) | (BlueBYTE);
bhill42 3:141c57be5a2d 1076 (*lcd).pixel(x+i,y+j,color);
bhill42 3:141c57be5a2d 1077 i++;
bhill42 3:141c57be5a2d 1078 }
bhill42 3:141c57be5a2d 1079 ReadNumber = 0;
bhill42 3:141c57be5a2d 1080 while( ReadNumber < PaddingBytes )
bhill42 3:141c57be5a2d 1081 {
bhill42 3:141c57be5a2d 1082 ebmpBYTE TempBYTE;
bhill42 3:141c57be5a2d 1083 SafeFread( (char*) &TempBYTE , 1, 1, fp);
bhill42 3:141c57be5a2d 1084 ReadNumber++;
bhill42 3:141c57be5a2d 1085 }
bhill42 3:141c57be5a2d 1086 }
bhill42 3:141c57be5a2d 1087
bhill42 3:141c57be5a2d 1088 }
bhill42 3:141c57be5a2d 1089
bhill42 3:141c57be5a2d 1090 fclose(fp);
bhill42 3:141c57be5a2d 1091 return true;
bhill42 1:bdeb188cb474 1092 }