/* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */  UINT8 JFIF_major_version;	/* JFIF version number */  UINT8 JFIF_minor_version;  UINT8 density_unit;		/* JFIF code for pixel size units */  UINT16 X_density;		/* Horizontal pixel density */  UINT16 Y_density;		/* Vertical pixel density */  boolean saw_Adobe_marker;	/* TRUE iff an Adobe APP14 marker was found */  UINT8 Adobe_transform;	/* Color transform code from Adobe marker */  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */  /* Aside from the specific data retained from APPn markers known to the   * library, the uninterpreted contents of any or all APPn and COM markers   * can be saved in a list for examination by the application.   */  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */  /* Remaining fields are known throughout decompressor, but generally   * should not be touched by a surrounding application.   */  /*   * These fields are computed during decompression startup   */  int max_h_samp_factor;	/* largest h_samp_factor */  int max_v_samp_factor;	/* largest v_samp_factor */  int min_DCT_scaled_size;	/* smallest DCT_scaled_size of any component */  JDIMENSION total_iMCU_rows;	/* # of iMCU rows in image */  /* The coefficient controller's input and output progress is measured in   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows   * in fully interleaved JPEG scans, but are used whether the scan is   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block   * rows of each component.  Therefore, the IDCT output contains   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.   */  JSAMPLE * sample_range_limit; /* table for fast range-limiting */  /*   * These fields are valid during any one scan.   * They describe the components and MCUs actually appearing in the scan.   * Note that the decompressor output side must not use these fields.   */  int comps_in_scan;		/* # of JPEG components in this scan */  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];  /* *cur_comp_info[i] describes component that appears i'th in SOS */  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */  int blocks_in_MCU;		/* # of DCT blocks per MCU */  int MCU_membership[D_MAX_BLOCKS_IN_MCU];  /* MCU_membership[i] is index in cur_comp_info of component owning */  /* i'th block in an MCU */  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */  /* This field is shared between entropy decoder and marker parser.   * It is either zero or the code of a JPEG marker that has been   * read from the data source, but has not yet been processed.   */  int unread_marker;  /*   * Links to decompression subobjects (methods, private variables of modules)   */  struct jpeg_decomp_master * master;  struct jpeg_d_main_controller * main;  struct jpeg_d_coef_controller * coef;  struct jpeg_d_post_controller * post;  struct jpeg_input_controller * inputctl;  struct jpeg_marker_reader * marker;  struct jpeg_entropy_decoder * entropy;  struct jpeg_inverse_dct * idct;  struct jpeg_upsampler * upsample;  struct jpeg_color_deconverter * cconvert;  struct jpeg_color_quantizer * cquantize;};/* "Object" declarations for JPEG modules that may be supplied or called * directly by the surrounding application. * As with all objects in the JPEG library, these structs only define the * publicly visible methods and state variables of a module.  Additional * private fields may exist after the public ones. *//* Error handler object */struct jpeg_error_mgr {  /* Error exit handler: does not return to caller */  JMETHOD(void, error_exit, (j_common_ptr cinfo));  /* Conditionally emit a trace or warning message */  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));  /* Routine that actually outputs a trace or error message */  JMETHOD(void, output_message, (j_common_ptr cinfo));  /* Format a message string for the most recent JPEG error or message */  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));#define JMSG_LENGTH_MAX  200	/* recommended size of format_message buffer */  /* Reset error state variables at start of a new image */  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));    /* The message ID code and any parameters are saved here.   * A message can have one string parameter or up to 8 int parameters.   */  int msg_code;#define JMSG_STR_PARM_MAX  80  union {    int i[8];    char s[JMSG_STR_PARM_MAX];  } msg_parm;    /* Standard state variables for error facility */    int trace_level;		/* max msg_level that will be displayed */    /* For recoverable corrupt-data errors, we emit a warning message,   * but keep going unless emit_message chooses to abort.  emit_message   * should count warnings in num_warnings.  The surrounding application   * can check for bad data by seeing if num_warnings is nonzero at the   * end of processing.   */  long num_warnings;		/* number of corrupt-data warnings */  /* These fields point to the table(s) of error message strings.   * An application can change the table pointer to switch to a different   * message list (typically, to change the language in which errors are   * reported).  Some applications may wish to add additional error codes   * that will be handled by the JPEG library error mechanism; the second   * table pointer is used for this purpose.   *   * First table includes all errors generated by JPEG library itself.   * Error code 0 is reserved for a "no such error string" message.   */  const char * const * jpeg_message_table; /* Library errors */  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */  /* Second table can be added by application (see cjpeg/djpeg for example).   * It contains strings numbered first_addon_message..last_addon_message.   */  const char * const * addon_message_table; /* Non-library errors */  int first_addon_message;	/* code for first string in addon table */  int last_addon_message;	/* code for last string in addon table */};/* Progress monitor object */struct jpeg_progress_mgr {  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));  long pass_counter;		/* work units completed in this pass */  long pass_limit;		/* total number of work units in this pass */  int completed_passes;		/* passes completed so far */  int total_passes;		/* total number of passes expected */};/* Data destination object for compression */struct jpeg_destination_mgr {  JOCTET * next_output_byte;	/* => next byte to write in buffer */  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */  JMETHOD(void, init_destination, (j_compress_ptr cinfo));  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));  JMETHOD(void, term_destination, (j_compress_ptr cinfo));};/* Data source object for decompression */struct jpeg_source_mgr {  const JOCTET * next_input_byte; /* => next byte to read from buffer */  size_t bytes_in_buffer;	/* # of bytes remaining in buffer */  JMETHOD(void, init_source, (j_decompress_ptr cinfo));  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));  JMETHOD(void, term_source, (j_decompress_ptr cinfo));};/* Memory manager object. * Allocates "small" objects (a few K total), "large" objects (tens of K), * and "really big" objects (virtual arrays with backing store if needed). * The memory manager does not allow individual objects to be freed; rather, * each created object is assigned to a pool, and whole pools can be freed * at once.  This is faster and more convenient than remembering exactly what * to free, especially where malloc()/free() are not too speedy. * NB: alloc routines never return NULL.  They exit to error_exit if not * successful. */#define JPOOL_PERMANENT	0	/* lasts until master record is destroyed */#define JPOOL_IMAGE	1	/* lasts until done with image/datastream */#define JPOOL_NUMPOOLS	2typedef struct jvirt_sarray_control * jvirt_sarray_ptr;typedef struct jvirt_barray_control * jvirt_barray_ptr;struct jpeg_memory_mgr {  /* Method pointers */  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,				size_t sizeofobject));  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,				     size_t sizeofobject));  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,				     JDIMENSION samplesperrow,				     JDIMENSION numrows));  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,				      JDIMENSION blocksperrow,				      JDIMENSION numrows));  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,						  int pool_id,						  boolean pre_zero,						  JDIMENSION samplesperrow,						  JDIMENSION numrows,						  JDIMENSION maxaccess));  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,						  int pool_id,						  boolean pre_zero,						  JDIMENSION blocksperrow,						  JDIMENSION numrows,						  JDIMENSION maxaccess));  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,					   jvirt_sarray_ptr ptr,					   JDIMENSION start_row,					   JDIMENSION num_rows,					   boolean writable));  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,					    jvirt_barray_ptr ptr,					    JDIMENSION start_row,					    JDIMENSION num_rows,					    boolean writable));  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));  JMETHOD(void, self_destruct, (j_common_ptr cinfo));  /* Limit on memory allocation for this JPEG object.  (Note that this is   * merely advisory, not a guaranteed maximum; it only affects the space   * used for virtual-array buffers.)  May be changed by outer application   * after creating the JPEG object.   */  long max_memory_to_use;  /* Maximum allocation request accepted by alloc_large. */  long max_alloc_chunk;};/* Routine signature for application-supplied marker processing methods. * Need not pass marker code since it is stored in cinfo->unread_marker. */typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));/* Declarations for routines called by application. * The JPP macro hides prototype parameters from compilers that can't cope. * Note JPP requires double parentheses. */#ifdef HAVE_PROTOTYPES#define JPP(arglist)	arglist#else#define JPP(arglist)	()#endif/* Short forms of external names for systems with brain-damaged linkers. * We shorten external names to be unique in the first six letters, which