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 (! (*((my_marker_ptr) cinfo->marker)->process_APPn[		cinfo->unread_marker - (int) M_APP0]) (cinfo))	return JPEG_SUSPENDED;      break;          case M_COM:      if (! (*((my_marker_ptr) 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){  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;  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 */  marker->pub.saw_SOI = FALSE;		/* set internal state too */  marker->pub.saw_SOF = FALSE;  marker->pub.discarded_bytes = 0;  marker->cur_marker = NULL;}/* * 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){  my_marker_ptr marker;  int i;  /* Create subobject in permanent pool */  marker = (my_marker_ptr)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,				SIZEOF(my_marker_reader));  cinfo->marker = (struct jpeg_marker_reader *) marker;  /* Initialize public method pointers */  marker->pub.reset_marker_reader = reset_marker_reader;  marker->pub.read_markers = read_markers;  marker->pub.read_restart_marker = read_restart_marker;  /* Initialize COM/APPn processing.   * By default, we examine and then discard APP0 and APP14,   * but simply discard COM and all other APPn.   */  marker->process_COM = skip_variable;  marker->length_limit_COM = 0;  for (i = 0; i < 16; i++) {    marker->process_APPn[i] = skip_variable;    marker->length_limit_APPn[i] = 0;  }  marker->process_APPn[0] = get_interesting_appn;  marker->process_APPn[14] = get_interesting_appn;  /* Reset marker processing state */  reset_marker_reader(cinfo);}/* * Control saving of COM and APPn markers into marker_list. */#ifdef SAVE_MARKERS_SUPPORTEDGLOBAL(void)jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,		   unsigned int length_limit){  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;  long maxlength;  jpeg_marker_parser_method processor;  /* Length limit mustn't be larger than what we can allocate   * (should only be a concern in a 16-bit environment).   */  maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct);  if (((long) length_limit) > maxlength)    length_limit = (unsigned int) maxlength;  /* Choose processor routine to use.   * APP0/APP14 have special requirements.   */  if (length_limit) {    processor = save_marker;    /* If saving APP0/APP14, save at least enough for our internal use. */    if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN)      length_limit = APP0_DATA_LEN;    else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN)      length_limit = APP14_DATA_LEN;  } else {    processor = skip_variable;    /* If discarding APP0/APP14, use our regular on-the-fly processor. */    if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14)      processor = get_interesting_appn;  }  if (marker_code == (int) M_COM) {    marker->process_COM = processor;    marker->length_limit_COM = length_limit;  } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) {    marker->process_APPn[marker_code - (int) M_APP0] = processor;    marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit;  } else    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);}#endif /* SAVE_MARKERS_SUPPORTED *//* * Install a special processing method for COM or APPn markers. */GLOBAL(void)jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,			   jpeg_marker_parser_method routine){  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;  if (marker_code == (int) M_COM)    marker->process_COM = routine;  else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)    marker->process_APPn[marker_code - (int) M_APP0] = routine;  else    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);}