"Fossies" - the Fresh Open Source Software Archive

Member "PDFlib-Lite-7.0.5p3/libs/jpeg/jpeglib.h" (6 Jun 2012, 46209 Bytes) of package /linux/misc/old/PDFlib-Lite-7.0.5p3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "jpeglib.h" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * jpeglib.h
    3  *
    4  * Copyright (C) 1991-1998, Thomas G. Lane.
    5  * This file is part of the Independent JPEG Group's software.
    6  * For conditions of distribution and use, see the accompanying README file.
    7  *
    8  * This file defines the application interface for the JPEG library.
    9  * Most applications using the library need only include this file,
   10  * and perhaps jerror.h if they want to know the exact error codes.
   11  */
   12 
   13 #ifndef JPEGLIB_H
   14 #define JPEGLIB_H
   15 
   16 /*
   17  * First we include the configuration files that record how this
   18  * installation of the JPEG library is set up.  jconfig.h can be
   19  * generated automatically for many systems.  jmorecfg.h contains
   20  * manual configuration options that most people need not worry about.
   21  */
   22 
   23 #ifndef JCONFIG_INCLUDED    /* in case jinclude.h already did */
   24 #include "jconfig.h"        /* widely used configuration options */
   25 #endif
   26 #include "jmorecfg.h"       /* seldom changed options */
   27 
   28 
   29 /* Version ID for the JPEG library.
   30  * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
   31  */
   32 
   33 #define JPEG_LIB_VERSION  62    /* Version 6b */
   34 
   35 
   36 /* Various constants determining the sizes of things.
   37  * All of these are specified by the JPEG standard, so don't change them
   38  * if you want to be compatible.
   39  */
   40 
   41 #define DCTSIZE         8   /* The basic DCT block is 8x8 samples */
   42 #define DCTSIZE2        64  /* DCTSIZE squared; # of elements in a block */
   43 #define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
   44 #define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
   45 #define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
   46 #define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
   47 #define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
   48 /* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
   49  * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
   50  * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
   51  * to handle it.  We even let you do this from the jconfig.h file.  However,
   52  * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
   53  * sometimes emits noncompliant files doesn't mean you should too.
   54  */
   55 #define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
   56 #ifndef D_MAX_BLOCKS_IN_MCU
   57 #define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
   58 #endif
   59 
   60 
   61 /* Data structures for images (arrays of samples and of DCT coefficients).
   62  * On 80x86 machines, the image arrays are too big for near pointers,
   63  * but the pointer arrays can fit in near memory.
   64  */
   65 
   66 typedef JSAMPLE FAR *JSAMPROW;  /* ptr to one image row of pixel samples. */
   67 typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
   68 typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
   69 
   70 typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
   71 typedef JBLOCK FAR *JBLOCKROW;  /* pointer to one row of coefficient blocks */
   72 typedef JBLOCKROW *JBLOCKARRAY;     /* a 2-D array of coefficient blocks */
   73 typedef JBLOCKARRAY *JBLOCKIMAGE;   /* a 3-D array of coefficient blocks */
   74 
   75 typedef JCOEF FAR *JCOEFPTR;    /* useful in a couple of places */
   76 
   77 
   78 /* Types for JPEG compression parameters and working tables. */
   79 
   80 
   81 /* DCT coefficient quantization tables. */
   82 
   83 typedef struct {
   84   /* This array gives the coefficient quantizers in natural array order
   85    * (not the zigzag order in which they are stored in a JPEG DQT marker).
   86    * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
   87    */
   88   UINT16 quantval[DCTSIZE2];    /* quantization step for each coefficient */
   89   /* This field is used only during compression.  It's initialized FALSE when
   90    * the table is created, and set TRUE when it's been output to the file.
   91    * You could suppress output of a table by setting this to TRUE.
   92    * (See jpeg_suppress_tables for an example.)
   93    */
   94   boolean sent_table;       /* TRUE when table has been output */
   95 } JQUANT_TBL;
   96 
   97 
   98 /* Huffman coding tables. */
   99 
  100 typedef struct {
  101   /* These two fields directly represent the contents of a JPEG DHT marker */
  102   UINT8 bits[17];       /* bits[k] = # of symbols with codes of */
  103                 /* length k bits; bits[0] is unused */
  104   UINT8 huffval[256];       /* The symbols, in order of incr code length */
  105   /* This field is used only during compression.  It's initialized FALSE when
  106    * the table is created, and set TRUE when it's been output to the file.
  107    * You could suppress output of a table by setting this to TRUE.
  108    * (See jpeg_suppress_tables for an example.)
  109    */
  110   boolean sent_table;       /* TRUE when table has been output */
  111 } JHUFF_TBL;
  112 
  113 
  114 /* Basic info about one component (color channel). */
  115 
  116 typedef struct {
  117   /* These values are fixed over the whole image. */
  118   /* For compression, they must be supplied by parameter setup; */
  119   /* for decompression, they are read from the SOF marker. */
  120   int component_id;     /* identifier for this component (0..255) */
  121   int component_index;      /* its index in SOF or cinfo->comp_info[] */
  122   int h_samp_factor;        /* horizontal sampling factor (1..4) */
  123   int v_samp_factor;        /* vertical sampling factor (1..4) */
  124   int quant_tbl_no;     /* quantization table selector (0..3) */
  125   /* These values may vary between scans. */
  126   /* For compression, they must be supplied by parameter setup; */
  127   /* for decompression, they are read from the SOS marker. */
  128   /* The decompressor output side may not use these variables. */
  129   int dc_tbl_no;        /* DC entropy table selector (0..3) */
  130   int ac_tbl_no;        /* AC entropy table selector (0..3) */
  131   
  132   /* Remaining fields should be treated as private by applications. */
  133   
  134   /* These values are computed during compression or decompression startup: */
  135   /* Component's size in DCT blocks.
  136    * Any dummy blocks added to complete an MCU are not counted; therefore
  137    * these values do not depend on whether a scan is interleaved or not.
  138    */
  139   JDIMENSION width_in_blocks;
  140   JDIMENSION height_in_blocks;
  141   /* Size of a DCT block in samples.  Always DCTSIZE for compression.
  142    * For decompression this is the size of the output from one DCT block,
  143    * reflecting any scaling we choose to apply during the IDCT step.
  144    * Values of 1,2,4,8 are likely to be supported.  Note that different
  145    * components may receive different IDCT scalings.
  146    */
  147   int DCT_scaled_size;
  148   /* The downsampled dimensions are the component's actual, unpadded number
  149    * of samples at the jmain buffer (preprocessing/compression interface), thus
  150    * downsampled_width = ceil(image_width * Hi/Hmax)
  151    * and similarly for height.  For decompression, IDCT scaling is included, so
  152    * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
  153    */
  154   JDIMENSION downsampled_width;  /* actual width in samples */
  155   JDIMENSION downsampled_height; /* actual height in samples */
  156   /* This flag is used only for decompression.  In cases where some of the
  157    * components will be ignored (eg grayscale output from YCbCr image),
  158    * we can skip most computations for the unused components.
  159    */
  160   boolean component_needed; /* do we need the value of this component? */
  161 
  162   /* These values are computed before starting a scan of the component. */
  163   /* The decompressor output side may not use these variables. */
  164   int MCU_width;        /* number of blocks per MCU, horizontally */
  165   int MCU_height;       /* number of blocks per MCU, vertically */
  166   int MCU_blocks;       /* MCU_width * MCU_height */
  167   int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */
  168   int last_col_width;       /* # of non-dummy blocks across in last MCU */
  169   int last_row_height;      /* # of non-dummy blocks down in last MCU */
  170 
  171   /* Saved quantization table for component; NULL if none yet saved.
  172    * See jdinput.c comments about the need for this information.
  173    * This field is currently used only for decompression.
  174    */
  175   JQUANT_TBL * quant_table;
  176 
  177   /* Private per-component storage for DCT or IDCT subsystem. */
  178   void * dct_table;
  179 } jpeg_component_info;
  180 
  181 
  182 /* The script for encoding a multiple-scan file is an array of these: */
  183 
  184 typedef struct {
  185   int comps_in_scan;        /* number of components encoded in this scan */
  186   int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
  187   int Ss, Se;           /* progressive JPEG spectral selection parms */
  188   int Ah, Al;           /* progressive JPEG successive approx. parms */
  189 } jpeg_scan_info;
  190 
  191 /* The decompressor can save APPn and COM markers in a list of these: */
  192 
  193 typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
  194 
  195 struct jpeg_marker_struct {
  196   jpeg_saved_marker_ptr next;   /* next in list, or NULL */
  197   UINT8 marker;         /* marker code: JPEG_COM, or JPEG_APP0+n */
  198   unsigned int original_length; /* # bytes of data in the file */
  199   unsigned int data_length; /* # bytes of data saved at data[] */
  200   JOCTET FAR * data;        /* the data contained in the marker */
  201   /* the marker length word is not counted in data_length or original_length */
  202 };
  203 
  204 /* Known color spaces. */
  205 
  206 typedef enum {
  207     JCS_UNKNOWN,        /* error/unspecified */
  208     JCS_GRAYSCALE,      /* monochrome */
  209     JCS_RGB,        /* red/green/blue */
  210     JCS_YCbCr,      /* Y/Cb/Cr (also known as YUV) */
  211     JCS_CMYK,       /* C/M/Y/K */
  212     JCS_YCCK        /* Y/Cb/Cr/K */
  213 } J_COLOR_SPACE;
  214 
  215 /* DCT/IDCT algorithm options. */
  216 
  217 typedef enum {
  218     JDCT_ISLOW,     /* slow but accurate integer algorithm */
  219     JDCT_IFAST,     /* faster, less accurate integer method */
  220     JDCT_FLOAT      /* floating-point: accurate, fast on fast HW */
  221 } J_DCT_METHOD;
  222 
  223 #ifndef JDCT_DEFAULT        /* may be overridden in jconfig.h */
  224 #define JDCT_DEFAULT  JDCT_ISLOW
  225 #endif
  226 #ifndef JDCT_FASTEST        /* may be overridden in jconfig.h */
  227 #define JDCT_FASTEST  JDCT_IFAST
  228 #endif
  229 
  230 /* Dithering options for decompression. */
  231 
  232 typedef enum {
  233     JDITHER_NONE,       /* no dithering */
  234     JDITHER_ORDERED,    /* simple ordered dither */
  235     JDITHER_FS      /* Floyd-Steinberg error diffusion dither */
  236 } J_DITHER_MODE;
  237 
  238 
  239 /* Common fields between JPEG compression and decompression master structs. */
  240 
  241 #define jpeg_common_fields \
  242   struct jpeg_error_mgr * err;  /* Error handler module */\
  243   struct jpeg_memory_mgr * mem; /* Memory manager module */\
  244   struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
  245   void * client_data;       /* Available for use by application */\
  246   boolean is_decompressor;  /* So common code can tell which is which */\
  247   int global_state      /* For checking call sequence validity */
  248 
  249 /* Routines that are to be used by both halves of the library are declared
  250  * to receive a pointer to this structure.  There are no actual instances of
  251  * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
  252  */
  253 struct jpeg_common_struct {
  254   jpeg_common_fields;       /* Fields common to both master struct types */
  255   /* Additional fields follow in an actual jpeg_compress_struct or
  256    * jpeg_decompress_struct.  All three structs must agree on these
  257    * initial fields!  (This would be a lot cleaner in C++.)
  258    */
  259 };
  260 
  261 typedef struct jpeg_common_struct * j_common_ptr;
  262 typedef struct jpeg_compress_struct * j_compress_ptr;
  263 typedef struct jpeg_decompress_struct * j_decompress_ptr;
  264 
  265 
  266 /* Master record for a compression instance */
  267 
  268 struct jpeg_compress_struct {
  269   jpeg_common_fields;       /* Fields shared with jpeg_decompress_struct */
  270 
  271   /* Destination for compressed data */
  272   struct jpeg_destination_mgr * dest;
  273 
  274   /* Description of source image --- these fields must be filled in by
  275    * outer application before starting compression.  in_color_space must
  276    * be correct before you can even call jpeg_set_defaults().
  277    */
  278 
  279   JDIMENSION image_width;   /* input image width */
  280   JDIMENSION image_height;  /* input image height */
  281   int input_components;     /* # of color components in input image */
  282   J_COLOR_SPACE in_color_space; /* colorspace of input image */
  283 
  284   double input_gamma;       /* image gamma of input image */
  285 
  286   /* Compression parameters --- these fields must be set before calling
  287    * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
  288    * initialize everything to reasonable defaults, then changing anything
  289    * the application specifically wants to change.  That way you won't get
  290    * burnt when new parameters are added.  Also note that there are several
  291    * helper routines to simplify changing parameters.
  292    */
  293 
  294   int data_precision;       /* bits of precision in image data */
  295 
  296   int num_components;       /* # of color components in JPEG image */
  297   J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
  298 
  299   jpeg_component_info * comp_info;
  300   /* comp_info[i] describes component that appears i'th in SOF */
  301   
  302   JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
  303   /* ptrs to coefficient quantization tables, or NULL if not defined */
  304   
  305   JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  306   JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  307   /* ptrs to Huffman coding tables, or NULL if not defined */
  308   
  309   UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  310   UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  311   UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
  312 
  313   int num_scans;        /* # of entries in scan_info array */
  314   const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
  315   /* The default value of scan_info is NULL, which causes a single-scan
  316    * sequential JPEG file to be emitted.  To create a multi-scan file,
  317    * set num_scans and scan_info to point to an array of scan definitions.
  318    */
  319 
  320   boolean raw_data_in;      /* TRUE=caller supplies downsampled data */
  321   boolean arith_code;       /* TRUE=arithmetic coding, FALSE=Huffman */
  322   boolean optimize_coding;  /* TRUE=optimize entropy encoding parms */
  323   boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  324   int smoothing_factor;     /* 1..100, or 0 for no input smoothing */
  325   J_DCT_METHOD dct_method;  /* DCT algorithm selector */
  326 
  327   /* The restart interval can be specified in absolute MCUs by setting
  328    * restart_interval, or in MCU rows by setting restart_in_rows
  329    * (in which case the correct restart_interval will be figured
  330    * for each scan).
  331    */
  332   unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
  333   int restart_in_rows;      /* if > 0, MCU rows per restart interval */
  334 
  335   /* Parameters controlling emission of special markers. */
  336 
  337   boolean write_JFIF_header;    /* should a JFIF marker be written? */
  338   UINT8 JFIF_major_version; /* What to write for the JFIF version number */
  339   UINT8 JFIF_minor_version;
  340   /* These three values are not used by the JPEG code, merely copied */
  341   /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
  342   /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
  343   /* ratio is defined by X_density/Y_density even when density_unit=0. */
  344   UINT8 density_unit;       /* JFIF code for pixel size units */
  345   UINT16 X_density;     /* Horizontal pixel density */
  346   UINT16 Y_density;     /* Vertical pixel density */
  347   boolean write_Adobe_marker;   /* should an Adobe marker be written? */
  348   
  349   /* State variable: index of next scanline to be written to
  350    * jpeg_write_scanlines().  Application may use this to control its
  351    * processing loop, e.g., "while (next_scanline < image_height)".
  352    */
  353 
  354   JDIMENSION next_scanline; /* 0 .. image_height-1  */
  355 
  356   /* Remaining fields are known throughout compressor, but generally
  357    * should not be touched by a surrounding application.
  358    */
  359 
  360   /*
  361    * These fields are computed during compression startup
  362    */
  363   boolean progressive_mode; /* TRUE if scan script uses progressive mode */
  364   int max_h_samp_factor;    /* largest h_samp_factor */
  365   int max_v_samp_factor;    /* largest v_samp_factor */
  366 
  367   JDIMENSION total_iMCU_rows;   /* # of iMCU rows to be input to coef ctlr */
  368   /* The coefficient controller receives data in units of MCU rows as defined
  369    * for fully interleaved scans (whether the JPEG file is interleaved or not).
  370    * There are v_samp_factor * DCTSIZE sample rows of each component in an
  371    * "iMCU" (interleaved MCU) row.
  372    */
  373   
  374   /*
  375    * These fields are valid during any one scan.
  376    * They describe the components and MCUs actually appearing in the scan.
  377    */
  378   int comps_in_scan;        /* # of JPEG components in this scan */
  379   jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
  380   /* *cur_comp_info[i] describes component that appears i'th in SOS */
  381   
  382   JDIMENSION MCUs_per_row;  /* # of MCUs across the image */
  383   JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
  384   
  385   int blocks_in_MCU;        /* # of DCT blocks per MCU */
  386   int MCU_membership[C_MAX_BLOCKS_IN_MCU];
  387   /* MCU_membership[i] is index in cur_comp_info of component owning */
  388   /* i'th block in an MCU */
  389 
  390   int Ss, Se, Ah, Al;       /* progressive JPEG parameters for scan */
  391 
  392   /*
  393    * Links to compression subobjects (methods and private variables of modules)
  394    */
  395   struct jpeg_comp_master * master;
  396   struct jpeg_c_main_controller * jmain;
  397   struct jpeg_c_prep_controller * prep;
  398   struct jpeg_c_coef_controller * coef;
  399   struct jpeg_marker_writer * marker;
  400   struct jpeg_color_converter * cconvert;
  401   struct jpeg_downsampler * downsample;
  402   struct jpeg_forward_dct * fdct;
  403   struct jpeg_entropy_encoder * entropy;
  404   jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
  405   int script_space_size;
  406 };
  407 
  408 
  409 /* Master record for a decompression instance */
  410 
  411 struct jpeg_decompress_struct {
  412   jpeg_common_fields;       /* Fields shared with jpeg_compress_struct */
  413 
  414   /* Source of compressed data */
  415   struct jpeg_source_mgr * src;
  416 
  417   /* Basic description of image --- filled in by jpeg_read_header(). */
  418   /* Application may inspect these values to decide how to process image. */
  419 
  420   JDIMENSION image_width;   /* nominal image width (from SOF marker) */
  421   JDIMENSION image_height;  /* nominal image height */
  422   int num_components;       /* # of color components in JPEG image */
  423   J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
  424 
  425   /* Decompression processing parameters --- these fields must be set before
  426    * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
  427    * them to default values.
  428    */
  429 
  430   J_COLOR_SPACE out_color_space; /* colorspace for output */
  431 
  432   unsigned int scale_num, scale_denom; /* fraction by which to scale image */
  433 
  434   double output_gamma;      /* image gamma wanted in output */
  435 
  436   boolean buffered_image;   /* TRUE=multiple output passes */
  437   boolean raw_data_out;     /* TRUE=downsampled data wanted */
  438 
  439   J_DCT_METHOD dct_method;  /* IDCT algorithm selector */
  440   boolean do_fancy_upsampling;  /* TRUE=apply fancy upsampling */
  441   boolean do_block_smoothing;   /* TRUE=apply interblock smoothing */
  442 
  443   boolean quantize_colors;  /* TRUE=colormapped output wanted */
  444   /* the following are ignored if not quantize_colors: */
  445   J_DITHER_MODE dither_mode;    /* type of color dithering to use */
  446   boolean two_pass_quantize;    /* TRUE=use two-pass color quantization */
  447   int desired_number_of_colors; /* max # colors to use in created colormap */
  448   /* these are significant only in buffered-image mode: */
  449   boolean enable_1pass_quant;   /* enable future use of 1-pass quantizer */
  450   boolean enable_external_quant;/* enable future use of external colormap */
  451   boolean enable_2pass_quant;   /* enable future use of 2-pass quantizer */
  452 
  453   /* Description of actual output image that will be returned to application.
  454    * These fields are computed by jpeg_start_decompress().
  455    * You can also use jpeg_calc_output_dimensions() to determine these values
  456    * in advance of calling jpeg_start_decompress().
  457    */
  458 
  459   JDIMENSION output_width;  /* scaled image width */
  460   JDIMENSION output_height; /* scaled image height */
  461   int out_color_components; /* # of color components in out_color_space */
  462   int output_components;    /* # of color components returned */
  463   /* output_components is 1 (a colormap index) when quantizing colors;
  464    * otherwise it equals out_color_components.
  465    */
  466   int rec_outbuf_height;    /* min recommended height of scanline buffer */
  467   /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
  468    * high, space and time will be wasted due to unnecessary data copying.
  469    * Usually rec_outbuf_height will be 1 or 2, at most 4.
  470    */
  471 
  472   /* When quantizing colors, the output colormap is described by these fields.
  473    * The application can supply a colormap by setting colormap non-NULL before
  474    * calling jpeg_start_decompress; otherwise a colormap is created during
  475    * jpeg_start_decompress or jpeg_start_output.
  476    * The map has out_color_components rows and actual_number_of_colors columns.
  477    */
  478   int actual_number_of_colors;  /* number of entries in use */
  479   JSAMPARRAY colormap;      /* The color map as a 2-D pixel array */
  480 
  481   /* State variables: these variables indicate the progress of decompression.
  482    * The application may examine these but must not modify them.
  483    */
  484 
  485   /* Row index of next scanline to be read from jpeg_read_scanlines().
  486    * Application may use this to control its processing loop, e.g.,
  487    * "while (output_scanline < output_height)".
  488    */
  489   JDIMENSION output_scanline;   /* 0 .. output_height-1  */
  490 
  491   /* Current input scan number and number of iMCU rows completed in scan.
  492    * These indicate the progress of the decompressor input side.
  493    */
  494   int input_scan_number;    /* Number of SOS markers seen so far */
  495   JDIMENSION input_iMCU_row;    /* Number of iMCU rows completed */
  496 
  497   /* The "output scan number" is the notional scan being displayed by the
  498    * output side.  The decompressor will not allow output scan/row number
  499    * to get ahead of input scan/row, but it can fall arbitrarily far behind.
  500    */
  501   int output_scan_number;   /* Nominal scan number being displayed */
  502   JDIMENSION output_iMCU_row;   /* Number of iMCU rows read */
  503 
  504   /* Current progression status.  coef_bits[c][i] indicates the precision
  505    * with which component c's DCT coefficient i (in zigzag order) is known.
  506    * It is -1 when no data has yet been received, otherwise it is the point
  507    * transform (shift) value for the most recent scan of the coefficient
  508    * (thus, 0 at completion of the progression).
  509    * This pointer is NULL when reading a non-progressive file.
  510    */
  511   int (*coef_bits)[DCTSIZE2];   /* -1 or current Al value for each coef */
  512 
  513   /* Internal JPEG parameters --- the application usually need not look at
  514    * these fields.  Note that the decompressor output side may not use
  515    * any parameters that can change between scans.
  516    */
  517 
  518   /* Quantization and Huffman tables are carried forward across input
  519    * datastreams when processing abbreviated JPEG datastreams.
  520    */
  521 
  522   JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
  523   /* ptrs to coefficient quantization tables, or NULL if not defined */
  524 
  525   JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  526   JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  527   /* ptrs to Huffman coding tables, or NULL if not defined */
  528 
  529   /* These parameters are never carried across datastreams, since they
  530    * are given in SOF/SOS markers or defined to be reset by SOI.
  531    */
  532 
  533   int data_precision;       /* bits of precision in image data */
  534 
  535   jpeg_component_info * comp_info;
  536   /* comp_info[i] describes component that appears i'th in SOF */
  537 
  538   boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */
  539   boolean arith_code;       /* TRUE=arithmetic coding, FALSE=Huffman */
  540 
  541   UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  542   UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  543   UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
  544 
  545   /* MCUs per restart interval, or 0 for no restart */
  546   unsigned int restart_interval;
  547 
  548   /* These fields record data obtained from optional markers recognized by
  549    * the JPEG library.
  550    */
  551   boolean saw_JFIF_marker;  /* TRUE iff a JFIF APP0 marker was found */
  552   /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
  553   UINT8 JFIF_major_version; /* JFIF version number */
  554   UINT8 JFIF_minor_version;
  555   UINT8 density_unit;       /* JFIF code for pixel size units */
  556   UINT16 X_density;     /* Horizontal pixel density */
  557   UINT16 Y_density;     /* Vertical pixel density */
  558   boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */
  559   UINT8 Adobe_transform;    /* Color transform code from Adobe marker */
  560 
  561   boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  562 
  563   /* Aside from the specific data retained from APPn markers known to the
  564    * library, the uninterpreted contents of any or all APPn and COM markers
  565    * can be saved in a list for examination by the application.
  566    */
  567   jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
  568 
  569   /* Remaining fields are known throughout decompressor, but generally
  570    * should not be touched by a surrounding application.
  571    */
  572 
  573   /*
  574    * These fields are computed during decompression startup
  575    */
  576   int max_h_samp_factor;    /* largest h_samp_factor */
  577   int max_v_samp_factor;    /* largest v_samp_factor */
  578 
  579   int min_DCT_scaled_size;  /* smallest DCT_scaled_size of any component */
  580 
  581   JDIMENSION total_iMCU_rows;   /* # of iMCU rows in image */
  582   /* The coefficient controller's input and output progress is measured in
  583    * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
  584    * in fully interleaved JPEG scans, but are used whether the scan is
  585    * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
  586    * rows of each component.  Therefore, the IDCT output contains
  587    * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
  588    */
  589 
  590   JSAMPLE * sample_range_limit; /* table for fast range-limiting */
  591 
  592   /*
  593    * These fields are valid during any one scan.
  594    * They describe the components and MCUs actually appearing in the scan.
  595    * Note that the decompressor output side must not use these fields.
  596    */
  597   int comps_in_scan;        /* # of JPEG components in this scan */
  598   jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
  599   /* *cur_comp_info[i] describes component that appears i'th in SOS */
  600 
  601   JDIMENSION MCUs_per_row;  /* # of MCUs across the image */
  602   JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
  603 
  604   int blocks_in_MCU;        /* # of DCT blocks per MCU */
  605   int MCU_membership[D_MAX_BLOCKS_IN_MCU];
  606   /* MCU_membership[i] is index in cur_comp_info of component owning */
  607   /* i'th block in an MCU */
  608 
  609   int Ss, Se, Ah, Al;       /* progressive JPEG parameters for scan */
  610 
  611   /* This field is shared between entropy decoder and marker parser.
  612    * It is either zero or the code of a JPEG marker that has been
  613    * read from the data source, but has not yet been processed.
  614    */
  615   int unread_marker;
  616 
  617   /*
  618    * Links to decompression subobjects (methods, private variables of modules)
  619    */
  620   struct jpeg_decomp_master * master;
  621   struct jpeg_d_main_controller * jmain;
  622   struct jpeg_d_coef_controller * coef;
  623   struct jpeg_d_post_controller * post;
  624   struct jpeg_input_controller * inputctl;
  625   struct jpeg_marker_reader * marker;
  626   struct jpeg_entropy_decoder * entropy;
  627   struct jpeg_inverse_dct * idct;
  628   struct jpeg_upsampler * upsample;
  629   struct jpeg_color_deconverter * cconvert;
  630   struct jpeg_color_quantizer * cquantize;
  631 };
  632 
  633 
  634 /* "Object" declarations for JPEG modules that may be supplied or called
  635  * directly by the surrounding application.
  636  * As with all objects in the JPEG library, these structs only define the
  637  * publicly visible methods and state variables of a module.  Additional
  638  * private fields may exist after the public ones.
  639  */
  640 
  641 
  642 /* Error handler object */
  643 
  644 struct jpeg_error_mgr {
  645   /* Error exit handler: does not return to caller */
  646   JMETHOD(void, error_exit, (j_common_ptr cinfo));
  647   /* Conditionally emit a trace or warning message */
  648   JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
  649   /* Routine that actually outputs a trace or error message */
  650   JMETHOD(void, output_message, (j_common_ptr cinfo));
  651   /* Format a message string for the most recent JPEG error or message */
  652   JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
  653 #define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer */
  654   /* Reset error state variables at start of a new image */
  655   JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
  656   
  657   /* The message ID code and any parameters are saved here.
  658    * A message can have one string parameter or up to 8 int parameters.
  659    */
  660   int msg_code;
  661 #define JMSG_STR_PARM_MAX  80
  662   union {
  663     int i[8];
  664     char s[JMSG_STR_PARM_MAX];
  665   } msg_parm;
  666   
  667   /* Standard state variables for error facility */
  668   
  669   int trace_level;      /* max msg_level that will be displayed */
  670   
  671   /* For recoverable corrupt-data errors, we emit a warning message,
  672    * but keep going unless emit_message chooses to abort.  emit_message
  673    * should count warnings in num_warnings.  The surrounding application
  674    * can check for bad data by seeing if num_warnings is nonzero at the
  675    * end of processing.
  676    */
  677   long num_warnings;        /* number of corrupt-data warnings */
  678 
  679   /* These fields point to the table(s) of error message strings.
  680    * An application can change the table pointer to switch to a different
  681    * message list (typically, to change the language in which errors are
  682    * reported).  Some applications may wish to add additional error codes
  683    * that will be handled by the JPEG library error mechanism; the second
  684    * table pointer is used for this purpose.
  685    *
  686    * First table includes all errors generated by JPEG library itself.
  687    * Error code 0 is reserved for a "no such error string" message.
  688    */
  689   const char * const * jpeg_message_table; /* Library errors */
  690   int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
  691   /* Second table can be added by application (see cjpeg/djpeg for example).
  692    * It contains strings numbered first_addon_message..last_addon_message.
  693    */
  694   const char * const * addon_message_table; /* Non-library errors */
  695   int first_addon_message;  /* code for first string in addon table */
  696   int last_addon_message;   /* code for last string in addon table */
  697 };
  698 
  699 
  700 /* Progress monitor object */
  701 
  702 struct jpeg_progress_mgr {
  703   JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
  704 
  705   long pass_counter;        /* work units completed in this pass */
  706   long pass_limit;      /* total number of work units in this pass */
  707   int completed_passes;     /* passes completed so far */
  708   int total_passes;     /* total number of passes expected */
  709 };
  710 
  711 
  712 /* Data destination object for compression */
  713 
  714 struct jpeg_destination_mgr {
  715   JOCTET * next_output_byte;    /* => next byte to write in buffer */
  716   size_t free_in_buffer;    /* # of byte spaces remaining in buffer */
  717 
  718   JMETHOD(void, init_destination, (j_compress_ptr cinfo));
  719   JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
  720   JMETHOD(void, term_destination, (j_compress_ptr cinfo));
  721 };
  722 
  723 
  724 /* Data source object for decompression */
  725 
  726 struct jpeg_source_mgr {
  727   const JOCTET * next_input_byte; /* => next byte to read from buffer */
  728   size_t bytes_in_buffer;   /* # of bytes remaining in buffer */
  729 
  730   JMETHOD(void, init_source, (j_decompress_ptr cinfo));
  731   JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
  732   JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
  733   JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
  734   JMETHOD(void, term_source, (j_decompress_ptr cinfo));
  735 };
  736 
  737 
  738 /* Memory manager object.
  739  * Allocates "small" objects (a few K total), "large" objects (tens of K),
  740  * and "really big" objects (virtual arrays with backing store if needed).
  741  * The memory manager does not allow individual objects to be freed; rather,
  742  * each created object is assigned to a pool, and whole pools can be freed
  743  * at once.  This is faster and more convenient than remembering exactly what
  744  * to free, especially where malloc()/free() are not too speedy.
  745  * NB: alloc routines never return NULL.  They exit to error_exit if not
  746  * successful.
  747  */
  748 
  749 #define JPOOL_PERMANENT 0   /* lasts until master record is destroyed */
  750 #define JPOOL_IMAGE 1   /* lasts until done with image/datastream */
  751 #define JPOOL_NUMPOOLS  2
  752 
  753 typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
  754 typedef struct jvirt_barray_control * jvirt_barray_ptr;
  755 
  756 
  757 struct jpeg_memory_mgr {
  758   /* Method pointers */
  759   JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
  760                 size_t sizeofobject));
  761   JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
  762                      size_t sizeofobject));
  763   JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
  764                      JDIMENSION samplesperrow,
  765                      JDIMENSION numrows));
  766   JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
  767                       JDIMENSION blocksperrow,
  768                       JDIMENSION numrows));
  769   JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
  770                           int pool_id,
  771                           boolean pre_zero,
  772                           JDIMENSION samplesperrow,
  773                           JDIMENSION numrows,
  774                           JDIMENSION maxaccess));
  775   JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
  776                           int pool_id,
  777                           boolean pre_zero,
  778                           JDIMENSION blocksperrow,
  779                           JDIMENSION numrows,
  780                           JDIMENSION maxaccess));
  781   JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
  782   JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
  783                        jvirt_sarray_ptr ptr,
  784                        JDIMENSION start_row,
  785                        JDIMENSION num_rows,
  786                        boolean writable));
  787   JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
  788                         jvirt_barray_ptr ptr,
  789                         JDIMENSION start_row,
  790                         JDIMENSION num_rows,
  791                         boolean writable));
  792   JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
  793   JMETHOD(void, self_destruct, (j_common_ptr cinfo));
  794 
  795   /* Limit on memory allocation for this JPEG object.  (Note that this is
  796    * merely advisory, not a guaranteed maximum; it only affects the space
  797    * used for virtual-array buffers.)  May be changed by outer application
  798    * after creating the JPEG object.
  799    */
  800   long max_memory_to_use;
  801 
  802   /* Maximum allocation request accepted by alloc_large. */
  803   long max_alloc_chunk;
  804 };
  805 
  806 
  807 /* Routine signature for application-supplied marker processing methods.
  808  * Need not pass marker code since it is stored in cinfo->unread_marker.
  809  */
  810 typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
  811 
  812 
  813 /* Declarations for routines called by application.
  814  * The JPP macro hides prototype parameters from compilers that can't cope.
  815  * Note JPP requires double parentheses.
  816  */
  817 
  818 #ifdef HAVE_PROTOTYPES
  819 #define JPP(arglist)    arglist
  820 #else
  821 #define JPP(arglist)    ()
  822 #endif
  823 
  824 
  825 /* Short forms of external names for systems with brain-damaged linkers.
  826  * We shorten external names to be unique in the first six letters, which
  827  * is good enough for all known systems.
  828  * (If your compiler itself needs names to be unique in less than 15 
  829  * characters, you are out of luck.  Get a better compiler.)
  830  */
  831 
  832 #ifdef NEED_SHORT_EXTERNAL_NAMES
  833 #define jpeg_std_error      jStdError
  834 #define jpeg_CreateCompress jCreaCompress
  835 #define jpeg_CreateDecompress   jCreaDecompress
  836 #define jpeg_destroy_compress   jDestCompress
  837 #define jpeg_destroy_decompress jDestDecompress
  838 #define jpeg_stdio_dest     jStdDest
  839 #define jpeg_stdio_src      jStdSrc
  840 #define jpeg_set_defaults   jSetDefaults
  841 #define jpeg_set_colorspace jSetColorspace
  842 #define jpeg_default_colorspace jDefColorspace
  843 #define jpeg_set_quality    jSetQuality
  844 #define jpeg_set_linear_quality jSetLQuality
  845 #define jpeg_add_quant_table    jAddQuantTable
  846 #define jpeg_quality_scaling    jQualityScaling
  847 #define jpeg_simple_progression jSimProgress
  848 #define jpeg_suppress_tables    jSuppressTables
  849 #define jpeg_alloc_quant_table  jAlcQTable
  850 #define jpeg_alloc_huff_table   jAlcHTable
  851 #define jpeg_start_compress jStrtCompress
  852 #define jpeg_write_scanlines    jWrtScanlines
  853 #define jpeg_finish_compress    jFinCompress
  854 #define jpeg_write_raw_data jWrtRawData
  855 #define jpeg_write_marker   jWrtMarker
  856 #define jpeg_write_m_header jWrtMHeader
  857 #define jpeg_write_m_byte   jWrtMByte
  858 #define jpeg_write_tables   jWrtTables
  859 #define jpeg_read_header    jReadHeader
  860 #define jpeg_start_decompress   jStrtDecompress
  861 #define jpeg_read_scanlines jReadScanlines
  862 #define jpeg_finish_decompress  jFinDecompress
  863 #define jpeg_read_raw_data  jReadRawData
  864 #define jpeg_has_multiple_scans jHasMultScn
  865 #define jpeg_start_output   jStrtOutput
  866 #define jpeg_finish_output  jFinOutput
  867 #define jpeg_input_complete jInComplete
  868 #define jpeg_new_colormap   jNewCMap
  869 #define jpeg_consume_input  jConsumeInput
  870 #define jpeg_calc_output_dimensions jCalcDimensions
  871 #define jpeg_save_markers   jSaveMarkers
  872 #define jpeg_set_marker_processor   jSetMarker
  873 #define jpeg_read_coefficients  jReadCoefs
  874 #define jpeg_write_coefficients jWrtCoefs
  875 #define jpeg_copy_critical_parameters   jCopyCrit
  876 #define jpeg_abort_compress jAbrtCompress
  877 #define jpeg_abort_decompress   jAbrtDecompress
  878 #define jpeg_abort      jAbort
  879 #define jpeg_destroy        jDestroy
  880 #define jpeg_resync_to_restart  jResyncRestart
  881 #endif /* NEED_SHORT_EXTERNAL_NAMES */
  882 
  883 
  884 /* Default error-management setup */
  885 EXTERN(struct jpeg_error_mgr *) jpeg_std_error
  886     JPP((struct jpeg_error_mgr * err));
  887 
  888 /* Initialization of JPEG compression objects.
  889  * jpeg_create_compress() and jpeg_create_decompress() are the exported
  890  * names that applications should call.  These expand to calls on
  891  * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
  892  * passed for version mismatch checking.
  893  * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
  894  */
  895 #define jpeg_create_compress(cinfo) \
  896     jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
  897             (size_t) sizeof(struct jpeg_compress_struct))
  898 #define jpeg_create_decompress(cinfo) \
  899     jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
  900               (size_t) sizeof(struct jpeg_decompress_struct))
  901 EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
  902                       int version, size_t structsize));
  903 EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
  904                     int version, size_t structsize));
  905 /* Destruction of JPEG compression objects */
  906 EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
  907 EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
  908 
  909 /* Standard data source and destination managers: stdio streams. */
  910 /* Caller is responsible for opening the file before and closing after. */
  911 EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
  912 EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
  913 
  914 /* Default parameter setup for compression */
  915 EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
  916 /* Compression parameter setup aids */
  917 EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
  918                       J_COLOR_SPACE colorspace));
  919 EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
  920 EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
  921                    boolean force_baseline));
  922 EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
  923                       int scale_factor,
  924                       boolean force_baseline));
  925 EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
  926                        const unsigned int *basic_table,
  927                        int scale_factor,
  928                        boolean force_baseline));
  929 EXTERN(int) jpeg_quality_scaling JPP((int quality));
  930 EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
  931 EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
  932                        boolean suppress));
  933 EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
  934 EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
  935 
  936 /* Main entry points for compression */
  937 EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
  938                       boolean write_all_tables));
  939 EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
  940                          JSAMPARRAY scanlines,
  941                          JDIMENSION num_lines));
  942 EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
  943 
  944 /* Replaces jpeg_write_scanlines when writing raw downsampled data. */
  945 EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
  946                         JSAMPIMAGE data,
  947                         JDIMENSION num_lines));
  948 
  949 /* Write a special marker.  See libjpeg.doc concerning safe usage. */
  950 EXTERN(void) jpeg_write_marker
  951     JPP((j_compress_ptr cinfo, int marker,
  952          const JOCTET * dataptr, unsigned int datalen));
  953 /* Same, but piecemeal. */
  954 EXTERN(void) jpeg_write_m_header
  955     JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
  956 EXTERN(void) jpeg_write_m_byte
  957     JPP((j_compress_ptr cinfo, int val));
  958 
  959 /* Alternate compression function: just write an abbreviated table file */
  960 EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
  961 
  962 /* Decompression startup: read start of JPEG datastream to see what's there */
  963 EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
  964                   boolean require_image));
  965 /* Return value is one of: */
  966 #define JPEG_SUSPENDED      0 /* Suspended due to lack of input data */
  967 #define JPEG_HEADER_OK      1 /* Found valid image datastream */
  968 #define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
  969 /* If you pass require_image = TRUE (normal case), you need not check for
  970  * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
  971  * JPEG_SUSPENDED is only possible if you use a data source module that can
  972  * give a suspension return (the stdio source module doesn't).
  973  */
  974 
  975 /* Main entry points for decompression */
  976 EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
  977 EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
  978                         JSAMPARRAY scanlines,
  979                         JDIMENSION max_lines));
  980 EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
  981 
  982 /* Replaces jpeg_read_scanlines when reading raw downsampled data. */
  983 EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
  984                        JSAMPIMAGE data,
  985                        JDIMENSION max_lines));
  986 
  987 /* Additional entry points for buffered-image mode. */
  988 EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
  989 EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
  990                        int scan_number));
  991 EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
  992 EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
  993 EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
  994 EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
  995 /* Return value is one of: */
  996 /* #define JPEG_SUSPENDED   0    Suspended due to lack of input data */
  997 #define JPEG_REACHED_SOS    1 /* Reached start of new scan */
  998 #define JPEG_REACHED_EOI    2 /* Reached end of image */
  999 #define JPEG_ROW_COMPLETED  3 /* Completed one iMCU row */
 1000 #define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */
 1001 
 1002 /* Precalculate output dimensions for current decompression parameters. */
 1003 EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
 1004 
 1005 /* Control saving of COM and APPn markers into marker_list. */
 1006 EXTERN(void) jpeg_save_markers
 1007     JPP((j_decompress_ptr cinfo, int marker_code,
 1008          unsigned int length_limit));
 1009 
 1010 /* Install a special processing method for COM or APPn markers. */
 1011 EXTERN(void) jpeg_set_marker_processor
 1012     JPP((j_decompress_ptr cinfo, int marker_code,
 1013          jpeg_marker_parser_method routine));
 1014 
 1015 /* Read or write raw DCT coefficients --- useful for lossless transcoding. */
 1016 EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
 1017 EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
 1018                       jvirt_barray_ptr * coef_arrays));
 1019 EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
 1020                         j_compress_ptr dstinfo));
 1021 
 1022 /* If you choose to abort compression or decompression before completing
 1023  * jpeg_finish_(de)compress, then you need to clean up to release memory,
 1024  * temporary files, etc.  You can just call jpeg_destroy_(de)compress
 1025  * if you're done with the JPEG object, but if you want to clean it up and
 1026  * reuse it, call this:
 1027  */
 1028 EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
 1029 EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
 1030 
 1031 /* Generic versions of jpeg_abort and jpeg_destroy that work on either
 1032  * flavor of JPEG object.  These may be more convenient in some places.
 1033  */
 1034 EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
 1035 EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
 1036 
 1037 /* Default restart-marker-resync procedure for use by data source modules */
 1038 EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
 1039                         int desired));
 1040 
 1041 
 1042 /* These marker codes are exported since applications and data source modules
 1043  * are likely to want to use them.
 1044  */
 1045 
 1046 #define JPEG_RST0   0xD0    /* RST0 marker code */
 1047 #define JPEG_EOI    0xD9    /* EOI marker code */
 1048 #define JPEG_APP0   0xE0    /* APP0 marker code */
 1049 #define JPEG_COM    0xFE    /* COM marker code */
 1050 
 1051 
 1052 /* If we have a brain-damaged compiler that emits warnings (or worse, errors)
 1053  * for structure definitions that are never filled in, keep it quiet by
 1054  * supplying dummy definitions for the various substructures.
 1055  */
 1056 
 1057 #ifdef INCOMPLETE_TYPES_BROKEN
 1058 #ifndef JPEG_INTERNALS      /* will be defined in jpegint.h */
 1059 struct jvirt_sarray_control { long dummy; };
 1060 struct jvirt_barray_control { long dummy; };
 1061 struct jpeg_comp_master { long dummy; };
 1062 struct jpeg_c_main_controller { long dummy; };
 1063 struct jpeg_c_prep_controller { long dummy; };
 1064 struct jpeg_c_coef_controller { long dummy; };
 1065 struct jpeg_marker_writer { long dummy; };
 1066 struct jpeg_color_converter { long dummy; };
 1067 struct jpeg_downsampler { long dummy; };
 1068 struct jpeg_forward_dct { long dummy; };
 1069 struct jpeg_entropy_encoder { long dummy; };
 1070 struct jpeg_decomp_master { long dummy; };
 1071 struct jpeg_d_main_controller { long dummy; };
 1072 struct jpeg_d_coef_controller { long dummy; };
 1073 struct jpeg_d_post_controller { long dummy; };
 1074 struct jpeg_input_controller { long dummy; };
 1075 struct jpeg_marker_reader { long dummy; };
 1076 struct jpeg_entropy_decoder { long dummy; };
 1077 struct jpeg_inverse_dct { long dummy; };
 1078 struct jpeg_upsampler { long dummy; };
 1079 struct jpeg_color_deconverter { long dummy; };
 1080 struct jpeg_color_quantizer { long dummy; };
 1081 #endif /* JPEG_INTERNALS */
 1082 #endif /* INCOMPLETE_TYPES_BROKEN */
 1083 
 1084 
 1085 /*
 1086  * The JPEG library modules define JPEG_INTERNALS before including this file.
 1087  * The internal structure declarations are read only when that is true.
 1088  * Applications using the library should not include jpegint.h, but may wish
 1089  * to include jerror.h.
 1090  */
 1091 
 1092 #ifdef JPEG_INTERNALS
 1093 #include "jpegint.h"        /* fetch private declarations */
 1094 #include "jerror.h"     /* fetch error codes too */
 1095 #endif
 1096 
 1097 #endif /* JPEGLIB_H */