1 /* 2 * jdmarker.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1991-1998, Thomas G. Lane. 6 * libjpeg-turbo Modifications: 7 * Copyright (C) 2012, D. R. Commander. 8 * For conditions of distribution and use, see the accompanying README file. 9 * 10 * This file contains routines to decode JPEG datastream markers. 11 * Most of the complexity arises from our desire to support input 12 * suspension: if not all of the data for a marker is available, 13 * we must exit back to the application. On resumption, we reprocess 14 * the marker. 15 */ 16 17 #define JPEG_INTERNALS 18 #include "jinclude.h" 19 #include "jpeglib.h" 20 21 22 typedef enum { /* JPEG marker codes */ 23 M_SOF0 = 0xc0, 24 M_SOF1 = 0xc1, 25 M_SOF2 = 0xc2, 26 M_SOF3 = 0xc3, 27 28 M_SOF5 = 0xc5, 29 M_SOF6 = 0xc6, 30 M_SOF7 = 0xc7, 31 32 M_JPG = 0xc8, 33 M_SOF9 = 0xc9, 34 M_SOF10 = 0xca, 35 M_SOF11 = 0xcb, 36 37 M_SOF13 = 0xcd, 38 M_SOF14 = 0xce, 39 M_SOF15 = 0xcf, 40 41 M_DHT = 0xc4, 42 43 M_DAC = 0xcc, 44 45 M_RST0 = 0xd0, 46 M_RST1 = 0xd1, 47 M_RST2 = 0xd2, 48 M_RST3 = 0xd3, 49 M_RST4 = 0xd4, 50 M_RST5 = 0xd5, 51 M_RST6 = 0xd6, 52 M_RST7 = 0xd7, 53 54 M_SOI = 0xd8, 55 M_EOI = 0xd9, 56 M_SOS = 0xda, 57 M_DQT = 0xdb, 58 M_DNL = 0xdc, 59 M_DRI = 0xdd, 60 M_DHP = 0xde, 61 M_EXP = 0xdf, 62 63 M_APP0 = 0xe0, 64 M_APP1 = 0xe1, 65 M_APP2 = 0xe2, 66 M_APP3 = 0xe3, 67 M_APP4 = 0xe4, 68 M_APP5 = 0xe5, 69 M_APP6 = 0xe6, 70 M_APP7 = 0xe7, 71 M_APP8 = 0xe8, 72 M_APP9 = 0xe9, 73 M_APP10 = 0xea, 74 M_APP11 = 0xeb, 75 M_APP12 = 0xec, 76 M_APP13 = 0xed, 77 M_APP14 = 0xee, 78 M_APP15 = 0xef, 79 80 M_JPG0 = 0xf0, 81 M_JPG13 = 0xfd, 82 M_COM = 0xfe, 83 84 M_TEM = 0x01, 85 86 M_ERROR = 0x100 87 } JPEG_MARKER; 88 89 90 /* Private state */ 91 92 typedef struct { 93 struct jpeg_marker_reader pub; /* public fields */ 94 95 /* Application-overridable marker processing methods */ 96 jpeg_marker_parser_method process_COM; 97 jpeg_marker_parser_method process_APPn[16]; 98 99 /* Limit on marker data length to save for each marker type */ 100 unsigned int length_limit_COM; 101 unsigned int length_limit_APPn[16]; 102 103 /* Status of COM/APPn marker saving */ 104 jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */ 105 unsigned int bytes_read; /* data bytes read so far in marker */ 106 /* Note: cur_marker is not linked into marker_list until it's all read. */ 107 } my_marker_reader; 108 109 typedef my_marker_reader * my_marker_ptr; 110 111 112 /* 113 * Macros for fetching data from the data source module. 114 * 115 * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect 116 * the current restart point; we update them only when we have reached a 117 * suitable place to restart if a suspension occurs. 118 */ 119 120 /* Declare and initialize local copies of input pointer/count */ 121 #define INPUT_VARS(cinfo) \ 122 struct jpeg_source_mgr * datasrc = (cinfo)->src; \ 123 const JOCTET * next_input_byte = datasrc->next_input_byte; \ 124 size_t bytes_in_buffer = datasrc->bytes_in_buffer 125 126 /* Unload the local copies --- do this only at a restart boundary */ 127 #define INPUT_SYNC(cinfo) \ 128 ( datasrc->next_input_byte = next_input_byte, \ 129 datasrc->bytes_in_buffer = bytes_in_buffer ) 130 131 /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */ 132 #define INPUT_RELOAD(cinfo) \ 133 ( next_input_byte = datasrc->next_input_byte, \ 134 bytes_in_buffer = datasrc->bytes_in_buffer ) 135 136 /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available. 137 * Note we do *not* do INPUT_SYNC before calling fill_input_buffer, 138 * but we must reload the local copies after a successful fill. 139 */ 140 #define MAKE_BYTE_AVAIL(cinfo,action) \ 141 if (bytes_in_buffer == 0) { \ 142 if (! (*datasrc->fill_input_buffer) (cinfo)) \ 143 { action; } \ 144 INPUT_RELOAD(cinfo); \ 145 } 146 147 /* Read a byte into variable V. 148 * If must suspend, take the specified action (typically "return FALSE"). 149 */ 150 #define INPUT_BYTE(cinfo,V,action) \ 151 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ 152 bytes_in_buffer--; \ 153 V = GETJOCTET(*next_input_byte++); ) 154 155 /* As above, but read two bytes interpreted as an unsigned 16-bit integer. 156 * V should be declared unsigned int or perhaps INT32. 157 */ 158 #define INPUT_2BYTES(cinfo,V,action) \ 159 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ 160 bytes_in_buffer--; \ 161 V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \ 162 MAKE_BYTE_AVAIL(cinfo,action); \ 163 bytes_in_buffer--; \ 164 V += GETJOCTET(*next_input_byte++); ) 165 166 167 /* 168 * Routines to process JPEG markers. 169 * 170 * Entry condition: JPEG marker itself has been read and its code saved 171 * in cinfo->unread_marker; input restart point is just after the marker. 172 * 173 * Exit: if return TRUE, have read and processed any parameters, and have 174 * updated the restart point to point after the parameters. 175 * If return FALSE, was forced to suspend before reaching end of 176 * marker parameters; restart point has not been moved. Same routine 177 * will be called again after application supplies more input data. 178 * 179 * This approach to suspension assumes that all of a marker's parameters 180 * can fit into a single input bufferload. This should hold for "normal" 181 * markers. Some COM/APPn markers might have large parameter segments 182 * that might not fit. If we are simply dropping such a marker, we use 183 * skip_input_data to get past it, and thereby put the problem on the 184 * source manager's shoulders. If we are saving the marker's contents 185 * into memory, we use a slightly different convention: when forced to 186 * suspend, the marker processor updates the restart point to the end of 187 * what it's consumed (ie, the end of the buffer) before returning FALSE. 188 * On resumption, cinfo->unread_marker still contains the marker code, 189 * but the data source will point to the next chunk of marker data. 190 * The marker processor must retain internal state to deal with this. 191 * 192 * Note that we don't bother to avoid duplicate trace messages if a 193 * suspension occurs within marker parameters. Other side effects 194 * require more care. 195 */ 196 197 198 LOCAL(boolean) 199 get_soi (j_decompress_ptr cinfo) 200 /* Process an SOI marker */ 201 { 202 int i; 203 204 TRACEMS(cinfo, 1, JTRC_SOI); 205 206 if (cinfo->marker->saw_SOI) 207 ERREXIT(cinfo, JERR_SOI_DUPLICATE); 208 209 /* Reset all parameters that are defined to be reset by SOI */ 210 211 for (i = 0; i < NUM_ARITH_TBLS; i++) { 212 cinfo->arith_dc_L[i] = 0; 213 cinfo->arith_dc_U[i] = 1; 214 cinfo->arith_ac_K[i] = 5; 215 } 216 cinfo->restart_interval = 0; 217 218 /* Set initial assumptions for colorspace etc */ 219 220 cinfo->jpeg_color_space = JCS_UNKNOWN; 221 cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */ 222 223 cinfo->saw_JFIF_marker = FALSE; 224 cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */ 225 cinfo->JFIF_minor_version = 1; 226 cinfo->density_unit = 0; 227 cinfo->X_density = 1; 228 cinfo->Y_density = 1; 229 cinfo->saw_Adobe_marker = FALSE; 230 cinfo->Adobe_transform = 0; 231 232 cinfo->marker->saw_SOI = TRUE; 233 234 return TRUE; 235 } 236 237 238 LOCAL(boolean) 239 get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith) 240 /* Process a SOFn marker */ 241 { 242 INT32 length; 243 int c, ci; 244 jpeg_component_info * compptr; 245 INPUT_VARS(cinfo); 246 247 cinfo->progressive_mode = is_prog; 248 cinfo->arith_code = is_arith; 249 250 INPUT_2BYTES(cinfo, length, return FALSE); 251 252 INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE); 253 INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE); 254 INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE); 255 INPUT_BYTE(cinfo, cinfo->num_components, return FALSE); 256 257 length -= 8; 258 259 TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker, 260 (int) cinfo->image_width, (int) cinfo->image_height, 261 cinfo->num_components); 262 263 if (cinfo->marker->saw_SOF) 264 ERREXIT(cinfo, JERR_SOF_DUPLICATE); 265 266 /* We don't support files in which the image height is initially specified */ 267 /* as 0 and is later redefined by DNL. As long as we have to check that, */ 268 /* might as well have a general sanity check. */ 269 if (cinfo->image_height <= 0 || cinfo->image_width <= 0 270 || cinfo->num_components <= 0) 271 ERREXIT(cinfo, JERR_EMPTY_IMAGE); 272 273 if (length != (cinfo->num_components * 3)) 274 ERREXIT(cinfo, JERR_BAD_LENGTH); 275 276 if (cinfo->comp_info == NULL) /* do only once, even if suspend */ 277 cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small) 278 ((j_common_ptr) cinfo, JPOOL_IMAGE, 279 cinfo->num_components * SIZEOF(jpeg_component_info)); 280 281 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 282 ci++, compptr++) { 283 compptr->component_index = ci; 284 INPUT_BYTE(cinfo, compptr->component_id, return FALSE); 285 INPUT_BYTE(cinfo, c, return FALSE); 286 compptr->h_samp_factor = (c >> 4) & 15; 287 compptr->v_samp_factor = (c ) & 15; 288 INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE); 289 290 TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT, 291 compptr->component_id, compptr->h_samp_factor, 292 compptr->v_samp_factor, compptr->quant_tbl_no); 293 } 294 295 cinfo->marker->saw_SOF = TRUE; 296 297 INPUT_SYNC(cinfo); 298 return TRUE; 299 } 300 301 302 LOCAL(boolean) 303 get_sos (j_decompress_ptr cinfo) 304 /* Process a SOS marker */ 305 { 306 INT32 length; 307 int i, ci, n, c, cc, pi; 308 jpeg_component_info * compptr; 309 INPUT_VARS(cinfo); 310 311 if (! cinfo->marker->saw_SOF) 312 ERREXIT(cinfo, JERR_SOS_NO_SOF); 313 314 INPUT_2BYTES(cinfo, length, return FALSE); 315 316 INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */ 317 318 TRACEMS1(cinfo, 1, JTRC_SOS, n); 319 320 if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN) 321 ERREXIT(cinfo, JERR_BAD_LENGTH); 322 323 cinfo->comps_in_scan = n; 324 325 /* Collect the component-spec parameters */ 326 327 for (i = 0; i < MAX_COMPS_IN_SCAN; i++) 328 cinfo->cur_comp_info[i] = NULL; 329 330 for (i = 0; i < n; i++) { 331 INPUT_BYTE(cinfo, cc, return FALSE); 332 INPUT_BYTE(cinfo, c, return FALSE); 333 334 for (ci = 0, compptr = cinfo->comp_info; 335 ci < cinfo->num_components && ci < MAX_COMPS_IN_SCAN; 336 ci++, compptr++) { 337 if (cc == compptr->component_id && !cinfo->cur_comp_info[ci]) 338 goto id_found; 339 } 340 341 ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc); 342 343 id_found: 344 345 cinfo->cur_comp_info[i] = compptr; 346 compptr->dc_tbl_no = (c >> 4) & 15; 347 compptr->ac_tbl_no = (c ) & 15; 348 349 TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc, 350 compptr->dc_tbl_no, compptr->ac_tbl_no); 351 352 /* This CSi (cc) should differ from the previous CSi */ 353 for (pi = 0; pi < i; pi++) { 354 if (cinfo->cur_comp_info[pi] == compptr) { 355 ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc); 356 } 357 } 358 } 359 360 /* Collect the additional scan parameters Ss, Se, Ah/Al. */ 361 INPUT_BYTE(cinfo, c, return FALSE); 362 cinfo->Ss = c; 363 INPUT_BYTE(cinfo, c, return FALSE); 364 cinfo->Se = c; 365 INPUT_BYTE(cinfo, c, return FALSE); 366 cinfo->Ah = (c >> 4) & 15; 367 cinfo->Al = (c ) & 15; 368 369 TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se, 370 cinfo->Ah, cinfo->Al); 371 372 /* Prepare to scan data & restart markers */ 373 cinfo->marker->next_restart_num = 0; 374 375 /* Count another SOS marker */ 376 cinfo->input_scan_number++; 377 378 INPUT_SYNC(cinfo); 379 return TRUE; 380 } 381 382 383 #ifdef D_ARITH_CODING_SUPPORTED 384 385 LOCAL(boolean) 386 get_dac (j_decompress_ptr cinfo) 387 /* Process a DAC marker */ 388 { 389 INT32 length; 390 int index, val; 391 INPUT_VARS(cinfo); 392 393 INPUT_2BYTES(cinfo, length, return FALSE); 394 length -= 2; 395 396 while (length > 0) { 397 INPUT_BYTE(cinfo, index, return FALSE); 398 INPUT_BYTE(cinfo, val, return FALSE); 399 400 length -= 2; 401 402 TRACEMS2(cinfo, 1, JTRC_DAC, index, val); 403 404 if (index < 0 || index >= (2*NUM_ARITH_TBLS)) 405 ERREXIT1(cinfo, JERR_DAC_INDEX, index); 406 407 if (index >= NUM_ARITH_TBLS) { /* define AC table */ 408 cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val; 409 } else { /* define DC table */ 410 cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F); 411 cinfo->arith_dc_U[index] = (UINT8) (val >> 4); 412 if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index]) 413 ERREXIT1(cinfo, JERR_DAC_VALUE, val); 414 } 415 } 416 417 if (length != 0) 418 ERREXIT(cinfo, JERR_BAD_LENGTH); 419 420 INPUT_SYNC(cinfo); 421 return TRUE; 422 } 423 424 #else /* ! D_ARITH_CODING_SUPPORTED */ 425 426 #define get_dac(cinfo) skip_variable(cinfo) 427 428 #endif /* D_ARITH_CODING_SUPPORTED */ 429 430 431 LOCAL(boolean) 432 get_dht (j_decompress_ptr cinfo) 433 /* Process a DHT marker */ 434 { 435 INT32 length; 436 UINT8 bits[17]; 437 UINT8 huffval[256]; 438 int i, index, count; 439 JHUFF_TBL **htblptr; 440 INPUT_VARS(cinfo); 441 442 INPUT_2BYTES(cinfo, length, return FALSE); 443 length -= 2; 444 445 while (length > 16) { 446 INPUT_BYTE(cinfo, index, return FALSE); 447 448 TRACEMS1(cinfo, 1, JTRC_DHT, index); 449 450 bits[0] = 0; 451 count = 0; 452 for (i = 1; i <= 16; i++) { 453 INPUT_BYTE(cinfo, bits[i], return FALSE); 454 count += bits[i]; 455 } 456 457 length -= 1 + 16; 458 459 TRACEMS8(cinfo, 2, JTRC_HUFFBITS, 460 bits[1], bits[2], bits[3], bits[4], 461 bits[5], bits[6], bits[7], bits[8]); 462 TRACEMS8(cinfo, 2, JTRC_HUFFBITS, 463 bits[9], bits[10], bits[11], bits[12], 464 bits[13], bits[14], bits[15], bits[16]); 465 466 /* Here we just do minimal validation of the counts to avoid walking 467 * off the end of our table space. jdhuff.c will check more carefully. 468 */ 469 if (count > 256 || ((INT32) count) > length) 470 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); 471 472 for (i = 0; i < count; i++) 473 INPUT_BYTE(cinfo, huffval[i], return FALSE); 474 475 MEMZERO(&huffval[count], (256 - count) * SIZEOF(UINT8)); 476 477 length -= count; 478 479 if (index & 0x10) { /* AC table definition */ 480 index -= 0x10; 481 if (index < 0 || index >= NUM_HUFF_TBLS) 482 ERREXIT1(cinfo, JERR_DHT_INDEX, index); 483 htblptr = &cinfo->ac_huff_tbl_ptrs[index]; 484 } else { /* DC table definition */ 485 if (index < 0 || index >= NUM_HUFF_TBLS) 486 ERREXIT1(cinfo, JERR_DHT_INDEX, index); 487 htblptr = &cinfo->dc_huff_tbl_ptrs[index]; 488 } 489 490 if (*htblptr == NULL) 491 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 492 493 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); 494 MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval)); 495 } 496 497 if (length != 0) 498 ERREXIT(cinfo, JERR_BAD_LENGTH); 499 500 INPUT_SYNC(cinfo); 501 return TRUE; 502 } 503 504 505 LOCAL(boolean) 506 get_dqt (j_decompress_ptr cinfo) 507 /* Process a DQT marker */ 508 { 509 INT32 length; 510 int n, i, prec; 511 unsigned int tmp; 512 JQUANT_TBL *quant_ptr; 513 INPUT_VARS(cinfo); 514 515 INPUT_2BYTES(cinfo, length, return FALSE); 516 length -= 2; 517 518 while (length > 0) { 519 INPUT_BYTE(cinfo, n, return FALSE); 520 prec = n >> 4; 521 n &= 0x0F; 522 523 TRACEMS2(cinfo, 1, JTRC_DQT, n, prec); 524 525 if (n >= NUM_QUANT_TBLS) 526 ERREXIT1(cinfo, JERR_DQT_INDEX, n); 527 528 if (cinfo->quant_tbl_ptrs[n] == NULL) 529 cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo); 530 quant_ptr = cinfo->quant_tbl_ptrs[n]; 531 532 for (i = 0; i < DCTSIZE2; i++) { 533 if (prec) 534 INPUT_2BYTES(cinfo, tmp, return FALSE); 535 else 536 INPUT_BYTE(cinfo, tmp, return FALSE); 537 /* We convert the zigzag-order table to natural array order. */ 538 quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp; 539 } 540 541 if (cinfo->err->trace_level >= 2) { 542 for (i = 0; i < DCTSIZE2; i += 8) { 543 TRACEMS8(cinfo, 2, JTRC_QUANTVALS, 544 quant_ptr->quantval[i], quant_ptr->quantval[i+1], 545 quant_ptr->quantval[i+2], quant_ptr->quantval[i+3], 546 quant_ptr->quantval[i+4], quant_ptr->quantval[i+5], 547 quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]); 548 } 549 } 550 551 length -= DCTSIZE2+1; 552 if (prec) length -= DCTSIZE2; 553 } 554 555 if (length != 0) 556 ERREXIT(cinfo, JERR_BAD_LENGTH); 557 558 INPUT_SYNC(cinfo); 559 return TRUE; 560 } 561 562 563 LOCAL(boolean) 564 get_dri (j_decompress_ptr cinfo) 565 /* Process a DRI marker */ 566 { 567 INT32 length; 568 unsigned int tmp; 569 INPUT_VARS(cinfo); 570 571 INPUT_2BYTES(cinfo, length, return FALSE); 572 573 if (length != 4) 574 ERREXIT(cinfo, JERR_BAD_LENGTH); 575 576 INPUT_2BYTES(cinfo, tmp, return FALSE); 577 578 TRACEMS1(cinfo, 1, JTRC_DRI, tmp); 579 580 cinfo->restart_interval = tmp; 581 582 INPUT_SYNC(cinfo); 583 return TRUE; 584 } 585 586 587 /* 588 * Routines for processing APPn and COM markers. 589 * These are either saved in memory or discarded, per application request. 590 * APP0 and APP14 are specially checked to see if they are 591 * JFIF and Adobe markers, respectively. 592 */ 593 594 #define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */ 595 #define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */ 596 #define APPN_DATA_LEN 14 /* Must be the largest of the above!! */ 597 598 599 LOCAL(void) 600 examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data, 601 unsigned int datalen, INT32 remaining) 602 /* Examine first few bytes from an APP0. 603 * Take appropriate action if it is a JFIF marker. 604 * datalen is # of bytes at data[], remaining is length of rest of marker data. 605 */ 606 { 607 INT32 totallen = (INT32) datalen + remaining; 608 609 if (datalen >= APP0_DATA_LEN && 610 GETJOCTET(data[0]) == 0x4A && 611 GETJOCTET(data[1]) == 0x46 && 612 GETJOCTET(data[2]) == 0x49 && 613 GETJOCTET(data[3]) == 0x46 && 614 GETJOCTET(data[4]) == 0) { 615 /* Found JFIF APP0 marker: save info */ 616 cinfo->saw_JFIF_marker = TRUE; 617 cinfo->JFIF_major_version = GETJOCTET(data[5]); 618 cinfo->JFIF_minor_version = GETJOCTET(data[6]); 619 cinfo->density_unit = GETJOCTET(data[7]); 620 cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]); 621 cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]); 622 /* Check version. 623 * Major version must be 1, anything else signals an incompatible change. 624 * (We used to treat this as an error, but now it's a nonfatal warning, 625 * because some bozo at Hijaak couldn't read the spec.) 626 * Minor version should be 0..2, but process anyway if newer. 627 */ 628 if (cinfo->JFIF_major_version != 1) 629 WARNMS2(cinfo, JWRN_JFIF_MAJOR, 630 cinfo->JFIF_major_version, cinfo->JFIF_minor_version); 631 /* Generate trace messages */ 632 TRACEMS5(cinfo, 1, JTRC_JFIF, 633 cinfo->JFIF_major_version, cinfo->JFIF_minor_version, 634 cinfo->X_density, cinfo->Y_density, cinfo->density_unit); 635 /* Validate thumbnail dimensions and issue appropriate messages */ 636 if (GETJOCTET(data[12]) | GETJOCTET(data[13])) 637 TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, 638 GETJOCTET(data[12]), GETJOCTET(data[13])); 639 totallen -= APP0_DATA_LEN; 640 if (totallen != 641 ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3)) 642 TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen); 643 } else if (datalen >= 6 && 644 GETJOCTET(data[0]) == 0x4A && 645 GETJOCTET(data[1]) == 0x46 && 646 GETJOCTET(data[2]) == 0x58 && 647 GETJOCTET(data[3]) == 0x58 && 648 GETJOCTET(data[4]) == 0) { 649 /* Found JFIF "JFXX" extension APP0 marker */ 650 /* The library doesn't actually do anything with these, 651 * but we try to produce a helpful trace message. 652 */ 653 switch (GETJOCTET(data[5])) { 654 case 0x10: 655 TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen); 656 break; 657 case 0x11: 658 TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen); 659 break; 660 case 0x13: 661 TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen); 662 break; 663 default: 664 TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, 665 GETJOCTET(data[5]), (int) totallen); 666 break; 667 } 668 } else { 669 /* Start of APP0 does not match "JFIF" or "JFXX", or too short */ 670 TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen); 671 } 672 } 673 674 675 LOCAL(void) 676 examine_app14 (j_decompress_ptr cinfo, JOCTET FAR * data, 677 unsigned int datalen, INT32 remaining) 678 /* Examine first few bytes from an APP14. 679 * Take appropriate action if it is an Adobe marker. 680 * datalen is # of bytes at data[], remaining is length of rest of marker data. 681 */ 682 { 683 unsigned int version, flags0, flags1, transform; 684 685 if (datalen >= APP14_DATA_LEN && 686 GETJOCTET(data[0]) == 0x41 && 687 GETJOCTET(data[1]) == 0x64 && 688 GETJOCTET(data[2]) == 0x6F && 689 GETJOCTET(data[3]) == 0x62 && 690 GETJOCTET(data[4]) == 0x65) { 691 /* Found Adobe APP14 marker */ 692 version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]); 693 flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]); 694 flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]); 695 transform = GETJOCTET(data[11]); 696 TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform); 697 cinfo->saw_Adobe_marker = TRUE; 698 cinfo->Adobe_transform = (UINT8) transform; 699 } else { 700 /* Start of APP14 does not match "Adobe", or too short */ 701 TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining)); 702 } 703 } 704 705 706 METHODDEF(boolean) 707 get_interesting_appn (j_decompress_ptr cinfo) 708 /* Process an APP0 or APP14 marker without saving it */ 709 { 710 INT32 length; 711 JOCTET b[APPN_DATA_LEN]; 712 unsigned int i, numtoread; 713 INPUT_VARS(cinfo); 714 715 INPUT_2BYTES(cinfo, length, return FALSE); 716 length -= 2; 717 718 /* get the interesting part of the marker data */ 719 if (length >= APPN_DATA_LEN) 720 numtoread = APPN_DATA_LEN; 721 else if (length > 0) 722 numtoread = (unsigned int) length; 723 else 724 numtoread = 0; 725 for (i = 0; i < numtoread; i++) 726 INPUT_BYTE(cinfo, b[i], return FALSE); 727 length -= numtoread; 728 729 /* process it */ 730 switch (cinfo->unread_marker) { 731 case M_APP0: 732 examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length); 733 break; 734 case M_APP14: 735 examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length); 736 break; 737 default: 738 /* can't get here unless jpeg_save_markers chooses wrong processor */ 739 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); 740 break; 741 } 742 743 /* skip any remaining data -- could be lots */ 744 INPUT_SYNC(cinfo); 745 if (length > 0) 746 (*cinfo->src->skip_input_data) (cinfo, (long) length); 747 748 return TRUE; 749 } 750 751 752 #ifdef SAVE_MARKERS_SUPPORTED 753 754 METHODDEF(boolean) 755 save_marker (j_decompress_ptr cinfo) 756 /* Save an APPn or COM marker into the marker list */ 757 { 758 my_marker_ptr marker = (my_marker_ptr) cinfo->marker; 759 jpeg_saved_marker_ptr cur_marker = marker->cur_marker; 760 unsigned int bytes_read, data_length; 761 JOCTET FAR * data; 762 INT32 length = 0; 763 INPUT_VARS(cinfo); 764 765 if (cur_marker == NULL) { 766 /* begin reading a marker */ 767 INPUT_2BYTES(cinfo, length, return FALSE); 768 length -= 2; 769 if (length >= 0) { /* watch out for bogus length word */ 770 /* figure out how much we want to save */ 771 unsigned int limit; 772 if (cinfo->unread_marker == (int) M_COM) 773 limit = marker->length_limit_COM; 774 else 775 limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0]; 776 if ((unsigned int) length < limit) 777 limit = (unsigned int) length; 778 /* allocate and initialize the marker item */ 779 cur_marker = (jpeg_saved_marker_ptr) 780 (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, 781 SIZEOF(struct jpeg_marker_struct) + limit); 782 cur_marker->next = NULL; 783 cur_marker->marker = (UINT8) cinfo->unread_marker; 784 cur_marker->original_length = (unsigned int) length; 785 cur_marker->data_length = limit; 786 /* data area is just beyond the jpeg_marker_struct */ 787 data = cur_marker->data = (JOCTET FAR *) (cur_marker + 1); 788 marker->cur_marker = cur_marker; 789 marker->bytes_read = 0; 790 bytes_read = 0; 791 data_length = limit; 792 } else { 793 /* deal with bogus length word */ 794 bytes_read = data_length = 0; 795 data = NULL; 796 } 797 } else { 798 /* resume reading a marker */ 799 bytes_read = marker->bytes_read; 800 data_length = cur_marker->data_length; 801 data = cur_marker->data + bytes_read; 802 } 803 804 while (bytes_read < data_length) { 805 INPUT_SYNC(cinfo); /* move the restart point to here */ 806 marker->bytes_read = bytes_read; 807 /* If there's not at least one byte in buffer, suspend */ 808 MAKE_BYTE_AVAIL(cinfo, return FALSE); 809 /* Copy bytes with reasonable rapidity */ 810 while (bytes_read < data_length && bytes_in_buffer > 0) { 811 *data++ = *next_input_byte++; 812 bytes_in_buffer--; 813 bytes_read++; 814 } 815 } 816 817 /* Done reading what we want to read */ 818 if (cur_marker != NULL) { /* will be NULL if bogus length word */ 819 /* Add new marker to end of list */ 820 if (cinfo->marker_list == NULL) { 821 cinfo->marker_list = cur_marker; 822 } else { 823 jpeg_saved_marker_ptr prev = cinfo->marker_list; 824 while (prev->next != NULL) 825 prev = prev->next; 826 prev->next = cur_marker; 827 } 828 /* Reset pointer & calc remaining data length */ 829 data = cur_marker->data; 830 length = cur_marker->original_length - data_length; 831 } 832 /* Reset to initial state for next marker */ 833 marker->cur_marker = NULL; 834 835 /* Process the marker if interesting; else just make a generic trace msg */ 836 switch (cinfo->unread_marker) { 837 case M_APP0: 838 examine_app0(cinfo, data, data_length, length); 839 break; 840 case M_APP14: 841 examine_app14(cinfo, data, data_length, length); 842 break; 843 default: 844 TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, 845 (int) (data_length + length)); 846 break; 847 } 848 849 /* skip any remaining data -- could be lots */ 850 INPUT_SYNC(cinfo); /* do before skip_input_data */ 851 if (length > 0) 852 (*cinfo->src->skip_input_data) (cinfo, (long) length); 853 854 return TRUE; 855 } 856 857 #endif /* SAVE_MARKERS_SUPPORTED */ 858 859 860 METHODDEF(boolean) 861 skip_variable (j_decompress_ptr cinfo) 862 /* Skip over an unknown or uninteresting variable-length marker */ 863 { 864 INT32 length; 865 INPUT_VARS(cinfo); 866 867 INPUT_2BYTES(cinfo, length, return FALSE); 868 length -= 2; 869 870 TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length); 871 872 INPUT_SYNC(cinfo); /* do before skip_input_data */ 873 if (length > 0) 874 (*cinfo->src->skip_input_data) (cinfo, (long) length); 875 876 return TRUE; 877 } 878 879 880 /* 881 * Find the next JPEG marker, save it in cinfo->unread_marker. 882 * Returns FALSE if had to suspend before reaching a marker; 883 * in that case cinfo->unread_marker is unchanged. 884 * 885 * Note that the result might not be a valid marker code, 886 * but it will never be 0 or FF. 887 */ 888 889 LOCAL(boolean) 890 next_marker (j_decompress_ptr cinfo) 891 { 892 int c; 893 INPUT_VARS(cinfo); 894 895 for (;;) { 896 INPUT_BYTE(cinfo, c, return FALSE); 897 /* Skip any non-FF bytes. 898 * This may look a bit inefficient, but it will not occur in a valid file. 899 * We sync after each discarded byte so that a suspending data source 900 * can discard the byte from its buffer. 901 */ 902 while (c != 0xFF) { 903 cinfo->marker->discarded_bytes++; 904 INPUT_SYNC(cinfo); 905 INPUT_BYTE(cinfo, c, return FALSE); 906 } 907 /* This loop swallows any duplicate FF bytes. Extra FFs are legal as 908 * pad bytes, so don't count them in discarded_bytes. We assume there 909 * will not be so many consecutive FF bytes as to overflow a suspending 910 * data source's input buffer. 911 */ 912 do { 913 INPUT_BYTE(cinfo, c, return FALSE); 914 } while (c == 0xFF); 915 if (c != 0) 916 break; /* found a valid marker, exit loop */ 917 /* Reach here if we found a stuffed-zero data sequence (FF/00). 918 * Discard it and loop back to try again. 919 */ 920 cinfo->marker->discarded_bytes += 2; 921 INPUT_SYNC(cinfo); 922 } 923 924 if (cinfo->marker->discarded_bytes != 0) { 925 TRACEMS2(cinfo, 1, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c); 926 cinfo->marker->discarded_bytes = 0; 927 } 928 929 cinfo->unread_marker = c; 930 931 INPUT_SYNC(cinfo); 932 return TRUE; 933 } 934 935 936 LOCAL(boolean) 937 first_marker (j_decompress_ptr cinfo) 938 /* Like next_marker, but used to obtain the initial SOI marker. */ 939 /* For this marker, we do not allow preceding garbage or fill; otherwise, 940 * we might well scan an entire input file before realizing it ain't JPEG. 941 * If an application wants to process non-JFIF files, it must seek to the 942 * SOI before calling the JPEG library. 943 */ 944 { 945 int c, c2; 946 INPUT_VARS(cinfo); 947 948 INPUT_BYTE(cinfo, c, return FALSE); 949 INPUT_BYTE(cinfo, c2, return FALSE); 950 if (c != 0xFF || c2 != (int) M_SOI) 951 ERREXIT2(cinfo, JERR_NO_SOI, c, c2); 952 953 cinfo->unread_marker = c2; 954 955 INPUT_SYNC(cinfo); 956 return TRUE; 957 } 958 959 #ifdef MOTION_JPEG_SUPPORTED 960 961 /* The default Huffman tables used by motion JPEG frames. When a motion JPEG 962 * frame does not have DHT tables, we should use the huffman tables suggested by 963 * the JPEG standard. Each of these tables represents a member of the JHUFF_TBLS 964 * struct so we can just copy it to the according JHUFF_TBLS member. 965 */ 966 /* DC table 0 */ 967 LOCAL(const unsigned char) mjpg_dc0_bits[] = { 968 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 969 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 970 }; 971 972 LOCAL(const unsigned char) mjpg_dc0_huffval[] = { 973 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 974 0x08, 0x09, 0x0A, 0x0B 975 }; 976 977 /* DC table 1 */ 978 LOCAL(const unsigned char) mjpg_dc1_bits[] = { 979 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 980 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 981 }; 982 983 LOCAL(const unsigned char) mjpg_dc1_huffval[] = { 984 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 985 0x08, 0x09, 0x0A, 0x0B 986 }; 987 988 /* AC table 0 */ 989 LOCAL(const unsigned char) mjpg_ac0_bits[] = { 990 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 991 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D 992 }; 993 994 LOCAL(const unsigned char) mjpg_ac0_huffval[] = { 995 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 996 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 997 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 998 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 999 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 1000 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 1001 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 1002 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 1003 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 1004 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 1005 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 1006 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 1007 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 1008 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 1009 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 1010 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 1011 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 1012 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 1013 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 1014 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 1015 0xF9, 0xFA 1016 }; 1017 1018 /* AC table 1 */ 1019 LOCAL(const unsigned char) mjpg_ac1_bits[] = { 1020 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 1021 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77 1022 }; 1023 1024 LOCAL(const unsigned char) mjpg_ac1_huffval[] = { 1025 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 1026 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 1027 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 1028 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 1029 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 1030 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 1031 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 1032 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 1033 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 1034 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 1035 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 1036 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 1037 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 1038 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 1039 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 1040 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 1041 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 1042 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 1043 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 1044 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 1045 0xF9, 0xFA 1046 }; 1047 1048 /* Loads the default Huffman tables used by motion JPEG frames. This function 1049 * just copies the huffman tables suggested in the JPEG standard when we have 1050 * not load them. 1051 */ 1052 LOCAL(void) 1053 mjpg_load_huff_tables (j_decompress_ptr cinfo) 1054 { 1055 JHUFF_TBL *htblptr; 1056 1057 if (! cinfo->dc_huff_tbl_ptrs[0]) { 1058 htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 1059 MEMZERO(htblptr, SIZEOF(JHUFF_TBL)); 1060 MEMCOPY(&htblptr->bits[1], mjpg_dc0_bits, SIZEOF(mjpg_dc0_bits)); 1061 MEMCOPY(&htblptr->huffval[0], mjpg_dc0_huffval, SIZEOF(mjpg_dc0_huffval)); 1062 cinfo->dc_huff_tbl_ptrs[0] = htblptr; 1063 } 1064 1065 if (! cinfo->dc_huff_tbl_ptrs[1]) { 1066 htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 1067 MEMZERO(htblptr, SIZEOF(JHUFF_TBL)); 1068 MEMCOPY(&htblptr->bits[1], mjpg_dc1_bits, SIZEOF(mjpg_dc1_bits)); 1069 MEMCOPY(&htblptr->huffval[0], mjpg_dc1_huffval, SIZEOF(mjpg_dc1_huffval)); 1070 cinfo->dc_huff_tbl_ptrs[1] = htblptr; 1071 } 1072 1073 if (! cinfo->ac_huff_tbl_ptrs[0]) { 1074 htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 1075 MEMZERO(htblptr, SIZEOF(JHUFF_TBL)); 1076 MEMCOPY(&htblptr->bits[1], mjpg_ac0_bits, SIZEOF(mjpg_ac0_bits)); 1077 MEMCOPY(&htblptr->huffval[0], mjpg_ac0_huffval, SIZEOF(mjpg_ac0_huffval)); 1078 cinfo->ac_huff_tbl_ptrs[0] = htblptr; 1079 } 1080 1081 if (! cinfo->ac_huff_tbl_ptrs[1]) { 1082 htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 1083 MEMZERO(htblptr, SIZEOF(JHUFF_TBL)); 1084 MEMCOPY(&htblptr->bits[1], mjpg_ac1_bits, SIZEOF(mjpg_ac1_bits)); 1085 MEMCOPY(&htblptr->huffval[0], mjpg_ac1_huffval, SIZEOF(mjpg_ac1_huffval)); 1086 cinfo->ac_huff_tbl_ptrs[1] = htblptr; 1087 } 1088 } 1089 1090 #else 1091 1092 #define mjpg_load_huff_tables(cinfo) 1093 1094 #endif /* MOTION_JPEG_SUPPORTED */ 1095 1096 1097 /* 1098 * Read markers until SOS or EOI. 1099 * 1100 * Returns same codes as are defined for jpeg_consume_input: 1101 * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. 1102 */ 1103 1104 METHODDEF(int) 1105 read_markers (j_decompress_ptr cinfo) 1106 { 1107 /* Outer loop repeats once for each marker. */ 1108 for (;;) { 1109 /* Collect the marker proper, unless we already did. */ 1110 /* NB: first_marker() enforces the requirement that SOI appear first. */ 1111 if (cinfo->unread_marker == 0) { 1112 if (! cinfo->marker->saw_SOI) { 1113 if (! first_marker(cinfo)) 1114 return JPEG_SUSPENDED; 1115 } else { 1116 if (! next_marker(cinfo)) 1117 return JPEG_SUSPENDED; 1118 } 1119 } 1120 /* At this point cinfo->unread_marker contains the marker code and the 1121 * input point is just past the marker proper, but before any parameters. 1122 * A suspension will cause us to return with this state still true. 1123 */ 1124 switch (cinfo->unread_marker) { 1125 case M_SOI: 1126 if (! get_soi(cinfo)) 1127 return JPEG_SUSPENDED; 1128 break; 1129 1130 case M_SOF0: /* Baseline */ 1131 case M_SOF1: /* Extended sequential, Huffman */ 1132 if (! get_sof(cinfo, FALSE, FALSE)) 1133 return JPEG_SUSPENDED; 1134 break; 1135 1136 case M_SOF2: /* Progressive, Huffman */ 1137 if (! get_sof(cinfo, TRUE, FALSE)) 1138 return JPEG_SUSPENDED; 1139 break; 1140 1141 case M_SOF9: /* Extended sequential, arithmetic */ 1142 if (! get_sof(cinfo, FALSE, TRUE)) 1143 return JPEG_SUSPENDED; 1144 break; 1145 1146 case M_SOF10: /* Progressive, arithmetic */ 1147 if (! get_sof(cinfo, TRUE, TRUE)) 1148 return JPEG_SUSPENDED; 1149 break; 1150 1151 /* Currently unsupported SOFn types */ 1152 case M_SOF3: /* Lossless, Huffman */ 1153 case M_SOF5: /* Differential sequential, Huffman */ 1154 case M_SOF6: /* Differential progressive, Huffman */ 1155 case M_SOF7: /* Differential lossless, Huffman */ 1156 case M_JPG: /* Reserved for JPEG extensions */ 1157 case M_SOF11: /* Lossless, arithmetic */ 1158 case M_SOF13: /* Differential sequential, arithmetic */ 1159 case M_SOF14: /* Differential progressive, arithmetic */ 1160 case M_SOF15: /* Differential lossless, arithmetic */ 1161 ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker); 1162 break; 1163 1164 case M_SOS: 1165 mjpg_load_huff_tables(cinfo); 1166 if (! get_sos(cinfo)) 1167 return JPEG_SUSPENDED; 1168 cinfo->unread_marker = 0; /* processed the marker */ 1169 return JPEG_REACHED_SOS; 1170 1171 case M_EOI: 1172 TRACEMS(cinfo, 1, JTRC_EOI); 1173 cinfo->unread_marker = 0; /* processed the marker */ 1174 return JPEG_REACHED_EOI; 1175 1176 case M_DAC: 1177 if (! get_dac(cinfo)) 1178 return JPEG_SUSPENDED; 1179 break; 1180 1181 case M_DHT: 1182 if (! get_dht(cinfo)) 1183 return JPEG_SUSPENDED; 1184 break; 1185 1186 case M_DQT: 1187 if (! get_dqt(cinfo)) 1188 return JPEG_SUSPENDED; 1189 break; 1190 1191 case M_DRI: 1192 if (! get_dri(cinfo)) 1193 return JPEG_SUSPENDED; 1194 break; 1195 1196 case M_APP0: 1197 case M_APP1: 1198 case M_APP2: 1199 case M_APP3: 1200 case M_APP4: 1201 case M_APP5: 1202 case M_APP6: 1203 case M_APP7: 1204 case M_APP8: 1205 case M_APP9: 1206 case M_APP10: 1207 case M_APP11: 1208 case M_APP12: 1209 case M_APP13: 1210 case M_APP14: 1211 case M_APP15: 1212 if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[ 1213 cinfo->unread_marker - (int) M_APP0]) (cinfo)) 1214 return JPEG_SUSPENDED; 1215 break; 1216 1217 case M_COM: 1218 if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo)) 1219 return JPEG_SUSPENDED; 1220 break; 1221 1222 case M_RST0: /* these are all parameterless */ 1223 case M_RST1: 1224 case M_RST2: 1225 case M_RST3: 1226 case M_RST4: 1227 case M_RST5: 1228 case M_RST6: 1229 case M_RST7: 1230 case M_TEM: 1231 TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker); 1232 break; 1233 1234 case M_DNL: /* Ignore DNL ... perhaps the wrong thing */ 1235 if (! skip_variable(cinfo)) 1236 return JPEG_SUSPENDED; 1237 break; 1238 1239 default: /* must be DHP, EXP, JPGn, or RESn */ 1240 /* For now, we treat the reserved markers as fatal errors since they are 1241 * likely to be used to signal incompatible JPEG Part 3 extensions. 1242 * Once the JPEG 3 version-number marker is well defined, this code 1243 * ought to change! 1244 */ 1245 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); 1246 break; 1247 } 1248 /* Successfully processed marker, so reset state variable */ 1249 cinfo->unread_marker = 0; 1250 } /* end loop */ 1251 } 1252 1253 1254 /* 1255 * Read a restart marker, which is expected to appear next in the datastream; 1256 * if the marker is not there, take appropriate recovery action. 1257 * Returns FALSE if suspension is required. 1258 * 1259 * This is called by the entropy decoder after it has read an appropriate 1260 * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder 1261 * has already read a marker from the data source. Under normal conditions 1262 * cinfo->unread_marker will be reset to 0 before returning; if not reset, 1263 * it holds a marker which the decoder will be unable to read past. 1264 */ 1265 1266 METHODDEF(boolean) 1267 read_restart_marker (j_decompress_ptr cinfo) 1268 { 1269 /* Obtain a marker unless we already did. */ 1270 /* Note that next_marker will complain if it skips any data. */ 1271 if (cinfo->unread_marker == 0) { 1272 if (! next_marker(cinfo)) 1273 return FALSE; 1274 } 1275 1276 if (cinfo->unread_marker == 1277 ((int) M_RST0 + cinfo->marker->next_restart_num)) { 1278 /* Normal case --- swallow the marker and let entropy decoder continue */ 1279 TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num); 1280 cinfo->unread_marker = 0; 1281 } else { 1282 /* Uh-oh, the restart markers have been messed up. */ 1283 /* Let the data source manager determine how to resync. */ 1284 if (! (*cinfo->src->resync_to_restart) (cinfo, 1285 cinfo->marker->next_restart_num)) 1286 return FALSE; 1287 } 1288 1289 /* Update next-restart state */ 1290 cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7; 1291 1292 return TRUE; 1293 } 1294 1295 1296 /* 1297 * This is the default resync_to_restart method for data source managers 1298 * to use if they don't have any better approach. Some data source managers 1299 * may be able to back up, or may have additional knowledge about the data 1300 * which permits a more intelligent recovery strategy; such managers would 1301 * presumably supply their own resync method. 1302 * 1303 * read_restart_marker calls resync_to_restart if it finds a marker other than 1304 * the restart marker it was expecting. (This code is *not* used unless 1305 * a nonzero restart interval has been declared.) cinfo->unread_marker is 1306 * the marker code actually found (might be anything, except 0 or FF). 1307 * The desired restart marker number (0..7) is passed as a parameter. 1308 * This routine is supposed to apply whatever error recovery strategy seems 1309 * appropriate in order to position the input stream to the next data segment. 1310 * Note that cinfo->unread_marker is treated as a marker appearing before 1311 * the current data-source input point; usually it should be reset to zero 1312 * before returning. 1313 * Returns FALSE if suspension is required. 1314 * 1315 * This implementation is substantially constrained by wanting to treat the 1316 * input as a data stream; this means we can't back up. Therefore, we have 1317 * only the following actions to work with: 1318 * 1. Simply discard the marker and let the entropy decoder resume at next 1319 * byte of file. 1320 * 2. Read forward until we find another marker, discarding intervening 1321 * data. (In theory we could look ahead within the current bufferload, 1322 * without having to discard data if we don't find the desired marker. 1323 * This idea is not implemented here, in part because it makes behavior 1324 * dependent on buffer size and chance buffer-boundary positions.) 1325 * 3. Leave the marker unread (by failing to zero cinfo->unread_marker). 1326 * This will cause the entropy decoder to process an empty data segment, 1327 * inserting dummy zeroes, and then we will reprocess the marker. 1328 * 1329 * #2 is appropriate if we think the desired marker lies ahead, while #3 is 1330 * appropriate if the found marker is a future restart marker (indicating 1331 * that we have missed the desired restart marker, probably because it got 1332 * corrupted). 1333 * We apply #2 or #3 if the found marker is a restart marker no more than 1334 * two counts behind or ahead of the expected one. We also apply #2 if the 1335 * found marker is not a legal JPEG marker code (it's certainly bogus data). 1336 * If the found marker is a restart marker more than 2 counts away, we do #1 1337 * (too much risk that the marker is erroneous; with luck we will be able to 1338 * resync at some future point). 1339 * For any valid non-restart JPEG marker, we apply #3. This keeps us from 1340 * overrunning the end of a scan. An implementation limited to single-scan 1341 * files might find it better to apply #2 for markers other than EOI, since 1342 * any other marker would have to be bogus data in that case. 1343 */ 1344 1345 GLOBAL(boolean) 1346 jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired) 1347 { 1348 int marker = cinfo->unread_marker; 1349 int action = 1; 1350 1351 /* Always put up a warning. */ 1352 WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired); 1353 1354 /* Outer loop handles repeated decision after scanning forward. */ 1355 for (;;) { 1356 if (marker < (int) M_SOF0) 1357 action = 2; /* invalid marker */ 1358 else if (marker < (int) M_RST0 || marker > (int) M_RST7) 1359 action = 3; /* valid non-restart marker */ 1360 else { 1361 if (marker == ((int) M_RST0 + ((desired+1) & 7)) || 1362 marker == ((int) M_RST0 + ((desired+2) & 7))) 1363 action = 3; /* one of the next two expected restarts */ 1364 else if (marker == ((int) M_RST0 + ((desired-1) & 7)) || 1365 marker == ((int) M_RST0 + ((desired-2) & 7))) 1366 action = 2; /* a prior restart, so advance */ 1367 else 1368 action = 1; /* desired restart or too far away */ 1369 } 1370 TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action); 1371 switch (action) { 1372 case 1: 1373 /* Discard marker and let entropy decoder resume processing. */ 1374 cinfo->unread_marker = 0; 1375 return TRUE; 1376 case 2: 1377 /* Scan to the next marker, and repeat the decision loop. */ 1378 if (! next_marker(cinfo)) 1379 return FALSE; 1380 marker = cinfo->unread_marker; 1381 break; 1382 case 3: 1383 /* Return without advancing past this marker. */ 1384 /* Entropy decoder will be forced to process an empty segment. */ 1385 return TRUE; 1386 } 1387 } /* end loop */ 1388 } 1389 1390 1391 /* 1392 * Reset marker processing state to begin a fresh datastream. 1393 */ 1394 1395 METHODDEF(void) 1396 reset_marker_reader (j_decompress_ptr cinfo) 1397 { 1398 my_marker_ptr marker = (my_marker_ptr) cinfo->marker; 1399 1400 cinfo->comp_info = NULL; /* until allocated by get_sof */ 1401 cinfo->input_scan_number = 0; /* no SOS seen yet */ 1402 cinfo->unread_marker = 0; /* no pending marker */ 1403 marker->pub.saw_SOI = FALSE; /* set internal state too */ 1404 marker->pub.saw_SOF = FALSE; 1405 marker->pub.discarded_bytes = 0; 1406 marker->cur_marker = NULL; 1407 } 1408 1409 1410 /* 1411 * Initialize the marker reader module. 1412 * This is called only once, when the decompression object is created. 1413 */ 1414 1415 GLOBAL(void) 1416 jinit_marker_reader (j_decompress_ptr cinfo) 1417 { 1418 my_marker_ptr marker; 1419 int i; 1420 1421 /* Create subobject in permanent pool */ 1422 marker = (my_marker_ptr) 1423 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 1424 SIZEOF(my_marker_reader)); 1425 cinfo->marker = (struct jpeg_marker_reader *) marker; 1426 /* Initialize public method pointers */ 1427 marker->pub.reset_marker_reader = reset_marker_reader; 1428 marker->pub.read_markers = read_markers; 1429 marker->pub.read_restart_marker = read_restart_marker; 1430 /* Initialize COM/APPn processing. 1431 * By default, we examine and then discard APP0 and APP14, 1432 * but simply discard COM and all other APPn. 1433 */ 1434 marker->process_COM = skip_variable; 1435 marker->length_limit_COM = 0; 1436 for (i = 0; i < 16; i++) { 1437 marker->process_APPn[i] = skip_variable; 1438 marker->length_limit_APPn[i] = 0; 1439 } 1440 marker->process_APPn[0] = get_interesting_appn; 1441 marker->process_APPn[14] = get_interesting_appn; 1442 /* Reset marker processing state */ 1443 reset_marker_reader(cinfo); 1444 } 1445 1446 1447 /* 1448 * Control saving of COM and APPn markers into marker_list. 1449 */ 1450 1451 #ifdef SAVE_MARKERS_SUPPORTED 1452 1453 GLOBAL(void) 1454 jpeg_save_markers (j_decompress_ptr cinfo, int marker_code, 1455 unsigned int length_limit) 1456 { 1457 my_marker_ptr marker = (my_marker_ptr) cinfo->marker; 1458 long maxlength; 1459 jpeg_marker_parser_method processor; 1460 1461 /* Length limit mustn't be larger than what we can allocate 1462 * (should only be a concern in a 16-bit environment). 1463 */ 1464 maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct); 1465 if (((long) length_limit) > maxlength) 1466 length_limit = (unsigned int) maxlength; 1467 1468 /* Choose processor routine to use. 1469 * APP0/APP14 have special requirements. 1470 */ 1471 if (length_limit) { 1472 processor = save_marker; 1473 /* If saving APP0/APP14, save at least enough for our internal use. */ 1474 if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN) 1475 length_limit = APP0_DATA_LEN; 1476 else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN) 1477 length_limit = APP14_DATA_LEN; 1478 } else { 1479 processor = skip_variable; 1480 /* If discarding APP0/APP14, use our regular on-the-fly processor. */ 1481 if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14) 1482 processor = get_interesting_appn; 1483 } 1484 1485 if (marker_code == (int) M_COM) { 1486 marker->process_COM = processor; 1487 marker->length_limit_COM = length_limit; 1488 } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) { 1489 marker->process_APPn[marker_code - (int) M_APP0] = processor; 1490 marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit; 1491 } else 1492 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); 1493 } 1494 1495 #endif /* SAVE_MARKERS_SUPPORTED */ 1496 1497 1498 /* 1499 * Install a special processing method for COM or APPn markers. 1500 */ 1501 1502 GLOBAL(void) 1503 jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code, 1504 jpeg_marker_parser_method routine) 1505 { 1506 my_marker_ptr marker = (my_marker_ptr) cinfo->marker; 1507 1508 if (marker_code == (int) M_COM) 1509 marker->process_COM = routine; 1510 else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) 1511 marker->process_APPn[marker_code - (int) M_APP0] = routine; 1512 else 1513 ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); 1514 } 1515
