MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));  }  INPUT_SYNC(cinfo);  return TRUE;}LOCAL(boolean)get_dqt (j_decompress_ptr cinfo)/* Process a DQT marker */{  INT32 length;  int n, i, prec;  unsigned int tmp;  JQUANT_TBL *quant_ptr;  INPUT_VARS(cinfo);  INPUT_2BYTES(cinfo, length, return FALSE);  length -= 2;  while (length > 0) {    INPUT_BYTE(cinfo, n, return FALSE);    prec = n >> 4;    n &= 0x0F;    TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);    if (n >= NUM_QUANT_TBLS)      ERREXIT1(cinfo, JERR_DQT_INDEX, n);          if (cinfo->quant_tbl_ptrs[n] == NULL)      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);    quant_ptr = cinfo->quant_tbl_ptrs[n];    for (i = 0; i < DCTSIZE2; i++) {      if (prec)	INPUT_2BYTES(cinfo, tmp, return FALSE);      else	INPUT_BYTE(cinfo, tmp, return FALSE);      /* We convert the zigzag-order table to natural array order. */      quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp;    }    if (cinfo->err->trace_level >= 2) {      for (i = 0; i < DCTSIZE2; i += 8) {	TRACEMS8(cinfo, 2, JTRC_QUANTVALS,		 quant_ptr->quantval[i],   quant_ptr->quantval[i+1],		 quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],		 quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],		 quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);      }    }    length -= DCTSIZE2+1;    if (prec) length -= DCTSIZE2;  }  INPUT_SYNC(cinfo);  return TRUE;}LOCAL(boolean)get_dri (j_decompress_ptr cinfo)/* Process a DRI marker */{  INT32 length;  unsigned int tmp;  INPUT_VARS(cinfo);  INPUT_2BYTES(cinfo, length, return FALSE);    if (length != 4)    ERREXIT(cinfo, JERR_BAD_LENGTH);  INPUT_2BYTES(cinfo, tmp, return FALSE);  TRACEMS1(cinfo, 1, JTRC_DRI, tmp);  cinfo->restart_interval = tmp;  INPUT_SYNC(cinfo);  return TRUE;}METHODDEF(boolean)skip_variable (j_decompress_ptr cinfo)/* Skip over an unknown or uninteresting variable-length marker */{  INT32 length;  INPUT_VARS(cinfo);  INPUT_2BYTES(cinfo, length, return FALSE);    TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);  INPUT_SYNC(cinfo);		/* do before skip_input_data */  (*cinfo->src->skip_input_data) (cinfo, (long) length - 2L);  return TRUE;}/* * Find the next JPEG marker, save it in cinfo->unread_marker. * Returns FALSE if had to suspend before reaching a marker; * in that case cinfo->unread_marker is unchanged. * * Note that the result might not be a valid marker code, * but it will never be 0 or FF. */LOCAL(boolean)next_marker (j_decompress_ptr cinfo){  int c;  INPUT_VARS(cinfo);  for (;;) {    INPUT_BYTE(cinfo, c, return FALSE);    /* Skip any non-FF bytes.     * This may look a bit inefficient, but it will not occur in a valid file.     * We sync after each discarded byte so that a suspending data source     * can discard the byte from its buffer.     */    while (c != 0xFF) {      cinfo->marker->discarded_bytes++;      INPUT_SYNC(cinfo);      INPUT_BYTE(cinfo, c, return FALSE);    }    /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as     * pad bytes, so don't count them in discarded_bytes.  We assume there     * will not be so many consecutive FF bytes as to overflow a suspending     * data source's input buffer.     */    do {      INPUT_BYTE(cinfo, c, return FALSE);    } while (c == 0xFF);    if (c != 0)      break;			/* found a valid marker, exit loop */    /* Reach here if we found a stuffed-zero data sequence (FF/00).     * Discard it and loop back to try again.     */    cinfo->marker->discarded_bytes += 2;    INPUT_SYNC(cinfo);  }  if (cinfo->marker->discarded_bytes != 0) {    WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);    cinfo->marker->discarded_bytes = 0;  }  cinfo->unread_marker = c;  INPUT_SYNC(cinfo);  return TRUE;}LOCAL(boolean)first_marker (j_decompress_ptr cinfo)/* Like next_marker, but used to obtain the initial SOI marker. *//* For this marker, we do not allow preceding garbage or fill; otherwise, * we might well scan an entire input file before realizing it ain't JPEG. * If an application wants to process non-JFIF files, it must seek to the * SOI before calling the JPEG library. */{  int c, c2;  INPUT_VARS(cinfo);  INPUT_BYTE(cinfo, c, return FALSE);  INPUT_BYTE(cinfo, c2, return FALSE);  if (c != 0xFF || c2 != (int) M_SOI)    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);  cinfo->unread_marker = c2;  INPUT_SYNC(cinfo);  return TRUE;}/* * Read markers until SOS or EOI. * * Returns same codes as are defined for jpeg_consume_input: * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. */METHODDEF(int)read_markers (j_decompress_ptr cinfo){  /* Outer loop repeats once for each marker. */  for (;;) {    /* Collect the marker proper, unless we already did. */    /* NB: first_marker() enforces the requirement that SOI appear first. */    if (cinfo->unread_marker == 0) {      if (! cinfo->marker->saw_SOI) {	if (! first_marker(cinfo))	  return JPEG_SUSPENDED;      } else {	if (! next_marker(cinfo))	  return JPEG_SUSPENDED;      }    }    /* At this point cinfo->unread_marker contains the marker code and the     * input point is just past the marker proper, but before any parameters.     * A suspension will cause us to return with this state still true.     */    switch (cinfo->unread_marker) {    case M_SOI:      if (! get_soi(cinfo))	return JPEG_SUSPENDED;      break;    case M_SOF0:		/* Baseline */    case M_SOF1:		/* Extended sequential, Huffman */      if (! get_sof(cinfo, FALSE, FALSE))	return JPEG_SUSPENDED;      break;    case M_SOF2:		/* Progressive, Huffman */      if (! get_sof(cinfo, TRUE, FALSE))	return JPEG_SUSPENDED;      break;    case M_SOF9:		/* Extended sequential, arithmetic */      if (! get_sof(cinfo, FALSE, TRUE))	return JPEG_SUSPENDED;      break;    case M_SOF10:		/* Progressive, arithmetic */      if (! get_sof(cinfo, TRUE, TRUE))	return JPEG_SUSPENDED;      break;    /* Currently unsupported SOFn types */    case M_SOF3:		/* Lossless, Huffman */    case M_SOF5:		/* Differential sequential, Huffman */    case M_SOF6:		/* Differential progressive, Huffman */    case M_SOF7:		/* Differential lossless, Huffman */    case M_JPG:			/* Reserved for JPEG extensions */    case M_SOF11:		/* Lossless, arithmetic */    case M_SOF13:		/* Differential sequential, arithmetic */    case M_SOF14:		/* Differential progressive, arithmetic */    case M_SOF15:		/* Differential lossless, arithmetic */      ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);      break;    case M_SOS:      if (! get_sos(cinfo))	return JPEG_SUSPENDED;      cinfo->unread_marker = 0;	/* processed the marker */      return JPEG_REACHED_SOS;        case M_EOI:      TRACEMS(cinfo, 1, JTRC_EOI);      cinfo->unread_marker = 0;	/* processed the marker */      return JPEG_REACHED_EOI;          case M_DAC:      if (! get_dac(cinfo))	return JPEG_SUSPENDED;      break;          case M_DHT:      if (! get_dht(cinfo))	return JPEG_SUSPENDED;      break;          case M_DQT:      if (! get_dqt(cinfo))	return JPEG_SUSPENDED;      break;          case M_DRI:      if (! get_dri(cinfo))	return JPEG_SUSPENDED;      break;          case M_APP0:    case M_APP1:    case M_APP2:    case M_APP3:    case M_APP4:    case M_APP5:    case M_APP6:    case M_APP7:    case M_APP8:    case M_APP9:    case M_APP10:    case M_APP11:    case M_APP12:    case M_APP13:    case M_APP14:    case M_APP15:      if (! (*cinfo->marker->process_APPn[cinfo->unread_marker - (int) M_APP0]) (cinfo))	return JPEG_SUSPENDED;      break;          case M_COM:      if (! (*cinfo->marker->process_COM) (cinfo))	return JPEG_SUSPENDED;      break;    case M_RST0:		/* these are all parameterless */    case M_RST1:    case M_RST2:    case M_RST3:    case M_RST4:    case M_RST5:    case M_RST6:    case M_RST7:    case M_TEM:      TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);      break;    case M_DNL:			/* Ignore DNL ... perhaps the wrong thing */      if (! skip_variable(cinfo))	return JPEG_SUSPENDED;      break;    default:			/* must be DHP, EXP, JPGn, or RESn */      /* For now, we treat the reserved markers as fatal errors since they are       * likely to be used to signal incompatible JPEG Part 3 extensions.       * Once the JPEG 3 version-number marker is well defined, this code       * ought to change!       */      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);      break;    }    /* Successfully processed marker, so reset state variable */    cinfo->unread_marker = 0;  } /* end loop */}/* * Read a restart marker, which is expected to appear next in the datastream; * if the marker is not there, take appropriate recovery action. * Returns FALSE if suspension is required. * * This is called by the entropy decoder after it has read an appropriate * number of MCUs.  cinfo->unread_marker may be nonzero if the entropy decoder * has already read a marker from the data source.  Under normal conditions * cinfo->unread_marker will be reset to 0 before returning; if not reset, * it holds a marker which the decoder will be unable to read past. */METHODDEF(boolean)read_restart_marker (j_decompress_ptr cinfo){  /* Obtain a marker unless we already did. */  /* Note that next_marker will complain if it skips any data. */  if (cinfo->unread_marker == 0) {    if (! next_marker(cinfo))      return FALSE;  }  if (cinfo->unread_marker ==      ((int) M_RST0 + cinfo->marker->next_restart_num)) {    /* Normal case --- swallow the marker and let entropy decoder continue */    TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);    cinfo->unread_marker = 0;  } else {    /* Uh-oh, the restart markers have been messed up. */    /* Let the data source manager determine how to resync. */    if (! (*cinfo->src->resync_to_restart) (cinfo,					    cinfo->marker->next_restart_num))      return FALSE;  }  /* Update next-restart state */  cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;  return TRUE;}/* * This is the default resync_to_restart method for data source managers * to use if they don't have any better approach.  Some data source managers * may be able to back up, or may have additional knowledge about the data * which permits a more intelligent recovery strategy; such managers would * presumably supply their own resync method. * * read_restart_marker calls resync_to_restart if it finds a marker other than * the restart marker it was expecting.  (This code is *not* used unless * a nonzero restart interval has been declared.)  cinfo->unread_marker is * the marker code actually found (might be anything, except 0 or FF). * The desired restart marker number (0..7) is passed as a parameter. * This routine is supposed to apply whatever error recovery strategy seems * appropriate in order to position the input stream to the next data segment. * Note that cinfo->unread_marker is treated as a marker appearing before * the current data-source input point; usually it should be reset to zero * before returning. * Returns FALSE if suspension is required. * * This implementation is substantially constrained by wanting to treat the * input as a data stream; this means we can't back up.  Therefore, we have * only the following actions to work with: *   1. Simply discard the marker and let the entropy decoder resume at next *      byte of file. *   2. Read forward until we find another marker, discarding intervening *      data.  (In theory we could look ahead within the current bufferload, *      without having to discard data if we don't find the desired marker. *      This idea is not implemented here, in part because it makes behavior *      dependent on buffer size and chance buffer-boundary positions.) *   3. Leave the marker unread (by failing to zero cinfo->unread_marker). *      This will cause the entropy decoder to process an empty data segment, *      inserting dummy zeroes, and then we will reprocess the marker. * * #2 is appropriate if we think the desired marker lies ahead, while #3 is * appropriate if the found marker is a future restart marker (indicating * that we have missed the desired restart marker, probably because it got * corrupted). * We apply #2 or #3 if the found marker is a restart marker no more than * two counts behind or ahead of the expected one.  We also apply #2 if the * found marker is not a legal JPEG marker code (it's certainly bogus data). * If the found marker is a restart marker more than 2 counts away, we do #1 * (too much risk that the marker is erroneous; with luck we will be able to * resync at some future point). * For any valid non-restart JPEG marker, we apply #3.  This keeps us from * overrunning the end of a scan.  An implementation limited to single-scan * files might find it better to apply #2 for markers other than EOI, since * any other marker would have to be bogus data in that case. */GLOBAL(boolean)jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired){  int marker = cinfo->unread_marker;  int action = 1;    /* Always put up a warning. */  WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);    /* Outer loop handles repeated decision after scanning forward. */  for (;;) {    if (marker < (int) M_SOF0)      action = 2;		/* invalid marker */    else if (marker < (int) M_RST0 || marker > (int) M_RST7)      action = 3;		/* valid non-restart marker */    else {      if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||	  marker == ((int) M_RST0 + ((desired+2) & 7)))	action = 3;		/* one of the next two expected restarts */      else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||	       marker == ((int) M_RST0 + ((desired-2) & 7)))	action = 2;		/* a prior restart, so advance */      else	action = 1;		/* desired restart or too far away */    }    TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);    switch (action) {    case 1:      /* Discard marker and let entropy decoder resume processing. */      cinfo->unread_marker = 0;      return TRUE;    case 2:      /* Scan to the next marker, and repeat the decision loop. */      if (! next_marker(cinfo))	return FALSE;      marker = cinfo->unread_marker;      break;    case 3:      /* Return without advancing past this marker. */      /* Entropy decoder will be forced to process an empty segment. */      return TRUE;    }  } /* end loop */}/* * Reset marker processing state to begin a fresh datastream. */METHODDEF(void)reset_marker_reader (j_decompress_ptr cinfo){  cinfo->comp_info = NULL;		/* until allocated by get_sof */  cinfo->input_scan_number = 0;		/* no SOS seen yet */  cinfo->unread_marker = 0;		/* no pending marker */  cinfo->marker->saw_SOI = FALSE;	/* set internal state too */  cinfo->marker->saw_SOF = FALSE;  cinfo->marker->discarded_bytes = 0;}/* * Initialize the marker reader module. * This is called only once, when the decompression object is created. */GLOBAL(void)jinit_marker_reader (j_decompress_ptr cinfo){  int i;  /* Create subobject in permanent pool */  cinfo->marker = (struct jpeg_marker_reader *)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,				SIZEOF(struct jpeg_marker_reader));  /* Initialize method pointers */  cinfo->marker->reset_marker_reader = reset_marker_reader;  cinfo->marker->read_markers = read_markers;  cinfo->marker->read_restart_marker = read_restart_marker;  cinfo->marker->process_COM = skip_variable;  for (i = 0; i < 16; i++)    cinfo->marker->process_APPn[i] = skip_variable;  cinfo->marker->process_APPn[0] = get_app0;  cinfo->marker->process_APPn[14] = get_app14;  /* Reset marker processing state */  reset_marker_reader(cinfo);}