自学教程：C++ GETJOCTET函数代码示例

boolJpgInput::read_icc_profile(j_decompress_ptr cinfo, ImageSpec& spec){    int num_markers = 0;    std::vector<unsigned char> icc_buf;    unsigned int total_length = 0;    const int MAX_SEQ_NO      = 255;    unsigned char marker_present        [MAX_SEQ_NO         + 1];  // one extra is used to store the flag if marker is found, set to one if marker is found    unsigned int data_length[MAX_SEQ_NO + 1];  // store the size of each marker    unsigned int data_offset[MAX_SEQ_NO + 1];  // store the offset of each marker    memset(marker_present, 0, (MAX_SEQ_NO + 1));    for (jpeg_saved_marker_ptr m = cinfo->marker_list; m; m = m->next) {        if (m->marker == (JPEG_APP0 + 2)            && !strcmp((const char*)m->data, "ICC_PROFILE")) {            if (num_markers == 0)                num_markers = GETJOCTET(m->data[13]);            else if (num_markers != GETJOCTET(m->data[13]))                return false;            int seq_no = GETJOCTET(m->data[12]);            if (seq_no <= 0 || seq_no > num_markers)                return false;            if (marker_present[seq_no])  // duplicate marker                return false;            marker_present[seq_no] = 1;  // flag found marker            data_length[seq_no]    = m->data_length - ICC_HEADER_SIZE;        }    }    if (num_markers == 0)        return false;    // checking for missing markers    for (int seq_no = 1; seq_no <= num_markers; seq_no++) {        if (marker_present[seq_no] == 0)            return false;  // missing sequence number        data_offset[seq_no] = total_length;        total_length += data_length[seq_no];    }    if (total_length == 0)        return false;  // found only empty markers    icc_buf.resize(total_length * sizeof(JOCTET));    // and fill it in    for (jpeg_saved_marker_ptr m = cinfo->marker_list; m; m = m->next) {        if (m->marker == (JPEG_APP0 + 2)            && !strcmp((const char*)m->data, "ICC_PROFILE")) {            int seq_no = GETJOCTET(m->data[12]);            memcpy(&icc_buf[0] + data_offset[seq_no], m->data + ICC_HEADER_SIZE,                   data_length[seq_no]);        }    }    spec.attribute(ICC_PROFILE_ATTR, TypeDesc(TypeDesc::UINT8, total_length),                   &icc_buf[0]);    return true;}

staticcmsBool HandlePhotoshopAPP13(jpeg_saved_marker_ptr ptr){    while (ptr) {        if (ptr -> marker == (JPEG_APP0 + 13) && ptr -> data_length > 9)        {            JOCTET FAR* data = ptr -> data;            if(GETJOCTET(data[0]) == 0x50 &&               GETJOCTET(data[1]) == 0x68 &&               GETJOCTET(data[2]) == 0x6F &&               GETJOCTET(data[3]) == 0x74 &&               GETJOCTET(data[4]) == 0x6F &&               GETJOCTET(data[5]) == 0x73 &&               GETJOCTET(data[6]) == 0x68 &&               GETJOCTET(data[7]) == 0x6F &&               GETJOCTET(data[8]) == 0x70) {                ProcessPhotoshopAPP13(data, ptr -> data_length);                return TRUE;            }        }        ptr = ptr -> next;    }    return FALSE;}

static void jcopy_markers_execute(j_decompress_ptr srcinfo, j_compress_ptr dstinfo){  jpeg_saved_marker_ptr marker;  /* In the current implementation, we don't actually need to examine the   * option flag here; we just copy everything that got saved.   * But to avoid confusion, we do not output JFIF and Adobe APP14 markers   * if the encoder library already wrote one.   */  for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {    if (dstinfo->write_JFIF_header &&    marker->marker == JPEG_APP0 &&    marker->data_length >= 5 &&    GETJOCTET(marker->data[0]) == 0x4A &&    GETJOCTET(marker->data[1]) == 0x46 &&    GETJOCTET(marker->data[2]) == 0x49 &&    GETJOCTET(marker->data[3]) == 0x46 &&    GETJOCTET(marker->data[4]) == 0)      continue;         /* reject duplicate JFIF */    if (dstinfo->write_Adobe_marker &&    marker->marker == JPEG_APP0+14 &&    marker->data_length >= 5 &&    GETJOCTET(marker->data[0]) == 0x41 &&    GETJOCTET(marker->data[1]) == 0x64 &&    GETJOCTET(marker->data[2]) == 0x6F &&    GETJOCTET(marker->data[3]) == 0x62 &&    GETJOCTET(marker->data[4]) == 0x65)      continue;         /* reject duplicate Adobe */#ifdef NEED_FAR_POINTERS    /* We could use jpeg_write_marker if the data weren't FAR... */    {      unsigned int i;      jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);      for (i = 0; i < marker->data_length; i++)        jpeg_write_m_byte(dstinfo, marker->data[i]);    }#else    jpeg_write_marker(dstinfo, marker->marker,              marker->data, marker->data_length);#endif  }}

/* Comment processing */u_charjpeg_getc(j_decompress_ptr cinfo){	struct jpeg_source_mgr *datasrc = cinfo->src;	if (datasrc->bytes_in_buffer == 0) {		if (! (*datasrc->fill_input_buffer) (cinfo))			err(1, "%s: fill_input", __FUNCTION__);	}	datasrc->bytes_in_buffer--;	return GETJOCTET(*datasrc->next_input_byte++);}

static unsigned intjpeg_getc (j_decompress_ptr cinfo)/* Read next byte */{  struct jpeg_source_mgr * datasrc = cinfo->src;  if (datasrc->bytes_in_buffer == 0) {      if (! (*datasrc->fill_input_buffer) (cinfo))           pm_error("Can't suspend here.");  }  datasrc->bytes_in_buffer--;  return GETJOCTET(*datasrc->next_input_byte++);}

/* This function was borrowed from libjpeg */static l_uint8jpeg_getc(j_decompress_ptr cinfo){struct jpeg_source_mgr *datasrc;    datasrc = cinfo->src;    if (datasrc->bytes_in_buffer == 0) {        if (! (*datasrc->fill_input_buffer) (cinfo)) {            return 0;        }    }    datasrc->bytes_in_buffer--;    return GETJOCTET(*datasrc->next_input_byte++);}

staticBOOL IsITUFax(jpeg_saved_marker_ptr ptr){    while (ptr) {                if (ptr -> marker == (JPEG_APP0 + 1) && ptr -> data_length > 5)        {            JOCTET FAR* data = ptr -> data;                        if (GETJOCTET(data[0]) == 0x47 &&                GETJOCTET(data[1]) == 0x33 &&                GETJOCTET(data[2]) == 0x46 &&                GETJOCTET(data[3]) == 0x41 &&                GETJOCTET(data[4]) == 0x58)                return TRUE;        }                ptr = ptr -> next;    }   return FALSE;}

jpeg_fill_bit_buffer (bitread_working_state * state,          register bit_buf_type get_buffer, register int bits_left,          int nbits)/* Load up the bit buffer to a depth of at least nbits */{  /* Copy heavily used state fields into locals (hopefully registers) */  register const JOCTET * next_input_byte = state->next_input_byte;  register size_t bytes_in_buffer = state->bytes_in_buffer;  j_decompress_ptr cinfo = state->cinfo;  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */  /* (It is assumed that no request will be for more than that many bits.) */  /* We fail to do so only if we hit a marker or are forced to suspend. */  if (cinfo->unread_marker == 0) {  /* cannot advance past a marker */    while (bits_left < MIN_GET_BITS) {      register int c;      /* Attempt to read a byte */      if (bytes_in_buffer == 0) {  if (! (*cinfo->src->fill_input_buffer) (cinfo))    return FALSE;  next_input_byte = cinfo->src->next_input_byte;  bytes_in_buffer = cinfo->src->bytes_in_buffer;      }      bytes_in_buffer--;      c = GETJOCTET(*next_input_byte++);      /* If it's 0xFF, check and discard stuffed zero byte */      if (c == 0xFF) {  /* Loop here to discard any padding FF's on terminating marker,   * so that we can save a valid unread_marker value.  NOTE: we will   * accept multiple FF's followed by a 0 as meaning a single FF data   * byte.  This data pattern is not valid according to the standard.   */  do {    if (bytes_in_buffer == 0) {      if (! (*cinfo->src->fill_input_buffer) (cinfo))        return FALSE;      next_input_byte = cinfo->src->next_input_byte;      bytes_in_buffer = cinfo->src->bytes_in_buffer;    }    bytes_in_buffer--;    c = GETJOCTET(*next_input_byte++);  } while (c == 0xFF);  if (c == 0) {    /* Found FF/00, which represents an FF data byte */    c = 0xFF;  } else {    /* Oops, it's actually a marker indicating end of compressed data.     * Save the marker code for later use.     * Fine point: it might appear that we should save the marker into     * bitread working state, not straight into permanent state.  But     * once we have hit a marker, we cannot need to suspend within the     * current MCU, because we will read no more bytes from the data     * source.  So it is OK to update permanent state right away.     */    cinfo->unread_marker = c;    /* See if we need to insert some fake zero bits. */    goto no_more_bytes;  }      }      /* OK, load c into get_buffer */      get_buffer = (get_buffer << 8) | c;      bits_left += 8;    } /* end while */  } else {  no_more_bytes:    /* We get here if we've read the marker that terminates the compressed     * data segment.  There should be enough bits in the buffer register     * to satisfy the request; if so, no problem.     */    if (nbits > bits_left) {      /* Uh-oh.  Report corrupted data to user and stuff zeroes into       * the data stream, so that we can produce some kind of image.       * We use a nonvolatile flag to ensure that only one warning message       * appears per data segment.       */      huffd_common_ptr huffd;      if (cinfo->process == JPROC_LOSSLESS)  huffd = (huffd_common_ptr) ((j_lossless_d_ptr) cinfo->codec)->entropy_private;      else  huffd = (huffd_common_ptr) ((j_lossy_d_ptr) cinfo->codec)->entropy_private;      if (! huffd->insufficient_data) {  WARNMS(cinfo, JWRN_HIT_MARKER);  huffd->insufficient_data = TRUE;      }      /* Fill the buffer with zero bits */      get_buffer <<= MIN_GET_BITS - bits_left;      bits_left = MIN_GET_BITS;    }  }  /* Unload the local registers */  state->next_input_byte = next_input_byte;  state->bytes_in_buffer = bytes_in_buffer;  state->get_buffer = get_buffer;  state->bits_left = bits_left;//.........这里部分代码省略.........

//.........这里部分代码省略.........#ifdef PROGRESS_REPORT  start_progress_monitor((j_common_ptr) &cinfo, &progress);#endif  /* Figure out the input file format, and set up to read it. */  src_mgr = select_file_type(&cinfo, input_file);  src_mgr->input_file = input_file;  /* Read the input file header to obtain file size & colorspace. */  (*src_mgr->start_input) (&cinfo, src_mgr);  /* Now that we know input colorspace, fix colorspace-dependent defaults */#if JPEG_RAW_READER  if (!is_jpeg)#endif    jpeg_default_colorspace(&cinfo);  /* Adjust default compression parameters by re-parsing the options */  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);  /* Specify data destination for compression */#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)  if (memdst)    jpeg_mem_dest(&cinfo, &outbuffer, &outsize);  else#endif    jpeg_stdio_dest(&cinfo, output_file);  /* Start compressor */  jpeg_start_compress(&cinfo, TRUE);  /* Copy metadata */  if (is_jpeg) {    jpeg_saved_marker_ptr marker;        /* In the current implementation, we don't actually need to examine the     * option flag here; we just copy everything that got saved.     * But to avoid confusion, we do not output JFIF and Adobe APP14 markers     * if the encoder library already wrote one.     */    for (marker = src_mgr->marker_list; marker != NULL; marker = marker->next) {      if (cinfo.write_JFIF_header &&          marker->marker == JPEG_APP0 &&          marker->data_length >= 5 &&          GETJOCTET(marker->data[0]) == 0x4A &&          GETJOCTET(marker->data[1]) == 0x46 &&          GETJOCTET(marker->data[2]) == 0x49 &&          GETJOCTET(marker->data[3]) == 0x46 &&          GETJOCTET(marker->data[4]) == 0)        continue;			/* reject duplicate JFIF */      if (cinfo.write_Adobe_marker &&          marker->marker == JPEG_APP0+14 &&          marker->data_length >= 5 &&          GETJOCTET(marker->data[0]) == 0x41 &&          GETJOCTET(marker->data[1]) == 0x64 &&          GETJOCTET(marker->data[2]) == 0x6F &&          GETJOCTET(marker->data[3]) == 0x62 &&          GETJOCTET(marker->data[4]) == 0x65)        continue;			/* reject duplicate Adobe */      jpeg_write_marker(&cinfo, marker->marker, marker->data, marker->data_length);    }  }    /* Process data */  while (cinfo.next_scanline < cinfo.image_height) {    num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);#if JPEG_RAW_READER    if (is_jpeg)      (void) jpeg_write_raw_data(&cinfo, src_mgr->plane_pointer, num_scanlines);    else#endif      (void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);  }  /* Finish compression and release memory */  (*src_mgr->finish_input) (&cinfo, src_mgr);  jpeg_finish_compress(&cinfo);  jpeg_destroy_compress(&cinfo);  /* Close files, if we opened them */  if (input_file != stdin)    fclose(input_file);  if (output_file != stdout && output_file != NULL)    fclose(output_file);#ifdef PROGRESS_REPORT  end_progress_monitor((j_common_ptr) &cinfo);#endif  if (memdst) {    fprintf(stderr, "Compressed size:  %lu bytes/n", outsize);    if (outbuffer != NULL)      free(outbuffer);  }  /* All done. */  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);  return 0;			/* suppress no-return-value warnings */}

decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data){  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;  int Al = cinfo->Al;  int blkn;  BITREAD_STATE_VARS;  savable_state state;  /* Process restart marker if needed; may have to suspend */  if (cinfo->restart_interval) {    if (entropy->restarts_to_go == 0)      if (! process_restart(cinfo))	return FALSE;  }  /* If we've run out of data, just leave the MCU set to zeroes.   * This way, we return uniform gray for the remainder of the segment.   */  if (! entropy->pub.insufficient_data) {    /* Load up working state */    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);    ASSIGN_STATE(state, entropy->saved);    /* Outer loop handles each block in the MCU */    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {      JBLOCKROW block = MCU_data[blkn];      int ci = cinfo->MCU_membership[blkn];      d_derived_tbl * tbl = entropy->dc_derived_tbls[ci];      register int s;      /* Decode a single block's worth of coefficients */      /* Section F.2.2.1: decode the DC coefficient difference */      {		/* HUFFX_DECODE */	register int nb, look, t;	if (bits_left < HUFFX_LOOKAHEAD) {	  register const JOCTET * next_input_byte = br_state.next_input_byte;	  register size_t         bytes_in_buffer = br_state.bytes_in_buffer;	  if (cinfo->unread_marker == 0) {	    while (bits_left < MIN_GET_BITS) {	      register int c;	      if (bytes_in_buffer == 0 ||		  (c = GETJOCTET(*next_input_byte)) == 0xFF) {		goto label11; }	      bytes_in_buffer--; next_input_byte++;	      get_buffer = (get_buffer << 8) | c;	      bits_left += 8;	    }	    br_state.next_input_byte = next_input_byte;	    br_state.bytes_in_buffer = bytes_in_buffer;	  } else {	label11:	    br_state.next_input_byte = next_input_byte;	    br_state.bytes_in_buffer = bytes_in_buffer;	    if (! jpeg_fill_bit_buffer(&br_state,get_buffer,bits_left, 0)) {	      return FALSE; }	    get_buffer = br_state.get_buffer; bits_left = br_state.bits_left;	    if (bits_left < HUFFX_LOOKAHEAD) {	      nb = 1; goto label1;	    }	  }	}	look = PEEK_BITS(HUFFX_LOOKAHEAD);	if ((nb = tbl->lookx_nbits[look]) != 0) {	  s = tbl->lookx_val[look];	  if (nb <= HUFFX_LOOKAHEAD) {	    DROP_BITS(nb);	  } else {	    DROP_BITS(HUFFX_LOOKAHEAD);	    nb -= HUFFX_LOOKAHEAD;	    CHECK_BIT_BUFFER(br_state, nb, return FALSE);	    s += GET_BITS(nb);	  }	} else {	  nb = HUFFX_LOOKAHEAD;      label1:	  if ((s=jpeg_huff_decode(&br_state,get_buffer,bits_left,tbl,nb))	       < 0) { return FALSE; }	  get_buffer = br_state.get_buffer; bits_left = br_state.bits_left;	  if (s) {	    CHECK_BIT_BUFFER(br_state, s, return FALSE);	    t = GET_BITS(s);	    s = HUFF_EXTEND(t, s);	  }	}      }

LOCAL booleanfill_bit_buffer (working_state * state, int nbits)/* Load up the bit buffer to a depth of at least nbits */{  /* Copy heavily used state fields into locals (hopefully registers) */  register const JOCTET * next_input_byte = state->next_input_byte;  register size_t bytes_in_buffer = state->bytes_in_buffer;  register INT32 get_buffer = state->cur.get_buffer;  register int bits_left = state->cur.bits_left;  register int c;  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */  /* (It is assumed that no request will be for more than that many bits.) */  while (bits_left < MIN_GET_BITS) {    /* Attempt to read a byte */    if (state->unread_marker != 0)      goto no_more_data;	/* can't advance past a marker */    if (bytes_in_buffer == 0) {      if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))	return FALSE;      next_input_byte = state->cinfo->src->next_input_byte;      bytes_in_buffer = state->cinfo->src->bytes_in_buffer;    }    bytes_in_buffer--;    c = GETJOCTET(*next_input_byte++);    /* If it's 0xFF, check and discard stuffed zero byte */    if (c == 0xFF) {      do {	if (bytes_in_buffer == 0) {	  if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))	    return FALSE;	  next_input_byte = state->cinfo->src->next_input_byte;	  bytes_in_buffer = state->cinfo->src->bytes_in_buffer;	}	bytes_in_buffer--;	c = GETJOCTET(*next_input_byte++);      } while (c == 0xFF);      if (c == 0) {	/* Found FF/00, which represents an FF data byte */	c = 0xFF;      } else {	/* Oops, it's actually a marker indicating end of compressed data. */	/* Better put it back for use later */	state->unread_marker = c;      no_more_data:	/* There should be enough bits still left in the data segment; */	/* if so, just break out of the outer while loop. */	if (bits_left >= nbits)	  break;	/* Uh-oh.  Report corrupted data to user and stuff zeroes into	 * the data stream, so that we can produce some kind of image.	 * Note that this will be repeated for each byte demanded for the	 * rest of the segment; this is slow but not unreasonably so.	 * The main thing is to avoid getting a zillion warnings, hence	 * we use a flag to ensure that only one warning appears.	 */	if (! ((huff_entropy_ptr) state->cinfo->entropy)->printed_eod) {	  WARNMS(state->cinfo, JWRN_HIT_MARKER);	  ((huff_entropy_ptr) state->cinfo->entropy)->printed_eod = TRUE;	}	c = 0;			/* insert a zero byte into bit buffer */      }    }    /* OK, load c into get_buffer */    get_buffer = (get_buffer << 8) | c;    bits_left += 8;  }  /* Unload the local registers */  state->next_input_byte = next_input_byte;  state->bytes_in_buffer = bytes_in_buffer;  state->cur.get_buffer = get_buffer;  state->cur.bits_left = bits_left;  return TRUE;}

static unsigned readUint16(JOCTET* data, bool isBigEndian){    if (isBigEndian)        return (GETJOCTET(data[0]) << 8) | GETJOCTET(data[1]);    return (GETJOCTET(data[1]) << 8) | GETJOCTET(data[0]);}

jpeg_fill_bit_buffer (bitread_working_state * state,		      register bit_buf_type get_buffer, register int bits_left,		      int nbits)/* Load up the bit buffer to a depth of at least nbits */{  /* Copy heavily used state fields into locals (hopefully registers) */  register const JOCTET * next_input_byte = state->next_input_byte;  register size_t bytes_in_buffer = state->bytes_in_buffer;  register int c;  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */  /* (It is assumed that no request will be for more than that many bits.) */  while (bits_left < MIN_GET_BITS) {    /* Attempt to read a byte */    if (state->unread_marker != 0)      goto no_more_data;	/* can't advance past a marker */    if (bytes_in_buffer == 0) {      if (! (*(boolean (*)(j_decompress_ptr))(__boundcheck_ptr_reference(253,34,"jpeg_fill_bit_buffer",(void *)(state->cinfo->src->fill_input_buffer),(void *)state->cinfo->src->fill_input_buffer))) (state->cinfo))	return FALSE;      next_input_byte = state->cinfo->src->next_input_byte;      bytes_in_buffer = state->cinfo->src->bytes_in_buffer;    }    bytes_in_buffer--;    c = GETJOCTET(*next_input_byte++);    /* If it's 0xFF, check and discard stuffed zero byte */    if (c == 0xFF) {      do {	if (bytes_in_buffer == 0) {	  if (! (*(boolean (*)(j_decompress_ptr))(__boundcheck_ptr_reference(265,31,"jpeg_fill_bit_buffer",(void *)(state->cinfo->src->fill_input_buffer),(void *)state->cinfo->src->fill_input_buffer))) (state->cinfo))	    return FALSE;	  next_input_byte = state->cinfo->src->next_input_byte;	  bytes_in_buffer = state->cinfo->src->bytes_in_buffer;	}	bytes_in_buffer--;	c = GETJOCTET(*next_input_byte++);      } while (c == 0xFF);      if (c == 0) {	/* Found FF/00, which represents an FF data byte */	c = 0xFF;      } else {	/* Oops, it's actually a marker indicating end of compressed data. */	/* Better put it back for use later */	state->unread_marker = c;      no_more_data:	/* There should be enough bits still left in the data segment; */	/* if so, just break out of the outer while loop. */	if (bits_left >= nbits)	  break;	/* Uh-oh.  Report corrupted data to user and stuff zeroes into	 * the data stream, so that we can produce some kind of image.	 * Note that this code will be repeated for each byte demanded	 * for the rest of the segment.  We use a nonvolatile flag to ensure	 * that only one warning message appears.	 */	if (! *(boolean *)(__boundcheck_ptr_reference(293,32,"jpeg_fill_bit_buffer",(void *)(state->printed_eod_ptr),(void *)(state->printed_eod_ptr)))) {	  WARNMS(state->cinfo, JWRN_HIT_MARKER);	  *(boolean *)(__boundcheck_ptr_reference(295,28,"jpeg_fill_bit_buffer",(void *)(state->printed_eod_ptr),(void *)(state->printed_eod_ptr))) = TRUE;	}	c = 0;			/* insert a zero byte into bit buffer */      }    }    /* OK, load c into get_buffer */    get_buffer = (get_buffer << 8) | c;    bits_left += 8;  }  /* Unload the local registers */  state->next_input_byte = next_input_byte;  state->bytes_in_buffer = bytes_in_buffer;  state->get_buffer = get_buffer;  state->bits_left = bits_left;  return TRUE;}

bool ScImgDataLoader_JPEG::marker_is_photoshop (jpeg_saved_marker_ptr marker){	return	    marker->marker == PHOTOSHOP_MARKER &&	    marker->data_length >= ICC_OVERHEAD_LEN &&	    /* verify the identifying string */	    GETJOCTET(marker->data[0]) == 0x50 &&	    GETJOCTET(marker->data[1]) == 0x68 &&	    GETJOCTET(marker->data[2]) == 0x6F &&	    GETJOCTET(marker->data[3]) == 0x74 &&	    GETJOCTET(marker->data[4]) == 0x6F &&	    GETJOCTET(marker->data[5]) == 0x73 &&	    GETJOCTET(marker->data[6]) == 0x68 &&	    GETJOCTET(marker->data[7]) == 0x6F &&	    GETJOCTET(marker->data[8]) == 0x70 &&	    GETJOCTET(marker->data[9]) == 0x20 &&	    GETJOCTET(marker->data[10]) == 0x33 &&	    GETJOCTET(marker->data[11]) == 0x2E &&	    GETJOCTET(marker->data[12]) == 0x30 &&	    GETJOCTET(marker->data[13]) == 0x0;}

static booleanmarker_is_icc (jpeg_saved_marker_ptr marker){  return    marker->marker == ICC_MARKER &&    marker->data_length >= ICC_OVERHEAD_LEN &&    /* verify the identifying string */    GETJOCTET(marker->data[0]) == 0x49 &&    GETJOCTET(marker->data[1]) == 0x43 &&    GETJOCTET(marker->data[2]) == 0x43 &&    GETJOCTET(marker->data[3]) == 0x5F &&    GETJOCTET(marker->data[4]) == 0x50 &&    GETJOCTET(marker->data[5]) == 0x52 &&    GETJOCTET(marker->data[6]) == 0x4F &&    GETJOCTET(marker->data[7]) == 0x46 &&    GETJOCTET(marker->data[8]) == 0x49 &&    GETJOCTET(marker->data[9]) == 0x4C &&    GETJOCTET(marker->data[10]) == 0x45 &&    GETJOCTET(marker->data[11]) == 0x0;}

booleanread_icc_profile (j_decompress_ptr cinfo,                  JOCTET **icc_data_ptr,                  unsigned int *icc_data_len){  jpeg_saved_marker_ptr marker;  int num_markers = 0;  int seq_no;  JOCTET *icc_data;  unsigned int total_length;#define MAX_SEQ_NO 255 /* sufficient since marker numbers are bytes */  char marker_present[MAX_SEQ_NO+1];	  /* 1 if marker found */  unsigned int data_length[MAX_SEQ_NO+1]; /* size of profile data in marker */  unsigned int data_offset[MAX_SEQ_NO+1]; /* offset for data in marker */  *icc_data_ptr = NULL;		/* avoid confusion if FALSE return */  *icc_data_len = 0;  /* This first pass over the saved markers discovers whether there are   * any ICC markers and verifies the consistency of the marker numbering.   */  for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)    marker_present[seq_no] = 0;  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next)  {    if (marker_is_icc(marker))    {      if (num_markers == 0)        num_markers = GETJOCTET(marker->data[13]);      else if (num_markers != GETJOCTET(marker->data[13]))        return FALSE;		/* inconsistent num_markers fields */      seq_no = GETJOCTET(marker->data[12]);      if (seq_no <= 0 || seq_no > num_markers)        return FALSE;		/* bogus sequence number */      if (marker_present[seq_no])        return FALSE;		/* duplicate sequence numbers */      marker_present[seq_no] = 1;      data_length[seq_no] = marker->data_length - ICC_OVERHEAD_LEN;    }  }  if (num_markers == 0)    return FALSE;  /* Check for missing markers, count total space needed,   * compute offset of each marker's part of the data.   */  total_length = 0;  for (seq_no = 1; seq_no <= num_markers; seq_no++)  {    if (marker_present[seq_no] == 0)      return FALSE;		/* missing sequence number */    data_offset[seq_no] = total_length;    total_length += data_length[seq_no];  }  if (total_length <= 0)    return FALSE;		/* found only empty markers? */  /* Allocate space for assembled data */  icc_data = (JOCTET *) calloc(total_length, sizeof(JOCTET));  if (icc_data == NULL)    return FALSE;		/* oops, out of memory */  /* and fill it in */  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next)  {    if (marker_is_icc(marker))    {      JOCTET FAR *src_ptr;      JOCTET *dst_ptr;      unsigned int length;      seq_no = GETJOCTET(marker->data[12]);      dst_ptr = icc_data + data_offset[seq_no];      src_ptr = marker->data + ICC_OVERHEAD_LEN;      length = data_length[seq_no];      while (length--)      {        *dst_ptr++ = *src_ptr++;      }    }  }  *icc_data_ptr = icc_data;  *icc_data_len = total_length;  return TRUE;}

static unsigned readUint32(JOCTET* data, bool isBigEndian){    if (isBigEndian)        return (GETJOCTET(data[0]) << 24) | (GETJOCTET(data[1]) << 16) | (GETJOCTET(data[2]) << 8) | GETJOCTET(data[3]);    return (GETJOCTET(data[3]) << 24) | (GETJOCTET(data[2]) << 16) | (GETJOCTET(data[1]) << 8) | GETJOCTET(data[0]);}

staticcmsBool ProcessPhotoshopAPP13(JOCTET FAR *data, int datalen){    int i;    for (i = 14; i < datalen; )    {        long len;        unsigned int type;        if (!(GETJOCTET(data[i]  ) == 0x38 &&              GETJOCTET(data[i+1]) == 0x42 &&              GETJOCTET(data[i+2]) == 0x49 &&              GETJOCTET(data[i+3]) == 0x4D)) break; // Not recognized        i += 4; // identifying string        type = (unsigned int) (GETJOCTET(data[i]<<8) + GETJOCTET(data[i+1]));        i += 2; // resource type        i += GETJOCTET(data[i]) + ((GETJOCTET(data[i]) & 1) ? 1 : 2);   // resource name        len = ((((GETJOCTET(data[i]<<8) + GETJOCTET(data[i+1]))<<8) +                         GETJOCTET(data[i+2]))<<8) + GETJOCTET(data[i+3]);        i += 4; // Size        if (type == 0x03ED && len >= 16) {            Decompressor.X_density = (UINT16) PS_FIXED_TO_FLOAT(GETJOCTET(data[i]<<8) + GETJOCTET(data[i+1]),                                                 GETJOCTET(data[i+2]<<8) + GETJOCTET(data[i+3]));            Decompressor.Y_density = (UINT16) PS_FIXED_TO_FLOAT(GETJOCTET(data[i+8]<<8) + GETJOCTET(data[i+9]),                                                 GETJOCTET(data[i+10]<<8) + GETJOCTET(data[i+11]));            // Set the density unit to 1 since the            // Vertical and Horizontal resolutions            // are specified in Pixels per inch            Decompressor.density_unit = 0x01;            return TRUE;        }        i += len + ((len & 1) ? 1 : 0);   // Alignment    }    return FALSE;}

/**  See if there was an ICC profile in the JPEG file being read;  if so, reassemble and return the profile data.  TRUE is returned if an ICC profile was found, FALSE if not.  If TRUE is returned, *icc_data_ptr is set to point to the  returned data, and *icc_data_len is set to its length.    IMPORTANT: the data at **icc_data_ptr has been allocated with malloc()  and must be freed by the caller with free() when the caller no longer  needs it.  (Alternatively, we could write this routine to use the  IJG library's memory allocator, so that the data would be freed implicitly  at jpeg_finish_decompress() time.  But it seems likely that many apps  will prefer to have the data stick around after decompression finishes.)    NOTE: if the file contains invalid ICC APP2 markers, we just silently  return FALSE.  You might want to issue an error message instead.*/static BOOL jpeg_read_icc_profile(j_decompress_ptr cinfo, JOCTET **icc_data_ptr, unsigned *icc_data_len) {	jpeg_saved_marker_ptr marker;	int num_markers = 0;	int seq_no;	JOCTET *icc_data;	unsigned total_length;	const int MAX_SEQ_NO = 255;			// sufficient since marker numbers are bytes	BYTE marker_present[MAX_SEQ_NO+1];	// 1 if marker found	unsigned data_length[MAX_SEQ_NO+1];	// size of profile data in marker	unsigned data_offset[MAX_SEQ_NO+1];	// offset for data in marker		*icc_data_ptr = NULL;		// avoid confusion if FALSE return	*icc_data_len = 0;		/**	this first pass over the saved markers discovers whether there are	any ICC markers and verifies the consistency of the marker numbering.	*/		memset(marker_present, 0, (MAX_SEQ_NO + 1));		for(marker = cinfo->marker_list; marker != NULL; marker = marker->next) {		if (marker_is_icc(marker)) {			if (num_markers == 0) {				// number of markers				num_markers = GETJOCTET(marker->data[13]);			}			else if (num_markers != GETJOCTET(marker->data[13])) {				return FALSE;		// inconsistent num_markers fields 			}			// sequence number			seq_no = GETJOCTET(marker->data[12]);			if (seq_no <= 0 || seq_no > num_markers) {				return FALSE;		// bogus sequence number 			}			if (marker_present[seq_no]) {				return FALSE;		// duplicate sequence numbers 			}			marker_present[seq_no] = 1;			data_length[seq_no] = marker->data_length - ICC_HEADER_SIZE;		}	}		if (num_markers == 0)		return FALSE;			/**	check for missing markers, count total space needed,	compute offset of each marker's part of the data.	*/		total_length = 0;	for(seq_no = 1; seq_no <= num_markers; seq_no++) {		if (marker_present[seq_no] == 0) {			return FALSE;		// missing sequence number		}		data_offset[seq_no] = total_length;		total_length += data_length[seq_no];	}		if (total_length <= 0)		return FALSE;		// found only empty markers ?		// allocate space for assembled data 	icc_data = (JOCTET *) malloc(total_length * sizeof(JOCTET));	if (icc_data == NULL)		return FALSE;		// out of memory		// and fill it in	for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {		if (marker_is_icc(marker)) {			JOCTET FAR *src_ptr;			JOCTET *dst_ptr;			unsigned length;			seq_no = GETJOCTET(marker->data[12]);			dst_ptr = icc_data + data_offset[seq_no];			src_ptr = marker->data + ICC_HEADER_SIZE;			length = data_length[seq_no];			while (length--) {				*dst_ptr++ = *src_ptr++;//.........这里部分代码省略.........