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