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_jpeg.h" 44 45 // JPEG filter factory 46 47 GrFmtJpeg::GrFmtJpeg() 48 { 49 m_sign_len = 3; 50 m_signature = "\xFF\xD8\xFF"; 51 m_description = "JPEG files (*.jpeg;*.jpg;*.jpe)"; 52 } 53 54 55 GrFmtJpeg::~GrFmtJpeg() 56 { 57 } 58 59 60 GrFmtReader* GrFmtJpeg::NewReader( const char* filename ) 61 { 62 return new GrFmtJpegReader( filename ); 63 } 64 65 66 GrFmtWriter* GrFmtJpeg::NewWriter( const char* filename ) 67 { 68 return new GrFmtJpegWriter( filename ); 69 } 70 71 72 #ifdef HAVE_JPEG 73 74 /****************************************************************************************\ 75 This part of the file implements JPEG codec on base of IJG libjpeg library, 76 in particular, this is the modified example.doc from libjpeg package. 77 See otherlibs/_graphics/readme.txt for copyright notice. 78 \****************************************************************************************/ 79 80 #include <stdio.h> 81 #include <setjmp.h> 82 83 #ifdef WIN32 84 85 #define XMD_H // prevent redefinition of INT32 86 #undef FAR // prevent FAR redefinition 87 88 #endif 89 90 #if defined WIN32 && defined __GNUC__ 91 typedef unsigned char boolean; 92 #endif 93 94 extern "C" { 95 #include "jpeglib.h" 96 } 97 98 /////////////////////// Error processing ///////////////////// 99 100 typedef struct GrFmtJpegErrorMgr 101 { 102 struct jpeg_error_mgr pub; /* "parent" structure */ 103 jmp_buf setjmp_buffer; /* jump label */ 104 } 105 GrFmtJpegErrorMgr; 106 107 108 METHODDEF(void) 109 error_exit( j_common_ptr cinfo ) 110 { 111 GrFmtJpegErrorMgr* err_mgr = (GrFmtJpegErrorMgr*)(cinfo->err); 112 113 /* Return control to the setjmp point */ 114 longjmp( err_mgr->setjmp_buffer, 1 ); 115 } 116 117 118 /////////////////////// GrFmtJpegReader /////////////////// 119 120 121 GrFmtJpegReader::GrFmtJpegReader( const char* filename ) : GrFmtReader( filename ) 122 { 123 m_cinfo = 0; 124 m_f = 0; 125 } 126 127 128 GrFmtJpegReader::~GrFmtJpegReader() 129 { 130 } 131 132 133 void GrFmtJpegReader::Close() 134 { 135 if( m_f ) 136 { 137 fclose( m_f ); 138 m_f = 0; 139 } 140 141 if( m_cinfo ) 142 { 143 jpeg_decompress_struct* cinfo = (jpeg_decompress_struct*)m_cinfo; 144 GrFmtJpegErrorMgr* jerr = (GrFmtJpegErrorMgr*)m_jerr; 145 146 jpeg_destroy_decompress( cinfo ); 147 delete cinfo; 148 delete jerr; 149 m_cinfo = 0; 150 m_jerr = 0; 151 } 152 GrFmtReader::Close(); 153 } 154 155 156 bool GrFmtJpegReader::ReadHeader() 157 { 158 bool result = false; 159 Close(); 160 161 jpeg_decompress_struct* cinfo = new jpeg_decompress_struct; 162 GrFmtJpegErrorMgr* jerr = new GrFmtJpegErrorMgr; 163 164 cinfo->err = jpeg_std_error(&jerr->pub); 165 jerr->pub.error_exit = error_exit; 166 167 m_cinfo = cinfo; 168 m_jerr = jerr; 169 170 if( setjmp( jerr->setjmp_buffer ) == 0 ) 171 { 172 jpeg_create_decompress( cinfo ); 173 174 m_f = fopen( m_filename, "rb" ); 175 if( m_f ) 176 { 177 jpeg_stdio_src( cinfo, m_f ); 178 jpeg_read_header( cinfo, TRUE ); 179 180 m_width = cinfo->image_width; 181 m_height = cinfo->image_height; 182 m_iscolor = cinfo->num_components > 1; 183 184 result = true; 185 } 186 } 187 188 if( !result ) 189 Close(); 190 191 return result; 192 } 193 194 /*************************************************************************** 195 * following code is for supporting MJPEG image files 196 * based on a message of Laurent Pinchart on the video4linux mailing list 197 ***************************************************************************/ 198 199 /* JPEG DHT Segment for YCrCb omitted from MJPEG data */ 200 static 201 unsigned char my_jpeg_odml_dht[0x1a4] = { 202 0xff, 0xc4, 0x01, 0xa2, 203 204 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 205 0x00, 0x00, 0x00, 0x00, 0x00, 206 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 207 208 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 209 0x00, 0x00, 0x00, 0x00, 0x00, 210 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 211 212 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 213 0x04, 0x00, 0x00, 0x01, 0x7d, 214 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 215 0x13, 0x51, 0x61, 0x07, 216 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 217 0x15, 0x52, 0xd1, 0xf0, 218 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 219 0x25, 0x26, 0x27, 0x28, 220 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 221 0x46, 0x47, 0x48, 0x49, 222 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 223 0x66, 0x67, 0x68, 0x69, 224 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 225 0x86, 0x87, 0x88, 0x89, 226 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 227 0xa4, 0xa5, 0xa6, 0xa7, 228 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 229 0xc2, 0xc3, 0xc4, 0xc5, 230 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 231 0xd9, 0xda, 0xe1, 0xe2, 232 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 233 0xf5, 0xf6, 0xf7, 0xf8, 234 0xf9, 0xfa, 235 236 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 237 0x04, 0x00, 0x01, 0x02, 0x77, 238 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 239 0x51, 0x07, 0x61, 0x71, 240 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 241 0x23, 0x33, 0x52, 0xf0, 242 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 243 0x18, 0x19, 0x1a, 0x26, 244 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 245 0x45, 0x46, 0x47, 0x48, 246 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 247 0x65, 0x66, 0x67, 0x68, 248 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 249 0x84, 0x85, 0x86, 0x87, 250 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 251 0xa2, 0xa3, 0xa4, 0xa5, 252 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 253 0xb9, 0xba, 0xc2, 0xc3, 254 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 255 0xd7, 0xd8, 0xd9, 0xda, 256 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 257 0xf5, 0xf6, 0xf7, 0xf8, 258 0xf9, 0xfa 259 }; 260 261 /* 262 * Parse the DHT table. 263 * This code comes from jpeg6b (jdmarker.c). 264 */ 265 static 266 int my_jpeg_load_dht (struct jpeg_decompress_struct *info, unsigned char *dht, 267 JHUFF_TBL *ac_tables[], JHUFF_TBL *dc_tables[]) 268 { 269 unsigned int length = (dht[2] << 8) + dht[3] - 2; 270 unsigned int pos = 4; 271 unsigned int count, i; 272 int index; 273 274 JHUFF_TBL **hufftbl; 275 unsigned char bits[17]; 276 unsigned char huffval[256]; 277 278 while (length > 16) 279 { 280 bits[0] = 0; 281 index = dht[pos++]; 282 count = 0; 283 for (i = 1; i <= 16; ++i) 284 { 285 bits[i] = dht[pos++]; 286 count += bits[i]; 287 } 288 length -= 17; 289 290 if (count > 256 || count > length) 291 return -1; 292 293 for (i = 0; i < count; ++i) 294 huffval[i] = dht[pos++]; 295 length -= count; 296 297 if (index & 0x10) 298 { 299 index -= 0x10; 300 hufftbl = &ac_tables[index]; 301 } 302 else 303 hufftbl = &dc_tables[index]; 304 305 if (index < 0 || index >= NUM_HUFF_TBLS) 306 return -1; 307 308 if (*hufftbl == NULL) 309 *hufftbl = jpeg_alloc_huff_table ((j_common_ptr)info); 310 if (*hufftbl == NULL) 311 return -1; 312 313 memcpy ((*hufftbl)->bits, bits, sizeof (*hufftbl)->bits); 314 memcpy ((*hufftbl)->huffval, huffval, sizeof (*hufftbl)->huffval); 315 } 316 317 if (length != 0) 318 return -1; 319 320 return 0; 321 } 322 323 /*************************************************************************** 324 * end of code for supportting MJPEG image files 325 * based on a message of Laurent Pinchart on the video4linux mailing list 326 ***************************************************************************/ 327 328 bool GrFmtJpegReader::ReadData( uchar* data, int step, int color ) 329 { 330 bool result = false; 331 332 color = color > 0 || (m_iscolor && color < 0); 333 334 if( m_cinfo && m_jerr && m_width && m_height ) 335 { 336 jpeg_decompress_struct* cinfo = (jpeg_decompress_struct*)m_cinfo; 337 GrFmtJpegErrorMgr* jerr = (GrFmtJpegErrorMgr*)m_jerr; 338 JSAMPARRAY buffer = 0; 339 340 if( setjmp( jerr->setjmp_buffer ) == 0 ) 341 { 342 /* check if this is a mjpeg image format */ 343 if ( cinfo->ac_huff_tbl_ptrs[0] == NULL && 344 cinfo->ac_huff_tbl_ptrs[1] == NULL && 345 cinfo->dc_huff_tbl_ptrs[0] == NULL && 346 cinfo->dc_huff_tbl_ptrs[1] == NULL ) 347 { 348 /* yes, this is a mjpeg image format, so load the correct 349 huffman table */ 350 my_jpeg_load_dht( cinfo, 351 my_jpeg_odml_dht, 352 cinfo->ac_huff_tbl_ptrs, 353 cinfo->dc_huff_tbl_ptrs ); 354 } 355 356 if( color > 0 || (m_iscolor && color < 0) ) 357 { 358 color = 1; 359 if( cinfo->num_components != 4 ) 360 { 361 cinfo->out_color_space = JCS_RGB; 362 cinfo->out_color_components = 3; 363 } 364 else 365 { 366 cinfo->out_color_space = JCS_CMYK; 367 cinfo->out_color_components = 4; 368 } 369 } 370 else 371 { 372 color = 0; 373 if( cinfo->num_components != 4 ) 374 { 375 cinfo->out_color_space = JCS_GRAYSCALE; 376 cinfo->out_color_components = 1; 377 } 378 else 379 { 380 cinfo->out_color_space = JCS_CMYK; 381 cinfo->out_color_components = 4; 382 } 383 } 384 385 jpeg_start_decompress( cinfo ); 386 387 buffer = (*cinfo->mem->alloc_sarray)((j_common_ptr)cinfo, 388 JPOOL_IMAGE, m_width*4, 1 ); 389 390 for( ; m_height--; data += step ) 391 { 392 jpeg_read_scanlines( cinfo, buffer, 1 ); 393 if( color ) 394 { 395 if( cinfo->out_color_components == 3 ) 396 icvCvt_RGB2BGR_8u_C3R( buffer[0], 0, data, 0, cvSize(m_width,1) ); 397 else 398 icvCvt_CMYK2BGR_8u_C4C3R( buffer[0], 0, data, 0, cvSize(m_width,1) ); 399 } 400 else 401 { 402 if( cinfo->out_color_components == 1 ) 403 memcpy( data, buffer[0], m_width ); 404 else 405 icvCvt_CMYK2Gray_8u_C4C1R( buffer[0], 0, data, 0, cvSize(m_width,1) ); 406 } 407 } 408 result = true; 409 jpeg_finish_decompress( cinfo ); 410 } 411 } 412 413 Close(); 414 return result; 415 } 416 417 418 /////////////////////// GrFmtJpegWriter /////////////////// 419 420 GrFmtJpegWriter::GrFmtJpegWriter( const char* filename ) : GrFmtWriter( filename ) 421 { 422 } 423 424 425 GrFmtJpegWriter::~GrFmtJpegWriter() 426 { 427 } 428 429 430 bool GrFmtJpegWriter::WriteImage( const uchar* data, int step, 431 int width, int height, int /*depth*/, int _channels ) 432 { 433 const int default_quality = 95; 434 struct jpeg_compress_struct cinfo; 435 GrFmtJpegErrorMgr jerr; 436 437 bool result = false; 438 FILE* f = 0; 439 int channels = _channels > 1 ? 3 : 1; 440 uchar* buffer = 0; // temporary buffer for row flipping 441 442 cinfo.err = jpeg_std_error(&jerr.pub); 443 jerr.pub.error_exit = error_exit; 444 445 if( setjmp( jerr.setjmp_buffer ) == 0 ) 446 { 447 jpeg_create_compress(&cinfo); 448 f = fopen( m_filename, "wb" ); 449 450 if( f ) 451 { 452 jpeg_stdio_dest( &cinfo, f ); 453 454 cinfo.image_width = width; 455 cinfo.image_height = height; 456 cinfo.input_components = channels; 457 cinfo.in_color_space = channels > 1 ? JCS_RGB : JCS_GRAYSCALE; 458 459 jpeg_set_defaults( &cinfo ); 460 jpeg_set_quality( &cinfo, default_quality, 461 TRUE /* limit to baseline-JPEG values */ ); 462 jpeg_start_compress( &cinfo, TRUE ); 463 464 if( channels > 1 ) 465 buffer = new uchar[width*channels]; 466 467 for( ; height--; data += step ) 468 { 469 uchar* ptr = (uchar*)data; 470 471 if( _channels == 3 ) 472 { 473 icvCvt_BGR2RGB_8u_C3R( data, 0, buffer, 0, cvSize(width,1) ); 474 ptr = buffer; 475 } 476 else if( _channels == 4 ) 477 { 478 icvCvt_BGRA2BGR_8u_C4C3R( data, 0, buffer, 0, cvSize(width,1), 2 ); 479 ptr = buffer; 480 } 481 482 jpeg_write_scanlines( &cinfo, &ptr, 1 ); 483 } 484 485 jpeg_finish_compress( &cinfo ); 486 result = true; 487 } 488 } 489 490 if(f) fclose(f); 491 jpeg_destroy_compress( &cinfo ); 492 493 delete[] buffer; 494 return result; 495 } 496 497 #else 498 499 ////////////////////// JPEG-oriented two-level bitstream //////////////////////// 500 501 RJpegBitStream::RJpegBitStream() 502 { 503 } 504 505 RJpegBitStream::~RJpegBitStream() 506 { 507 Close(); 508 } 509 510 511 bool RJpegBitStream::Open( const char* filename ) 512 { 513 Close(); 514 Allocate(); 515 516 m_is_opened = m_low_strm.Open( filename ); 517 if( m_is_opened ) SetPos(0); 518 return m_is_opened; 519 } 520 521 522 void RJpegBitStream::Close() 523 { 524 m_low_strm.Close(); 525 m_is_opened = false; 526 } 527 528 529 void RJpegBitStream::ReadBlock() 530 { 531 uchar* end = m_start + m_block_size; 532 uchar* current = m_start; 533 534 if( setjmp( m_low_strm.JmpBuf()) == 0 ) 535 { 536 int sz = m_unGetsize; 537 memmove( current - sz, m_end - sz, sz ); 538 while( current < end ) 539 { 540 int val = m_low_strm.GetByte(); 541 if( val != 0xff ) 542 { 543 *current++ = (uchar)val; 544 } 545 else 546 { 547 val = m_low_strm.GetByte(); 548 if( val == 0 ) 549 *current++ = 0xFF; 550 else if( !(0xD0 <= val && val <= 0xD7) ) 551 { 552 m_low_strm.SetPos( m_low_strm.GetPos() - 2 ); 553 goto fetch_end; 554 } 555 } 556 } 557 fetch_end: ; 558 } 559 else 560 { 561 if( current == m_start && m_jmp_set ) 562 longjmp( m_jmp_buf, RBS_THROW_EOS ); 563 } 564 m_current = m_start; 565 m_end = m_start + (((current - m_start) + 3) & -4); 566 if( !bsIsBigEndian() ) 567 bsBSwapBlock( m_start, m_end ); 568 } 569 570 571 void RJpegBitStream::Flush() 572 { 573 m_end = m_start + m_block_size; 574 m_current = m_end - 4; 575 m_bit_idx = 0; 576 } 577 578 void RJpegBitStream::AlignOnByte() 579 { 580 m_bit_idx &= -8; 581 } 582 583 int RJpegBitStream::FindMarker() 584 { 585 int code = m_low_strm.GetWord(); 586 while( (code & 0xFF00) != 0xFF00 || (code == 0xFFFF || code == 0xFF00 )) 587 { 588 code = ((code&255) << 8) | m_low_strm.GetByte(); 589 } 590 return code; 591 } 592 593 594 /****************************** JPEG (JFIF) reader ***************************/ 595 596 // zigzag & IDCT prescaling (AAN algorithm) tables 597 static const uchar zigzag[] = 598 { 599 0, 8, 1, 2, 9, 16, 24, 17, 10, 3, 4, 11, 18, 25, 32, 40, 600 33, 26, 19, 12, 5, 6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35, 601 28, 21, 14, 7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30, 602 23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63, 603 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63 604 }; 605 606 607 static const int idct_prescale[] = 608 { 609 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 610 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, 611 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, 612 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, 613 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 614 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, 615 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, 616 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 617 }; 618 619 620 #define fixb 14 621 #define fix(x, n) (int)((x)*(1 << (n)) + .5) 622 #define fix1(x, n) (x) 623 #define fixmul(x) (x) 624 625 #define C0_707 fix( 0.707106781f, fixb ) 626 #define C0_924 fix( 0.923879533f, fixb ) 627 #define C0_541 fix( 0.541196100f, fixb ) 628 #define C0_382 fix( 0.382683432f, fixb ) 629 #define C1_306 fix( 1.306562965f, fixb ) 630 631 #define C1_082 fix( 1.082392200f, fixb ) 632 #define C1_414 fix( 1.414213562f, fixb ) 633 #define C1_847 fix( 1.847759065f, fixb ) 634 #define C2_613 fix( 2.613125930f, fixb ) 635 636 #define fixc 12 637 #define b_cb fix( 1.772, fixc ) 638 #define g_cb -fix( 0.34414, fixc ) 639 #define g_cr -fix( 0.71414, fixc ) 640 #define r_cr fix( 1.402, fixc ) 641 642 #define y_r fix( 0.299, fixc ) 643 #define y_g fix( 0.587, fixc ) 644 #define y_b fix( 0.114, fixc ) 645 646 #define cb_r -fix( 0.1687, fixc ) 647 #define cb_g -fix( 0.3313, fixc ) 648 #define cb_b fix( 0.5, fixc ) 649 650 #define cr_r fix( 0.5, fixc ) 651 #define cr_g -fix( 0.4187, fixc ) 652 #define cr_b -fix( 0.0813, fixc ) 653 654 655 // IDCT without prescaling 656 static void aan_idct8x8( int *src, int *dst, int step ) 657 { 658 int workspace[64], *work = workspace; 659 int i; 660 661 /* Pass 1: process rows */ 662 for( i = 8; i > 0; i--, src += 8, work += 8 ) 663 { 664 /* Odd part */ 665 int x0 = src[5], x1 = src[3]; 666 int x2 = src[1], x3 = src[7]; 667 668 int x4 = x0 + x1; x0 -= x1; 669 670 x1 = x2 + x3; x2 -= x3; 671 x3 = x1 + x4; x1 -= x4; 672 673 x4 = (x0 + x2)*C1_847; 674 x0 = descale( x4 - x0*C2_613, fixb); 675 x2 = descale( x2*C1_082 - x4, fixb); 676 x1 = descale( x1*C1_414, fixb); 677 678 x0 -= x3; 679 x1 -= x0; 680 x2 += x1; 681 682 work[7] = x3; work[6] = x0; 683 work[5] = x1; work[4] = x2; 684 685 /* Even part */ 686 x2 = src[2]; x3 = src[6]; 687 x0 = src[0]; x1 = src[4]; 688 689 x4 = x2 + x3; 690 x2 = descale((x2-x3)*C1_414, fixb) - x4; 691 692 x3 = x0 + x1; x0 -= x1; 693 x1 = x3 + x4; x3 -= x4; 694 x4 = x0 + x2; x0 -= x2; 695 696 x2 = work[7]; 697 x1 -= x2; x2 = 2*x2 + x1; 698 work[7] = x1; work[0] = x2; 699 700 x2 = work[6]; 701 x1 = x4 + x2; x4 -= x2; 702 work[1] = x1; work[6] = x4; 703 704 x1 = work[5]; x2 = work[4]; 705 x4 = x0 + x1; x0 -= x1; 706 x1 = x3 + x2; x3 -= x2; 707 708 work[2] = x4; work[5] = x0; 709 work[3] = x3; work[4] = x1; 710 } 711 712 /* Pass 2: process columns */ 713 work = workspace; 714 for( i = 8; i > 0; i--, dst += step, work++ ) 715 { 716 /* Odd part */ 717 int x0 = work[8*5], x1 = work[8*3]; 718 int x2 = work[8*1], x3 = work[8*7]; 719 720 int x4 = x0 + x1; x0 -= x1; 721 x1 = x2 + x3; x2 -= x3; 722 x3 = x1 + x4; x1 -= x4; 723 724 x4 = (x0 + x2)*C1_847; 725 x0 = descale( x4 - x0*C2_613, fixb); 726 x2 = descale( x2*C1_082 - x4, fixb); 727 x1 = descale( x1*C1_414, fixb); 728 729 x0 -= x3; 730 x1 -= x0; 731 x2 += x1; 732 733 dst[7] = x3; dst[6] = x0; 734 dst[5] = x1; dst[4] = x2; 735 736 /* Even part */ 737 x2 = work[8*2]; x3 = work[8*6]; 738 x0 = work[8*0]; x1 = work[8*4]; 739 740 x4 = x2 + x3; 741 x2 = descale((x2-x3)*C1_414, fixb) - x4; 742 743 x3 = x0 + x1; x0 -= x1; 744 x1 = x3 + x4; x3 -= x4; 745 x4 = x0 + x2; x0 -= x2; 746 747 x2 = dst[7]; 748 x1 -= x2; x2 = 2*x2 + x1; 749 x1 = descale(x1,3); 750 x2 = descale(x2,3); 751 752 dst[7] = x1; dst[0] = x2; 753 754 x2 = dst[6]; 755 x1 = descale(x4 + x2,3); 756 x4 = descale(x4 - x2,3); 757 dst[1] = x1; dst[6] = x4; 758 759 x1 = dst[5]; x2 = dst[4]; 760 761 x4 = descale(x0 + x1,3); 762 x0 = descale(x0 - x1,3); 763 x1 = descale(x3 + x2,3); 764 x3 = descale(x3 - x2,3); 765 766 dst[2] = x4; dst[5] = x0; 767 dst[3] = x3; dst[4] = x1; 768 } 769 } 770 771 772 static const int max_dec_htable_size = 1 << 12; 773 static const int first_table_bits = 9; 774 775 GrFmtJpegReader::GrFmtJpegReader( const char* filename ) : GrFmtReader( filename ) 776 { 777 m_planes= -1; 778 m_offset= -1; 779 780 int i; 781 for( i = 0; i < 4; i++ ) 782 { 783 m_td[i] = new short[max_dec_htable_size]; 784 m_ta[i] = new short[max_dec_htable_size]; 785 } 786 } 787 788 789 GrFmtJpegReader::~GrFmtJpegReader() 790 { 791 for( int i = 0; i < 4; i++ ) 792 { 793 delete[] m_td[i]; 794 m_td[i] = 0; 795 delete[] m_ta[i]; 796 m_ta[i] = 0; 797 } 798 } 799 800 801 void GrFmtJpegReader::Close() 802 { 803 m_strm.Close(); 804 GrFmtReader::Close(); 805 } 806 807 808 bool GrFmtJpegReader::ReadHeader() 809 { 810 char buffer[16]; 811 int i; 812 bool result = false, is_sof = false, 813 is_qt = false, is_ht = false, is_sos = false; 814 815 assert( strlen(m_filename) != 0 ); 816 if( !m_strm.Open( m_filename )) return false; 817 818 memset( m_is_tq, 0, sizeof(m_is_tq)); 819 memset( m_is_td, 0, sizeof(m_is_td)); 820 memset( m_is_ta, 0, sizeof(m_is_ta)); 821 m_MCUs = 0; 822 823 if( setjmp( m_strm.JmpBuf()) == 0 ) 824 { 825 RMByteStream& lstrm = m_strm.m_low_strm; 826 827 lstrm.Skip( 2 ); // skip SOI marker 828 829 for(;;) 830 { 831 int marker = m_strm.FindMarker() & 255; 832 833 // check for standalone markers 834 if( marker != 0xD8 /* SOI */ && marker != 0xD9 /* EOI */ && 835 marker != 0x01 /* TEM */ && !( 0xD0 <= marker && marker <= 0xD7 )) 836 { 837 int pos = lstrm.GetPos(); 838 int length = lstrm.GetWord(); 839 840 switch( marker ) 841 { 842 case 0xE0: // APP0 843 lstrm.GetBytes( buffer, 5 ); 844 if( strcmp(buffer, "JFIF") == 0 ) // JFIF identification 845 { 846 m_version = lstrm.GetWord(); 847 //is_jfif = true; 848 } 849 break; 850 851 case 0xC0: // SOF0 852 m_precision = lstrm.GetByte(); 853 m_height = lstrm.GetWord(); 854 m_width = lstrm.GetWord(); 855 m_planes = lstrm.GetByte(); 856 857 if( m_width == 0 || m_height == 0 || // DNL not supported 858 (m_planes != 1 && m_planes != 3)) goto parsing_end; 859 860 m_iscolor = m_planes == 3; 861 862 memset( m_ci, -1, sizeof(m_ci)); 863 864 for( i = 0; i < m_planes; i++ ) 865 { 866 int idx = lstrm.GetByte(); 867 868 if( idx < 1 || idx > m_planes ) // wrong index 869 { 870 idx = i+1; // hack 871 } 872 cmp_info& ci = m_ci[idx-1]; 873 874 if( ci.tq > 0 /* duplicated description */) goto parsing_end; 875 876 ci.h = (char)lstrm.GetByte(); 877 ci.v = (char)(ci.h & 15); 878 ci.h >>= 4; 879 ci.tq = (char)lstrm.GetByte(); 880 if( !((ci.h == 1 || ci.h == 2 || ci.h == 4) && 881 (ci.v == 1 || ci.v == 2 || ci.v == 4) && 882 ci.tq < 3) || 883 // chroma mcu-parts should have equal sizes and 884 // be non greater then luma sizes 885 !( i != 2 || (ci.h == m_ci[1].h && ci.v == m_ci[1].v && 886 ci.h <= m_ci[0].h && ci.v <= m_ci[0].v))) 887 goto parsing_end; 888 } 889 is_sof = true; 890 m_type = marker - 0xC0; 891 break; 892 893 case 0xDB: // DQT 894 if( !LoadQuantTables( length )) goto parsing_end; 895 is_qt = true; 896 break; 897 898 case 0xC4: // DHT 899 if( !LoadHuffmanTables( length )) goto parsing_end; 900 is_ht = true; 901 break; 902 903 case 0xDA: // SOS 904 is_sos = true; 905 m_offset = pos - 2; 906 goto parsing_end; 907 908 case 0xDD: // DRI 909 m_MCUs = lstrm.GetWord(); 910 break; 911 } 912 lstrm.SetPos( pos + length ); 913 } 914 } 915 parsing_end: ; 916 } 917 918 result = /*is_jfif &&*/ is_sof && is_qt && is_ht && is_sos; 919 if( !result ) 920 { 921 m_width = m_height = -1; 922 m_offset = -1; 923 m_strm.Close(); 924 } 925 return result; 926 } 927 928 929 bool GrFmtJpegReader::LoadQuantTables( int length ) 930 { 931 uchar buffer[128]; 932 int i, tq_size; 933 934 RMByteStream& lstrm = m_strm.m_low_strm; 935 length -= 2; 936 937 while( length > 0 ) 938 { 939 int tq = lstrm.GetByte(); 940 int size = tq >> 4; 941 tq &= 15; 942 943 tq_size = (64<<size) + 1; 944 if( tq > 3 || size > 1 || length < tq_size ) return false; 945 length -= tq_size; 946 947 lstrm.GetBytes( buffer, tq_size - 1 ); 948 949 if( size == 0 ) // 8 bit quant factors 950 { 951 for( i = 0; i < 64; i++ ) 952 { 953 int idx = zigzag[i]; 954 m_tq[tq][idx] = buffer[i] * 16 * idct_prescale[idx]; 955 } 956 } 957 else // 16 bit quant factors 958 { 959 for( i = 0; i < 64; i++ ) 960 { 961 int idx = zigzag[i]; 962 m_tq[tq][idx] = ((unsigned short*)buffer)[i] * idct_prescale[idx]; 963 } 964 } 965 m_is_tq[tq] = true; 966 } 967 968 return true; 969 } 970 971 972 bool GrFmtJpegReader::LoadHuffmanTables( int length ) 973 { 974 const int max_bits = 16; 975 uchar buffer[1024]; 976 int buffer2[1024]; 977 978 int i, ht_size; 979 RMByteStream& lstrm = m_strm.m_low_strm; 980 length -= 2; 981 982 while( length > 0 ) 983 { 984 int t = lstrm.GetByte(); 985 int hclass = t >> 4; 986 t &= 15; 987 988 if( t > 3 || hclass > 1 || length < 17 ) return false; 989 length -= 17; 990 991 lstrm.GetBytes( buffer, max_bits ); 992 for( i = 0, ht_size = 0; i < max_bits; i++ ) ht_size += buffer[i]; 993 994 if( length < ht_size ) return false; 995 length -= ht_size; 996 997 lstrm.GetBytes( buffer + max_bits, ht_size ); 998 999 if( !::bsCreateDecodeHuffmanTable( 1000 ::bsCreateSourceHuffmanTable( 1001 buffer, buffer2, max_bits, first_table_bits ), 1002 hclass == 0 ? m_td[t] : m_ta[t], 1003 max_dec_htable_size )) return false; 1004 if( hclass == 0 ) 1005 m_is_td[t] = true; 1006 else 1007 m_is_ta[t] = true; 1008 } 1009 return true; 1010 } 1011 1012 1013 bool GrFmtJpegReader::ReadData( uchar* data, int step, int color ) 1014 { 1015 if( m_offset < 0 || !m_strm.IsOpened()) 1016 return false; 1017 1018 if( setjmp( m_strm.JmpBuf()) == 0 ) 1019 { 1020 RMByteStream& lstrm = m_strm.m_low_strm; 1021 lstrm.SetPos( m_offset ); 1022 1023 for(;;) 1024 { 1025 int marker = m_strm.FindMarker() & 255; 1026 1027 if( marker == 0xD8 /* SOI */ || marker == 0xD9 /* EOI */ ) 1028 goto decoding_end; 1029 1030 // check for standalone markers 1031 if( marker != 0x01 /* TEM */ && !( 0xD0 <= marker && marker <= 0xD7 )) 1032 { 1033 int pos = lstrm.GetPos(); 1034 int length = lstrm.GetWord(); 1035 1036 switch( marker ) 1037 { 1038 case 0xC4: // DHT 1039 if( !LoadHuffmanTables( length )) goto decoding_end; 1040 break; 1041 1042 case 0xDA: // SOS 1043 // read scan header 1044 { 1045 int idx[3] = { -1, -1, -1 }; 1046 int i, ns = lstrm.GetByte(); 1047 int sum = 0, a; // spectral selection & approximation 1048 1049 if( ns != m_planes ) goto decoding_end; 1050 for( i = 0; i < ns; i++ ) 1051 { 1052 int td, ta, c = lstrm.GetByte() - 1; 1053 if( c < 0 || m_planes <= c ) 1054 { 1055 c = i; // hack 1056 } 1057 1058 if( idx[c] != -1 ) goto decoding_end; 1059 idx[i] = c; 1060 td = lstrm.GetByte(); 1061 ta = td & 15; 1062 td >>= 4; 1063 if( !(ta <= 3 && m_is_ta[ta] && 1064 td <= 3 && m_is_td[td] && 1065 m_is_tq[m_ci[c].tq]) ) 1066 goto decoding_end; 1067 1068 m_ci[c].td = (char)td; 1069 m_ci[c].ta = (char)ta; 1070 1071 sum += m_ci[c].h*m_ci[c].v; 1072 } 1073 1074 if( sum > 10 ) goto decoding_end; 1075 1076 m_ss = lstrm.GetByte(); 1077 m_se = lstrm.GetByte(); 1078 1079 a = lstrm.GetByte(); 1080 m_al = a & 15; 1081 m_ah = a >> 4; 1082 1083 ProcessScan( idx, ns, data, step, color ); 1084 goto decoding_end; // only single scan case is supported now 1085 } 1086 1087 //m_offset = pos - 2; 1088 //break; 1089 1090 case 0xDD: // DRI 1091 m_MCUs = lstrm.GetWord(); 1092 break; 1093 } 1094 1095 if( marker != 0xDA ) lstrm.SetPos( pos + length ); 1096 } 1097 } 1098 decoding_end: ; 1099 } 1100 1101 return true; 1102 } 1103 1104 1105 void GrFmtJpegReader::ResetDecoder() 1106 { 1107 m_ci[0].dc_pred = m_ci[1].dc_pred = m_ci[2].dc_pred = 0; 1108 } 1109 1110 void GrFmtJpegReader::ProcessScan( int* idx, int ns, uchar* data, int step, int color ) 1111 { 1112 int i, s = 0, mcu, x1 = 0, y1 = 0; 1113 int temp[64]; 1114 int blocks[10][64]; 1115 int pos[3], h[3], v[3]; 1116 int x_shift = 0, y_shift = 0; 1117 int nch = color ? 3 : 1; 1118 1119 assert( ns == m_planes && m_ss == 0 && m_se == 63 && 1120 m_al == 0 && m_ah == 0 ); // sequental & single scan 1121 1122 assert( idx[0] == 0 && (ns ==1 || (idx[1] == 1 && idx[2] == 2))); 1123 1124 for( i = 0; i < ns; i++ ) 1125 { 1126 int c = idx[i]; 1127 h[c] = m_ci[c].h*8; 1128 v[c] = m_ci[c].v*8; 1129 pos[c] = s >> 6; 1130 s += h[c]*v[c]; 1131 } 1132 1133 if( ns == 3 ) 1134 { 1135 x_shift = h[0]/(h[1]*2); 1136 y_shift = v[0]/(v[1]*2); 1137 } 1138 1139 m_strm.Flush(); 1140 ResetDecoder(); 1141 1142 for( mcu = 0;; mcu++ ) 1143 { 1144 int x2, y2, x, y, xc; 1145 int* cmp; 1146 uchar* data1; 1147 1148 if( mcu == m_MCUs && m_MCUs != 0 ) 1149 { 1150 ResetDecoder(); 1151 m_strm.AlignOnByte(); 1152 mcu = 0; 1153 } 1154 1155 // Get mcu 1156 for( i = 0; i < ns; i++ ) 1157 { 1158 int c = idx[i]; 1159 cmp = blocks[pos[c]]; 1160 for( y = 0; y < v[c]; y += 8, cmp += h[c]*8 ) 1161 for( x = 0; x < h[c]; x += 8 ) 1162 { 1163 GetBlock( temp, c ); 1164 if( i < (color ? 3 : 1)) 1165 { 1166 aan_idct8x8( temp, cmp + x, h[c] ); 1167 } 1168 } 1169 } 1170 1171 y2 = v[0]; 1172 x2 = h[0]; 1173 1174 if( y1 + y2 > m_height ) y2 = m_height - y1; 1175 if( x1 + x2 > m_width ) x2 = m_width - x1; 1176 1177 cmp = blocks[0]; 1178 data1 = data + x1*nch; 1179 1180 if( ns == 1 ) 1181 for( y = 0; y < y2; y++, data1 += step, cmp += h[0] ) 1182 { 1183 if( color ) 1184 { 1185 for( x = 0; x < x2; x++ ) 1186 { 1187 int val = descale( cmp[x] + 128*4, 2 ); 1188 data1[x*3] = data1[x*3 + 1] = data1[x*3 + 2] = saturate( val ); 1189 } 1190 } 1191 else 1192 { 1193 for( x = 0; x < x2; x++ ) 1194 { 1195 int val = descale( cmp[x] + 128*4, 2 ); 1196 data1[x] = saturate( val ); 1197 } 1198 } 1199 } 1200 else 1201 { 1202 for( y = 0; y < y2; y++, data1 += step, cmp += h[0] ) 1203 { 1204 if( color ) 1205 { 1206 int shift = h[1]*(y >> y_shift); 1207 int* cmpCb = blocks[pos[1]] + shift; 1208 int* cmpCr = blocks[pos[2]] + shift; 1209 x = 0; 1210 if( x_shift == 0 ) 1211 { 1212 for( ; x < x2; x++ ) 1213 { 1214 int Y = (cmp[x] + 128*4) << fixc; 1215 int Cb = cmpCb[x]; 1216 int Cr = cmpCr[x]; 1217 int t = (Y + Cb*b_cb) >> (fixc + 2); 1218 data1[x*3] = saturate(t); 1219 t = (Y + Cb*g_cb + Cr*g_cr) >> (fixc + 2); 1220 data1[x*3 + 1] = saturate(t); 1221 t = (Y + Cr*r_cr) >> (fixc + 2); 1222 data1[x*3 + 2] = saturate(t); 1223 } 1224 } 1225 else if( x_shift == 1 ) 1226 { 1227 for( xc = 0; x <= x2 - 2; x += 2, xc++ ) 1228 { 1229 int Y = (cmp[x] + 128*4) << fixc; 1230 int Cb = cmpCb[xc]; 1231 int Cr = cmpCr[xc]; 1232 int t = (Y + Cb*b_cb) >> (fixc + 2); 1233 data1[x*3] = saturate(t); 1234 t = (Y + Cb*g_cb + Cr*g_cr) >> (fixc + 2); 1235 data1[x*3 + 1] = saturate(t); 1236 t = (Y + Cr*r_cr) >> (fixc + 2); 1237 data1[x*3 + 2] = saturate(t); 1238 Y = (cmp[x+1] + 128*4) << fixc; 1239 t = (Y + Cb*b_cb) >> (fixc + 2); 1240 data1[x*3 + 3] = saturate(t); 1241 t = (Y + Cb*g_cb + Cr*g_cr) >> (fixc + 2); 1242 data1[x*3 + 4] = saturate(t); 1243 t = (Y + Cr*r_cr) >> (fixc + 2); 1244 data1[x*3 + 5] = saturate(t); 1245 } 1246 } 1247 for( ; x < x2; x++ ) 1248 { 1249 int Y = (cmp[x] + 128*4) << fixc; 1250 int Cb = cmpCb[x >> x_shift]; 1251 int Cr = cmpCr[x >> x_shift]; 1252 int t = (Y + Cb*b_cb) >> (fixc + 2); 1253 data1[x*3] = saturate(t); 1254 t = (Y + Cb*g_cb + Cr*g_cr) >> (fixc + 2); 1255 data1[x*3 + 1] = saturate(t); 1256 t = (Y + Cr*r_cr) >> (fixc + 2); 1257 data1[x*3 + 2] = saturate(t); 1258 } 1259 } 1260 else 1261 { 1262 for( x = 0; x < x2; x++ ) 1263 { 1264 int val = descale( cmp[x] + 128*4, 2 ); 1265 data1[x] = saturate(val); 1266 } 1267 } 1268 } 1269 } 1270 1271 x1 += h[0]; 1272 if( x1 >= m_width ) 1273 { 1274 x1 = 0; 1275 y1 += v[0]; 1276 data += v[0]*step; 1277 if( y1 >= m_height ) break; 1278 } 1279 } 1280 } 1281 1282 1283 void GrFmtJpegReader::GetBlock( int* block, int c ) 1284 { 1285 memset( block, 0, 64*sizeof(block[0]) ); 1286 1287 assert( 0 <= c && c < 3 ); 1288 const short* td = m_td[m_ci[c].td]; 1289 const short* ta = m_ta[m_ci[c].ta]; 1290 const int* tq = m_tq[m_ci[c].tq]; 1291 1292 // Get DC coefficient 1293 int i = 0, cat = m_strm.GetHuff( td ); 1294 int mask = bs_bit_mask[cat]; 1295 int val = m_strm.Get( cat ); 1296 1297 val -= (val*2 <= mask ? mask : 0); 1298 m_ci[c].dc_pred = val += m_ci[c].dc_pred; 1299 1300 block[0] = descale(val * tq[0],16); 1301 1302 // Get AC coeffs 1303 for(;;) 1304 { 1305 cat = m_strm.GetHuff( ta ); 1306 if( cat == 0 ) break; // end of block 1307 1308 i += (cat >> 4) + 1; 1309 cat &= 15; 1310 mask = bs_bit_mask[cat]; 1311 val = m_strm.Get( cat ); 1312 cat = zigzag[i]; 1313 val -= (val*2 <= mask ? mask : 0); 1314 block[cat] = descale(val * tq[cat], 16); 1315 assert( i <= 63 ); 1316 if( i >= 63 ) break; 1317 } 1318 } 1319 1320 ////////////////////// WJpegStream /////////////////////// 1321 1322 WJpegBitStream::WJpegBitStream() 1323 { 1324 } 1325 1326 1327 WJpegBitStream::~WJpegBitStream() 1328 { 1329 Close(); 1330 m_is_opened = false; 1331 } 1332 1333 1334 1335 bool WJpegBitStream::Open( const char* filename ) 1336 { 1337 Close(); 1338 Allocate(); 1339 1340 m_is_opened = m_low_strm.Open( filename ); 1341 if( m_is_opened ) 1342 { 1343 m_block_pos = 0; 1344 ResetBuffer(); 1345 } 1346 return m_is_opened; 1347 } 1348 1349 1350 void WJpegBitStream::Close() 1351 { 1352 if( m_is_opened ) 1353 { 1354 Flush(); 1355 m_low_strm.Close(); 1356 m_is_opened = false; 1357 } 1358 } 1359 1360 1361 void WJpegBitStream::Flush() 1362 { 1363 Put( -1, m_bit_idx & 31 ); 1364 *((ulong*&)m_current)++ = m_val; 1365 WriteBlock(); 1366 ResetBuffer(); 1367 } 1368 1369 1370 void WJpegBitStream::WriteBlock() 1371 { 1372 uchar* ptr = m_start; 1373 if( !bsIsBigEndian() ) 1374 bsBSwapBlock( m_start, m_current ); 1375 1376 while( ptr < m_current ) 1377 { 1378 int val = *ptr++; 1379 m_low_strm.PutByte( val ); 1380 if( val == 0xff ) 1381 { 1382 m_low_strm.PutByte( 0 ); 1383 } 1384 } 1385 1386 m_current = m_start; 1387 } 1388 1389 1390 /////////////////////// GrFmtJpegWriter /////////////////// 1391 1392 GrFmtJpegWriter::GrFmtJpegWriter( const char* filename ) : GrFmtWriter( filename ) 1393 { 1394 } 1395 1396 GrFmtJpegWriter::~GrFmtJpegWriter() 1397 { 1398 } 1399 1400 // Standard JPEG quantization tables 1401 static const uchar jpegTableK1_T[] = 1402 { 1403 16, 12, 14, 14, 18, 24, 49, 72, 1404 11, 12, 13, 17, 22, 35, 64, 92, 1405 10, 14, 16, 22, 37, 55, 78, 95, 1406 16, 19, 24, 29, 56, 64, 87, 98, 1407 24, 26, 40, 51, 68, 81, 103, 112, 1408 40, 58, 57, 87, 109, 104, 121, 100, 1409 51, 60, 69, 80, 103, 113, 120, 103, 1410 61, 55, 56, 62, 77, 92, 101, 99 1411 }; 1412 1413 1414 static const uchar jpegTableK2_T[] = 1415 { 1416 17, 18, 24, 47, 99, 99, 99, 99, 1417 18, 21, 26, 66, 99, 99, 99, 99, 1418 24, 26, 56, 99, 99, 99, 99, 99, 1419 47, 66, 99, 99, 99, 99, 99, 99, 1420 99, 99, 99, 99, 99, 99, 99, 99, 1421 99, 99, 99, 99, 99, 99, 99, 99, 1422 99, 99, 99, 99, 99, 99, 99, 99, 1423 99, 99, 99, 99, 99, 99, 99, 99 1424 }; 1425 1426 1427 // Standard Huffman tables 1428 1429 // ... for luma DCs. 1430 static const uchar jpegTableK3[] = 1431 { 1432 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1433 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 1434 }; 1435 1436 1437 // ... for chroma DCs. 1438 static const uchar jpegTableK4[] = 1439 { 1440 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1441 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 1442 }; 1443 1444 1445 // ... for luma ACs. 1446 static const uchar jpegTableK5[] = 1447 { 1448 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125, 1449 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 1450 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 1451 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 1452 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 1453 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 1454 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 1455 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 1456 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 1457 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 1458 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 1459 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 1460 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 1461 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 1462 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 1463 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 1464 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 1465 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 1466 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 1467 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 1468 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 1469 0xf9, 0xfa 1470 }; 1471 1472 // ... for chroma ACs 1473 static const uchar jpegTableK6[] = 1474 { 1475 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119, 1476 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 1477 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 1478 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 1479 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 1480 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 1481 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 1482 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 1483 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 1484 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 1485 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 1486 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 1487 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 1488 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 1489 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 1490 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 1491 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 1492 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 1493 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 1494 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 1495 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 1496 0xf9, 0xfa 1497 }; 1498 1499 1500 static const char jpegHeader[] = 1501 "\xFF\xD8" // SOI - start of image 1502 "\xFF\xE0" // APP0 - jfif extention 1503 "\x00\x10" // 2 bytes: length of APP0 segment 1504 "JFIF\x00" // JFIF signature 1505 "\x01\x02" // version of JFIF 1506 "\x00" // units = pixels ( 1 - inch, 2 - cm ) 1507 "\x00\x01\x00\x01" // 2 2-bytes values: x density & y density 1508 "\x00\x00"; // width & height of thumbnail: ( 0x0 means no thumbnail) 1509 1510 #define postshift 14 1511 1512 // FDCT with postscaling 1513 static void aan_fdct8x8( int *src, int *dst, 1514 int step, const int *postscale ) 1515 { 1516 int workspace[64], *work = workspace; 1517 int i; 1518 1519 // Pass 1: process rows 1520 for( i = 8; i > 0; i--, src += step, work += 8 ) 1521 { 1522 int x0 = src[0], x1 = src[7]; 1523 int x2 = src[3], x3 = src[4]; 1524 1525 int x4 = x0 + x1; x0 -= x1; 1526 x1 = x2 + x3; x2 -= x3; 1527 1528 work[7] = x0; work[1] = x2; 1529 x2 = x4 + x1; x4 -= x1; 1530 1531 x0 = src[1]; x3 = src[6]; 1532 x1 = x0 + x3; x0 -= x3; 1533 work[5] = x0; 1534 1535 x0 = src[2]; x3 = src[5]; 1536 work[3] = x0 - x3; x0 += x3; 1537 1538 x3 = x0 + x1; x0 -= x1; 1539 x1 = x2 + x3; x2 -= x3; 1540 1541 work[0] = x1; work[4] = x2; 1542 1543 x0 = descale((x0 - x4)*C0_707, fixb); 1544 x1 = x4 + x0; x4 -= x0; 1545 work[2] = x4; work[6] = x1; 1546 1547 x0 = work[1]; x1 = work[3]; 1548 x2 = work[5]; x3 = work[7]; 1549 1550 x0 += x1; x1 += x2; x2 += x3; 1551 x1 = descale(x1*C0_707, fixb); 1552 1553 x4 = x1 + x3; x3 -= x1; 1554 x1 = (x0 - x2)*C0_382; 1555 x0 = descale(x0*C0_541 + x1, fixb); 1556 x2 = descale(x2*C1_306 + x1, fixb); 1557 1558 x1 = x0 + x3; x3 -= x0; 1559 x0 = x4 + x2; x4 -= x2; 1560 1561 work[5] = x1; work[1] = x0; 1562 work[7] = x4; work[3] = x3; 1563 } 1564 1565 work = workspace; 1566 // pass 2: process columns 1567 for( i = 8; i > 0; i--, work++, postscale += 8, dst += 8 ) 1568 { 1569 int x0 = work[8*0], x1 = work[8*7]; 1570 int x2 = work[8*3], x3 = work[8*4]; 1571 1572 int x4 = x0 + x1; x0 -= x1; 1573 x1 = x2 + x3; x2 -= x3; 1574 1575 work[8*7] = x0; work[8*0] = x2; 1576 x2 = x4 + x1; x4 -= x1; 1577 1578 x0 = work[8*1]; x3 = work[8*6]; 1579 x1 = x0 + x3; x0 -= x3; 1580 work[8*4] = x0; 1581 1582 x0 = work[8*2]; x3 = work[8*5]; 1583 work[8*3] = x0 - x3; x0 += x3; 1584 1585 x3 = x0 + x1; x0 -= x1; 1586 x1 = x2 + x3; x2 -= x3; 1587 1588 dst[0] = descale(x1*postscale[0], postshift); 1589 dst[4] = descale(x2*postscale[4], postshift); 1590 1591 x0 = descale((x0 - x4)*C0_707, fixb); 1592 x1 = x4 + x0; x4 -= x0; 1593 1594 dst[2] = descale(x4*postscale[2], postshift); 1595 dst[6] = descale(x1*postscale[6], postshift); 1596 1597 x0 = work[8*0]; x1 = work[8*3]; 1598 x2 = work[8*4]; x3 = work[8*7]; 1599 1600 x0 += x1; x1 += x2; x2 += x3; 1601 x1 = descale(x1*C0_707, fixb); 1602 1603 x4 = x1 + x3; x3 -= x1; 1604 x1 = (x0 - x2)*C0_382; 1605 x0 = descale(x0*C0_541 + x1, fixb); 1606 x2 = descale(x2*C1_306 + x1, fixb); 1607 1608 x1 = x0 + x3; x3 -= x0; 1609 x0 = x4 + x2; x4 -= x2; 1610 1611 dst[5] = descale(x1*postscale[5], postshift); 1612 dst[1] = descale(x0*postscale[1], postshift); 1613 dst[7] = descale(x4*postscale[7], postshift); 1614 dst[3] = descale(x3*postscale[3], postshift); 1615 } 1616 } 1617 1618 1619 bool GrFmtJpegWriter::WriteImage( const uchar* data, int step, 1620 int width, int height, int /*depth*/, int _channels ) 1621 { 1622 assert( data && width > 0 && height > 0 ); 1623 1624 if( !m_strm.Open( m_filename ) ) return false; 1625 1626 // encode the header and tables 1627 // for each mcu: 1628 // convert rgb to yuv with downsampling (if color). 1629 // for every block: 1630 // calc dct and quantize 1631 // encode block. 1632 int x, y; 1633 int i, j; 1634 const int max_quality = 12; 1635 int quality = max_quality; 1636 WMByteStream& lowstrm = m_strm.m_low_strm; 1637 int fdct_qtab[2][64]; 1638 ulong huff_dc_tab[2][16]; 1639 ulong huff_ac_tab[2][256]; 1640 int channels = _channels > 1 ? 3 : 1; 1641 int x_scale = channels > 1 ? 2 : 1, y_scale = x_scale; 1642 int dc_pred[] = { 0, 0, 0 }; 1643 int x_step = x_scale * 8; 1644 int y_step = y_scale * 8; 1645 int block[6][64]; 1646 int buffer[1024]; 1647 int luma_count = x_scale*y_scale; 1648 int block_count = luma_count + channels - 1; 1649 int Y_step = x_scale*8; 1650 const int UV_step = 16; 1651 double inv_quality; 1652 1653 if( quality < 3 ) quality = 3; 1654 if( quality > max_quality ) quality = max_quality; 1655 1656 inv_quality = 1./quality; 1657 1658 // Encode header 1659 lowstrm.PutBytes( jpegHeader, sizeof(jpegHeader) - 1 ); 1660 1661 // Encode quantization tables 1662 for( i = 0; i < (channels > 1 ? 2 : 1); i++ ) 1663 { 1664 const uchar* qtable = i == 0 ? jpegTableK1_T : jpegTableK2_T; 1665 int chroma_scale = i > 0 ? luma_count : 1; 1666 1667 lowstrm.PutWord( 0xffdb ); // DQT marker 1668 lowstrm.PutWord( 2 + 65*1 ); // put single qtable 1669 lowstrm.PutByte( 0*16 + i ); // 8-bit table 1670 1671 // put coefficients 1672 for( j = 0; j < 64; j++ ) 1673 { 1674 int idx = zigzag[j]; 1675 int qval = cvRound(qtable[idx]*inv_quality); 1676 if( qval < 1 ) 1677 qval = 1; 1678 if( qval > 255 ) 1679 qval = 255; 1680 fdct_qtab[i][idx] = cvRound((1 << (postshift + 9))/ 1681 (qval*chroma_scale*idct_prescale[idx])); 1682 lowstrm.PutByte( qval ); 1683 } 1684 } 1685 1686 // Encode huffman tables 1687 for( i = 0; i < (channels > 1 ? 4 : 2); i++ ) 1688 { 1689 const uchar* htable = i == 0 ? jpegTableK3 : i == 1 ? jpegTableK5 : 1690 i == 2 ? jpegTableK4 : jpegTableK6; 1691 int is_ac_tab = i & 1; 1692 int idx = i >= 2; 1693 int tableSize = 16 + (is_ac_tab ? 162 : 12); 1694 1695 lowstrm.PutWord( 0xFFC4 ); // DHT marker 1696 lowstrm.PutWord( 3 + tableSize ); // define one huffman table 1697 lowstrm.PutByte( is_ac_tab*16 + idx ); // put DC/AC flag and table index 1698 lowstrm.PutBytes( htable, tableSize ); // put table 1699 1700 bsCreateEncodeHuffmanTable( bsCreateSourceHuffmanTable( 1701 htable, buffer, 16, 9 ), is_ac_tab ? huff_ac_tab[idx] : 1702 huff_dc_tab[idx], is_ac_tab ? 256 : 16 ); 1703 } 1704 1705 // put frame header 1706 lowstrm.PutWord( 0xFFC0 ); // SOF0 marker 1707 lowstrm.PutWord( 8 + 3*channels ); // length of frame header 1708 lowstrm.PutByte( 8 ); // sample precision 1709 lowstrm.PutWord( height ); 1710 lowstrm.PutWord( width ); 1711 lowstrm.PutByte( channels ); // number of components 1712 1713 for( i = 0; i < channels; i++ ) 1714 { 1715 lowstrm.PutByte( i + 1 ); // (i+1)-th component id (Y,U or V) 1716 if( i == 0 ) 1717 lowstrm.PutByte(x_scale*16 + y_scale); // chroma scale factors 1718 else 1719 lowstrm.PutByte(1*16 + 1); 1720 lowstrm.PutByte( i > 0 ); // quantization table idx 1721 } 1722 1723 // put scan header 1724 lowstrm.PutWord( 0xFFDA ); // SOS marker 1725 lowstrm.PutWord( 6 + 2*channels ); // length of scan header 1726 lowstrm.PutByte( channels ); // number of components in the scan 1727 1728 for( i = 0; i < channels; i++ ) 1729 { 1730 lowstrm.PutByte( i+1 ); // component id 1731 lowstrm.PutByte( (i>0)*16 + (i>0) );// selection of DC & AC tables 1732 } 1733 1734 lowstrm.PutWord(0*256 + 63);// start and end of spectral selection - for 1735 // sequental DCT start is 0 and end is 63 1736 1737 lowstrm.PutByte( 0 ); // successive approximation bit position 1738 // high & low - (0,0) for sequental DCT 1739 1740 // encode data 1741 for( y = 0; y < height; y += y_step, data += y_step*step ) 1742 { 1743 for( x = 0; x < width; x += x_step ) 1744 { 1745 int x_limit = x_step; 1746 int y_limit = y_step; 1747 const uchar* rgb_data = data + x*_channels; 1748 int* Y_data = block[0]; 1749 1750 if( x + x_limit > width ) x_limit = width - x; 1751 if( y + y_limit > height ) y_limit = height - y; 1752 1753 memset( block, 0, block_count*64*sizeof(block[0][0])); 1754 1755 if( channels > 1 ) 1756 { 1757 int* UV_data = block[luma_count]; 1758 1759 for( i = 0; i < y_limit; i++, rgb_data += step, Y_data += Y_step ) 1760 { 1761 for( j = 0; j < x_limit; j++, rgb_data += _channels ) 1762 { 1763 int r = rgb_data[2]; 1764 int g = rgb_data[1]; 1765 int b = rgb_data[0]; 1766 1767 int Y = descale( r*y_r + g*y_g + b*y_b, fixc - 2) - 128*4; 1768 int U = descale( r*cb_r + g*cb_g + b*cb_b, fixc - 2 ); 1769 int V = descale( r*cr_r + g*cr_g + b*cr_b, fixc - 2 ); 1770 int j2 = j >> (x_scale - 1); 1771 1772 Y_data[j] = Y; 1773 UV_data[j2] += U; 1774 UV_data[j2 + 8] += V; 1775 } 1776 1777 rgb_data -= x_limit*_channels; 1778 if( ((i+1) & (y_scale - 1)) == 0 ) 1779 { 1780 UV_data += UV_step; 1781 } 1782 } 1783 } 1784 else 1785 { 1786 for( i = 0; i < y_limit; i++, rgb_data += step, Y_data += Y_step ) 1787 { 1788 for( j = 0; j < x_limit; j++ ) 1789 Y_data[j] = rgb_data[j]*4 - 128*4; 1790 } 1791 } 1792 1793 for( i = 0; i < block_count; i++ ) 1794 { 1795 int is_chroma = i >= luma_count; 1796 int src_step = x_scale * 8; 1797 int run = 0, val; 1798 int* src_ptr = block[i & -2] + (i & 1)*8; 1799 const ulong* htable = huff_ac_tab[is_chroma]; 1800 1801 aan_fdct8x8( src_ptr, buffer, src_step, fdct_qtab[is_chroma] ); 1802 1803 j = is_chroma + (i > luma_count); 1804 val = buffer[0] - dc_pred[j]; 1805 dc_pred[j] = buffer[0]; 1806 1807 { 1808 float a = (float)val; 1809 int cat = (((int&)a >> 23) & 255) - (126 & (val ? -1 : 0)); 1810 1811 assert( cat <= 11 ); 1812 m_strm.PutHuff( cat, huff_dc_tab[is_chroma] ); 1813 m_strm.Put( val - (val < 0 ? 1 : 0), cat ); 1814 } 1815 1816 for( j = 1; j < 64; j++ ) 1817 { 1818 val = buffer[zigzag[j]]; 1819 1820 if( val == 0 ) 1821 { 1822 run++; 1823 } 1824 else 1825 { 1826 while( run >= 16 ) 1827 { 1828 m_strm.PutHuff( 0xF0, htable ); // encode 16 zeros 1829 run -= 16; 1830 } 1831 1832 { 1833 float a = (float)val; 1834 int cat = (((int&)a >> 23) & 255) - (126 & (val ? -1 : 0)); 1835 1836 assert( cat <= 10 ); 1837 m_strm.PutHuff( cat + run*16, htable ); 1838 m_strm.Put( val - (val < 0 ? 1 : 0), cat ); 1839 } 1840 1841 run = 0; 1842 } 1843 } 1844 1845 if( run ) 1846 { 1847 m_strm.PutHuff( 0x00, htable ); // encode EOB 1848 } 1849 } 1850 } 1851 } 1852 1853 // Flush 1854 m_strm.Flush(); 1855 1856 lowstrm.PutWord( 0xFFD9 ); // EOI marker 1857 m_strm.Close(); 1858 1859 return true; 1860 } 1861 1862 #endif 1863 1864 /* End of file. */ 1865 1866 1867
