/* State variable: index of next scanline to be written to   * jpeg_write_scanlines().  Application may use this to control its   * processing loop, e.g., "while (next_scanline < image_height)".   */  JDIMENSION next_scanline;	/* 0 .. image_height-1  */  /* Remaining fields are known throughout compressor, but generally   * should not be touched by a surrounding application.   */  /*   * These fields are computed during compression startup   */  boolean progressive_mode;	/* TRUE if scan script uses progressive mode */  int max_h_samp_factor;	/* largest h_samp_factor */  int max_v_samp_factor;	/* largest v_samp_factor */  JDIMENSION total_iMCU_rows;	/* # of iMCU rows to be input to coef ctlr */  /* The coefficient controller receives data in units of MCU rows as defined   * for fully interleaved scans (whether the JPEG file is interleaved or not).   * There are v_samp_factor * DCTSIZE sample rows of each component in an   * "iMCU" (interleaved MCU) row.   */    /*   * These fields are valid during any one scan.   * They describe the components and MCUs actually appearing in the scan.   */  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[C_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 */  /*   * Links to compression subobjects (methods and private variables of modules)   */  struct jpeg_comp_master * master;  struct jpeg_c_main_controller * main;  struct jpeg_c_prep_controller * prep;  struct jpeg_c_coef_controller * coef;  struct jpeg_marker_writer * marker;  struct jpeg_color_converter * cconvert;  struct jpeg_downsampler * downsample;  struct jpeg_forward_dct * fdct;  struct jpeg_entropy_encoder * entropy;};/* Master record for a decompression instance */struct jpeg_decompress_struct {  jpeg_common_fields;		/* Fields shared with jpeg_compress_struct */  /* Source of compressed data */  struct jpeg_source_mgr * src;  /* Basic description of image --- filled in by jpeg_read_header(). */  /* Application may inspect these values to decide how to process image. */  JDIMENSION image_width;	/* nominal image width (from SOF marker) */  JDIMENSION image_height;	/* nominal image height */  int num_components;		/* # of color components in JPEG image */  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */  /* Decompression processing parameters --- these fields must be set before   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes   * them to default values.   */  J_COLOR_SPACE out_color_space; /* colorspace for output */  unsigned int scale_num, scale_denom; /* fraction by which to scale image */  double output_gamma;		/* image gamma wanted in output */  boolean buffered_image;	/* TRUE=multiple output passes */  boolean raw_data_out;		/* TRUE=downsampled data wanted */  J_DCT_METHOD dct_method;	/* IDCT algorithm selector */  boolean do_fancy_upsampling;	/* TRUE=apply fancy upsampling */  boolean do_block_smoothing;	/* TRUE=apply interblock smoothing */  boolean quantize_colors;	/* TRUE=colormapped output wanted */  /* the following are ignored if not quantize_colors: */  J_DITHER_MODE dither_mode;	/* type of color dithering to use */  boolean two_pass_quantize;	/* TRUE=use two-pass color quantization */  int desired_number_of_colors;	/* max # colors to use in created colormap */  /* these are significant only in buffered-image mode: */  boolean enable_1pass_quant;	/* enable future use of 1-pass quantizer */  boolean enable_external_quant;/* enable future use of external colormap */  boolean enable_2pass_quant;	/* enable future use of 2-pass quantizer */  /* Description of actual output image that will be returned to application.   * These fields are computed by jpeg_start_decompress().   * You can also use jpeg_calc_output_dimensions() to determine these values   * in advance of calling jpeg_start_decompress().   */  JDIMENSION output_width;	/* scaled image width */  JDIMENSION output_height;	/* scaled image height */  int out_color_components;	/* # of color components in out_color_space */  int output_components;	/* # of color components returned */  /* output_components is 1 (a colormap index) when quantizing colors;   * otherwise it equals out_color_components.   */  int rec_outbuf_height;	/* min recommended height of scanline buffer */  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows   * high, space and time will be wasted due to unnecessary data copying.   * Usually rec_outbuf_height will be 1 or 2, at most 4.   */  /* When quantizing colors, the output colormap is described by these fields.   * The application can supply a colormap by setting colormap non-NULL before   * calling jpeg_start_decompress; otherwise a colormap is created during   * jpeg_start_decompress or jpeg_start_output.   * The map has out_color_components rows and actual_number_of_colors columns.   */  int actual_number_of_colors;	/* number of entries in use */  JSAMPARRAY colormap;		/* The color map as a 2-D pixel array */  /* State variables: these variables indicate the progress of decompression.   * The application may examine these but must not modify them.   */  /* Row index of next scanline to be read from jpeg_read_scanlines().   * Application may use this to control its processing loop, e.g.,   * "while (output_scanline < output_height)".   */  JDIMENSION output_scanline;	/* 0 .. output_height-1  */  /* Current input scan number and number of iMCU rows completed in scan.   * These indicate the progress of the decompressor input side.   */  int input_scan_number;	/* Number of SOS markers seen so far */  JDIMENSION input_iMCU_row;	/* Number of iMCU rows completed */  /* The "output scan number" is the notional scan being displayed by the   * output side.  The decompressor will not allow output scan/row number   * to get ahead of input scan/row, but it can fall arbitrarily far behind.   */  int output_scan_number;	/* Nominal scan number being displayed */  JDIMENSION output_iMCU_row;	/* Number of iMCU rows read */  /* Current progression status.  coef_bits[c][i] indicates the precision   * with which component c's DCT coefficient i (in zigzag order) is known.   * It is -1 when no data has yet been received, otherwise it is the point   * transform (shift) value for the most recent scan of the coefficient   * (thus, 0 at completion of the progression).   * This pointer is NULL when reading a non-progressive file.   */  int (*coef_bits)[DCTSIZE2];	/* -1 or current Al value for each coef */  /* Internal JPEG parameters --- the application usually need not look at   * these fields.  Note that the decompressor output side may not use   * any parameters that can change between scans.   */  /* Quantization and Huffman tables are carried forward across input   * datastreams when processing abbreviated JPEG datastreams.   */  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];  /* ptrs to coefficient quantization tables, or NULL if not defined */  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];  /* ptrs to Huffman coding tables, or NULL if not defined */  /* These parameters are never carried across datastreams, since they   * are given in SOF/SOS markers or defined to be reset by SOI.   */  int data_precision;		/* bits of precision in image data */  jpeg_component_info * comp_info;  /* comp_info[i] describes component that appears i'th in SOF */  boolean progressive_mode;	/* TRUE if SOFn specifies progressive mode */  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */  /* These fields record data obtained from optional markers recognized by   * the JPEG library.   */  boolean saw_JFIF_marker;	/* TRUE iff a JFIF APP0 marker was found */  /* Data copied from JFIF marker: */  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 */  /* 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).