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?
User | Revision | Line number | New 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 | } |