1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // Intel License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 // Third party copyrights are property of their respective owners. 15 // 16 // Redistribution and use in source and binary forms, with or without modification, 17 // are permitted provided that the following conditions are met: 18 // 19 // * Redistribution's of source code must retain the above copyright notice, 20 // this list of conditions and the following disclaimer. 21 // 22 // * Redistribution's in binary form must reproduce the above copyright notice, 23 // this list of conditions and the following disclaimer in the documentation 24 // and/or other materials provided with the distribution. 25 // 26 // * The name of Intel Corporation may not be used to endorse or promote products 27 // derived from this software without specific prior written permission. 28 // 29 // This software is provided by the copyright holders and contributors "as is" and 30 // any express or implied warranties, including, but not limited to, the implied 31 // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 // In no event shall the Intel Corporation or contributors be liable for any direct, 33 // indirect, incidental, special, exemplary, or consequential damages 34 // (including, but not limited to, procurement of substitute goods or services; 35 // loss of use, data, or profits; or business interruption) however caused 36 // and on any theory of liability, whether in contract, strict liability, 37 // or tort (including negligence or otherwise) arising in any way out of 38 // the use of this software, even if advised of the possibility of such damage. 39 // 40 //M*/ 41 42 #include "_highgui.h" 43 #include "grfmt_bmp.h" 44 45 static const char* fmtSignBmp = "BM"; 46 47 GrFmtBmp::GrFmtBmp() 48 { 49 m_sign_len = 2; 50 m_signature = fmtSignBmp; 51 m_description = "Windows bitmap (*.bmp;*.dib)"; 52 } 53 54 55 GrFmtBmp::~GrFmtBmp() 56 { 57 } 58 59 60 GrFmtReader* GrFmtBmp::NewReader( const char* filename ) 61 { 62 return new GrFmtBmpReader( filename ); 63 } 64 65 66 GrFmtWriter* GrFmtBmp::NewWriter( const char* filename ) 67 { 68 return new GrFmtBmpWriter( filename ); 69 } 70 71 72 /************************ BMP reader *****************************/ 73 74 GrFmtBmpReader::GrFmtBmpReader( const char* filename ) : GrFmtReader( filename ) 75 { 76 m_offset = -1; 77 } 78 79 80 GrFmtBmpReader::~GrFmtBmpReader() 81 { 82 } 83 84 85 void GrFmtBmpReader::Close() 86 { 87 m_strm.Close(); 88 GrFmtReader::Close(); 89 } 90 91 92 bool GrFmtBmpReader::ReadHeader() 93 { 94 bool result = false; 95 96 assert( strlen(m_filename) != 0 ); 97 if( !m_strm.Open( m_filename )) return false; 98 99 if( setjmp( m_strm.JmpBuf()) == 0 ) 100 { 101 m_strm.Skip( 10 ); 102 m_offset = m_strm.GetDWord(); 103 104 int size = m_strm.GetDWord(); 105 106 if( size >= 36 ) 107 { 108 m_width = m_strm.GetDWord(); 109 m_height = m_strm.GetDWord(); 110 m_bpp = m_strm.GetDWord() >> 16; 111 m_rle_code = (BmpCompression)m_strm.GetDWord(); 112 m_strm.Skip(12); 113 int clrused = m_strm.GetDWord(); 114 m_strm.Skip( size - 36 ); 115 116 if( m_width > 0 && m_height > 0 && 117 (((m_bpp == 1 || m_bpp == 4 || m_bpp == 8 || 118 m_bpp == 24 || m_bpp == 32 ) && m_rle_code == BMP_RGB) || 119 (m_bpp == 16 && (m_rle_code == BMP_RGB || m_rle_code == BMP_BITFIELDS)) || 120 (m_bpp == 4 && m_rle_code == BMP_RLE4) || 121 (m_bpp == 8 && m_rle_code == BMP_RLE8))) 122 { 123 m_iscolor = true; 124 result = true; 125 126 if( m_bpp <= 8 ) 127 { 128 memset( m_palette, 0, sizeof(m_palette)); 129 m_strm.GetBytes( m_palette, (clrused == 0? 1<<m_bpp : clrused)*4 ); 130 m_iscolor = IsColorPalette( m_palette, m_bpp ); 131 } 132 else if( m_bpp == 16 && m_rle_code == BMP_BITFIELDS ) 133 { 134 int redmask = m_strm.GetDWord(); 135 int greenmask = m_strm.GetDWord(); 136 int bluemask = m_strm.GetDWord(); 137 138 if( bluemask == 0x1f && greenmask == 0x3e0 && redmask == 0x7c00 ) 139 m_bpp = 15; 140 else if( bluemask == 0x1f && greenmask == 0x7e0 && redmask == 0xf800 ) 141 ; 142 else 143 result = false; 144 } 145 else if( m_bpp == 16 && m_rle_code == BMP_RGB ) 146 m_bpp = 15; 147 } 148 } 149 else if( size == 12 ) 150 { 151 m_width = m_strm.GetWord(); 152 m_height = m_strm.GetWord(); 153 m_bpp = m_strm.GetDWord() >> 16; 154 m_rle_code = BMP_RGB; 155 156 if( m_width > 0 && m_height > 0 && 157 (m_bpp == 1 || m_bpp == 4 || m_bpp == 8 || 158 m_bpp == 24 || m_bpp == 32 )) 159 { 160 if( m_bpp <= 8 ) 161 { 162 uchar buffer[256*3]; 163 int j, clrused = 1 << m_bpp; 164 m_strm.GetBytes( buffer, clrused*3 ); 165 for( j = 0; j < clrused; j++ ) 166 { 167 m_palette[j].b = buffer[3*j+0]; 168 m_palette[j].g = buffer[3*j+1]; 169 m_palette[j].r = buffer[3*j+2]; 170 } 171 } 172 result = true; 173 } 174 } 175 } 176 177 if( !result ) 178 { 179 m_offset = -1; 180 m_width = m_height = -1; 181 m_strm.Close(); 182 } 183 return result; 184 } 185 186 187 bool GrFmtBmpReader::ReadData( uchar* data, int step, int color ) 188 { 189 const int buffer_size = 1 << 12; 190 uchar buffer[buffer_size]; 191 uchar bgr_buffer[buffer_size]; 192 uchar gray_palette[256]; 193 bool result = false; 194 uchar* src = buffer; 195 uchar* bgr = bgr_buffer; 196 int src_pitch = ((m_width*(m_bpp != 15 ? m_bpp : 16) + 7)/8 + 3) & -4; 197 int nch = color ? 3 : 1; 198 int width3 = m_width*nch; 199 int y; 200 201 if( m_offset < 0 || !m_strm.IsOpened()) 202 return false; 203 204 data += (m_height - 1)*step; 205 step = -step; 206 207 if( (m_bpp != 24 || !color) && src_pitch+32 > buffer_size ) 208 src = new uchar[src_pitch+32]; 209 210 if( !color ) 211 { 212 if( m_bpp <= 8 ) 213 { 214 CvtPaletteToGray( m_palette, gray_palette, 1 << m_bpp ); 215 } 216 if( m_width*3 + 32 > buffer_size ) bgr = new uchar[m_width*3 + 32]; 217 } 218 219 if( setjmp( m_strm.JmpBuf()) == 0 ) 220 { 221 m_strm.SetPos( m_offset ); 222 223 switch( m_bpp ) 224 { 225 /************************* 1 BPP ************************/ 226 case 1: 227 for( y = 0; y < m_height; y++, data += step ) 228 { 229 m_strm.GetBytes( src, src_pitch ); 230 FillColorRow1( color ? data : bgr, src, m_width, m_palette ); 231 if( !color ) 232 icvCvt_BGR2Gray_8u_C3C1R( bgr, 0, data, 0, cvSize(m_width,1) ); 233 } 234 result = true; 235 break; 236 237 /************************* 4 BPP ************************/ 238 case 4: 239 if( m_rle_code == BMP_RGB ) 240 { 241 for( y = 0; y < m_height; y++, data += step ) 242 { 243 m_strm.GetBytes( src, src_pitch ); 244 if( color ) 245 FillColorRow4( data, src, m_width, m_palette ); 246 else 247 FillGrayRow4( data, src, m_width, gray_palette ); 248 } 249 result = true; 250 } 251 else if( m_rle_code == BMP_RLE4 ) // rle4 compression 252 { 253 uchar* line_end = data + width3; 254 y = 0; 255 256 for(;;) 257 { 258 int code = m_strm.GetWord(); 259 int len = code & 255; 260 code >>= 8; 261 if( len != 0 ) // encoded mode 262 { 263 PaletteEntry clr[2]; 264 uchar gray_clr[2]; 265 int t = 0; 266 267 clr[0] = m_palette[code >> 4]; 268 clr[1] = m_palette[code & 15]; 269 gray_clr[0] = gray_palette[code >> 4]; 270 gray_clr[1] = gray_palette[code & 15]; 271 272 uchar* end = data + len*nch; 273 if( end > line_end ) goto decode_rle4_bad; 274 do 275 { 276 if( color ) 277 WRITE_PIX( data, clr[t] ); 278 else 279 *data = gray_clr[t]; 280 t ^= 1; 281 } 282 while( (data += nch) < end ); 283 } 284 else if( code > 2 ) // absolute mode 285 { 286 if( data + code*nch > line_end ) goto decode_rle4_bad; 287 m_strm.GetBytes( src, (((code + 1)>>1) + 1) & -2 ); 288 if( color ) 289 data = FillColorRow4( data, src, code, m_palette ); 290 else 291 data = FillGrayRow4( data, src, code, gray_palette ); 292 } 293 else 294 { 295 int x_shift3 = (int)(line_end - data); 296 int y_shift = m_height - y; 297 298 if( code == 2 ) 299 { 300 x_shift3 = m_strm.GetByte()*nch; 301 y_shift = m_strm.GetByte(); 302 } 303 304 len = x_shift3 + (y_shift * width3) & ((code == 0) - 1); 305 306 if( color ) 307 data = FillUniColor( data, line_end, step, width3, 308 y, m_height, x_shift3, 309 m_palette[0] ); 310 else 311 data = FillUniGray( data, line_end, step, width3, 312 y, m_height, x_shift3, 313 gray_palette[0] ); 314 315 if( y >= m_height ) 316 break; 317 } 318 } 319 320 result = true; 321 decode_rle4_bad: ; 322 } 323 break; 324 325 /************************* 8 BPP ************************/ 326 case 8: 327 if( m_rle_code == BMP_RGB ) 328 { 329 for( y = 0; y < m_height; y++, data += step ) 330 { 331 m_strm.GetBytes( src, src_pitch ); 332 if( color ) 333 FillColorRow8( data, src, m_width, m_palette ); 334 else 335 FillGrayRow8( data, src, m_width, gray_palette ); 336 } 337 result = true; 338 } 339 else if( m_rle_code == BMP_RLE8 ) // rle8 compression 340 { 341 uchar* line_end = data + width3; 342 int line_end_flag = 0; 343 y = 0; 344 345 for(;;) 346 { 347 int code = m_strm.GetWord(); 348 int len = code & 255; 349 code >>= 8; 350 if( len != 0 ) // encoded mode 351 { 352 int prev_y = y; 353 len *= nch; 354 355 if( data + len > line_end ) 356 goto decode_rle8_bad; 357 358 if( color ) 359 data = FillUniColor( data, line_end, step, width3, 360 y, m_height, len, 361 m_palette[code] ); 362 else 363 data = FillUniGray( data, line_end, step, width3, 364 y, m_height, len, 365 gray_palette[code] ); 366 367 line_end_flag = y - prev_y; 368 } 369 else if( code > 2 ) // absolute mode 370 { 371 int prev_y = y; 372 int code3 = code*nch; 373 374 if( data + code3 > line_end ) 375 goto decode_rle8_bad; 376 m_strm.GetBytes( src, (code + 1) & -2 ); 377 if( color ) 378 data = FillColorRow8( data, src, code, m_palette ); 379 else 380 data = FillGrayRow8( data, src, code, gray_palette ); 381 382 line_end_flag = y - prev_y; 383 } 384 else 385 { 386 int x_shift3 = (int)(line_end - data); 387 int y_shift = m_height - y; 388 389 if( code || !line_end_flag || x_shift3 < width3 ) 390 { 391 if( code == 2 ) 392 { 393 x_shift3 = m_strm.GetByte()*nch; 394 y_shift = m_strm.GetByte(); 395 } 396 397 x_shift3 += (y_shift * width3) & ((code == 0) - 1); 398 399 if( y >= m_height ) 400 break; 401 402 if( color ) 403 data = FillUniColor( data, line_end, step, width3, 404 y, m_height, x_shift3, 405 m_palette[0] ); 406 else 407 data = FillUniGray( data, line_end, step, width3, 408 y, m_height, x_shift3, 409 gray_palette[0] ); 410 411 if( y >= m_height ) 412 break; 413 } 414 415 line_end_flag = 0; 416 } 417 } 418 419 result = true; 420 decode_rle8_bad: ; 421 } 422 break; 423 /************************* 15 BPP ************************/ 424 case 15: 425 for( y = 0; y < m_height; y++, data += step ) 426 { 427 m_strm.GetBytes( src, src_pitch ); 428 if( !color ) 429 icvCvt_BGR5552Gray_8u_C2C1R( src, 0, data, 0, cvSize(m_width,1) ); 430 else 431 icvCvt_BGR5552BGR_8u_C2C3R( src, 0, data, 0, cvSize(m_width,1) ); 432 } 433 result = true; 434 break; 435 /************************* 16 BPP ************************/ 436 case 16: 437 for( y = 0; y < m_height; y++, data += step ) 438 { 439 m_strm.GetBytes( src, src_pitch ); 440 if( !color ) 441 icvCvt_BGR5652Gray_8u_C2C1R( src, 0, data, 0, cvSize(m_width,1) ); 442 else 443 icvCvt_BGR5652BGR_8u_C2C3R( src, 0, data, 0, cvSize(m_width,1) ); 444 } 445 result = true; 446 break; 447 /************************* 24 BPP ************************/ 448 case 24: 449 for( y = 0; y < m_height; y++, data += step ) 450 { 451 m_strm.GetBytes( color ? data : src, src_pitch ); 452 if( !color ) 453 icvCvt_BGR2Gray_8u_C3C1R( src, 0, data, 0, cvSize(m_width,1) ); 454 } 455 result = true; 456 break; 457 /************************* 32 BPP ************************/ 458 case 32: 459 for( y = 0; y < m_height; y++, data += step ) 460 { 461 m_strm.GetBytes( src, src_pitch ); 462 463 if( !color ) 464 icvCvt_BGRA2Gray_8u_C4C1R( src, 0, data, 0, cvSize(m_width,1) ); 465 else 466 icvCvt_BGRA2BGR_8u_C4C3R( src, 0, data, 0, cvSize(m_width,1) ); 467 } 468 result = true; 469 break; 470 default: 471 assert(0); 472 } 473 } 474 475 if( src != buffer ) delete[] src; 476 if( bgr != bgr_buffer ) delete[] bgr; 477 return result; 478 } 479 480 481 ////////////////////////////////////////////////////////////////////////////////////////// 482 483 GrFmtBmpWriter::GrFmtBmpWriter( const char* filename ) : GrFmtWriter( filename ) 484 { 485 } 486 487 488 GrFmtBmpWriter::~GrFmtBmpWriter() 489 { 490 } 491 492 493 bool GrFmtBmpWriter::WriteImage( const uchar* data, int step, 494 int width, int height, int /*depth*/, int channels ) 495 { 496 bool result = false; 497 int fileStep = (width*channels + 3) & -4; 498 uchar zeropad[] = "\0\0\0\0"; 499 500 assert( data && width > 0 && height > 0 && step >= fileStep ); 501 502 if( m_strm.Open( m_filename ) ) 503 { 504 int bitmapHeaderSize = 40; 505 int paletteSize = channels > 1 ? 0 : 1024; 506 int headerSize = 14 /* fileheader */ + bitmapHeaderSize + paletteSize; 507 PaletteEntry palette[256]; 508 509 // write signature 'BM' 510 m_strm.PutBytes( fmtSignBmp, (int)strlen(fmtSignBmp) ); 511 512 // write file header 513 m_strm.PutDWord( fileStep*height + headerSize ); // file size 514 m_strm.PutDWord( 0 ); 515 m_strm.PutDWord( headerSize ); 516 517 // write bitmap header 518 m_strm.PutDWord( bitmapHeaderSize ); 519 m_strm.PutDWord( width ); 520 m_strm.PutDWord( height ); 521 m_strm.PutWord( 1 ); 522 m_strm.PutWord( channels << 3 ); 523 m_strm.PutDWord( BMP_RGB ); 524 m_strm.PutDWord( 0 ); 525 m_strm.PutDWord( 0 ); 526 m_strm.PutDWord( 0 ); 527 m_strm.PutDWord( 0 ); 528 m_strm.PutDWord( 0 ); 529 530 if( channels == 1 ) 531 { 532 FillGrayPalette( palette, 8 ); 533 m_strm.PutBytes( palette, sizeof(palette)); 534 } 535 536 width *= channels; 537 data += step*(height - 1); 538 for( ; height--; data -= step ) 539 { 540 m_strm.PutBytes( data, width ); 541 if( fileStep > width ) 542 m_strm.PutBytes( zeropad, fileStep - width ); 543 } 544 545 m_strm.Close(); 546 result = true; 547 } 548 return result; 549 } 550 551 552
