src/third_party/libjpeg_turbo/jdmarker.c

   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 }