1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/libs/libjpeg/jpeglib.h	Thu Sep 08 06:28:38 2011 +0300
     1.3 @@ -0,0 +1,1096 @@
     1.4 +/*
     1.5 + * jpeglib.h
     1.6 + *
     1.7 + * Copyright (C) 1991-1998, Thomas G. Lane.
     1.8 + * This file is part of the Independent JPEG Group's software.
     1.9 + * For conditions of distribution and use, see the accompanying README file.
    1.10 + *
    1.11 + * This file defines the application interface for the JPEG library.
    1.12 + * Most applications using the library need only include this file,
    1.13 + * and perhaps jerror.h if they want to know the exact error codes.
    1.14 + */
    1.15 +
    1.16 +#ifndef JPEGLIB_H
    1.17 +#define JPEGLIB_H
    1.18 +
    1.19 +/*
    1.20 + * First we include the configuration files that record how this
    1.21 + * installation of the JPEG library is set up.  jconfig.h can be
    1.22 + * generated automatically for many systems.  jmorecfg.h contains
    1.23 + * manual configuration options that most people need not worry about.
    1.24 + */
    1.25 +
    1.26 +#ifndef JCONFIG_INCLUDED	/* in case jinclude.h already did */
    1.27 +#include "jconfig.h"		/* widely used configuration options */
    1.28 +#endif
    1.29 +#include "jmorecfg.h"		/* seldom changed options */
    1.30 +
    1.31 +
    1.32 +/* Version ID for the JPEG library.
    1.33 + * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
    1.34 + */
    1.35 +
    1.36 +#define JPEG_LIB_VERSION  62	/* Version 6b */
    1.37 +
    1.38 +
    1.39 +/* Various constants determining the sizes of things.
    1.40 + * All of these are specified by the JPEG standard, so don't change them
    1.41 + * if you want to be compatible.
    1.42 + */
    1.43 +
    1.44 +#define DCTSIZE		    8	/* The basic DCT block is 8x8 samples */
    1.45 +#define DCTSIZE2	    64	/* DCTSIZE squared; # of elements in a block */
    1.46 +#define NUM_QUANT_TBLS      4	/* Quantization tables are numbered 0..3 */
    1.47 +#define NUM_HUFF_TBLS       4	/* Huffman tables are numbered 0..3 */
    1.48 +#define NUM_ARITH_TBLS      16	/* Arith-coding tables are numbered 0..15 */
    1.49 +#define MAX_COMPS_IN_SCAN   4	/* JPEG limit on # of components in one scan */
    1.50 +#define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
    1.51 +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
    1.52 + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
    1.53 + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
    1.54 + * to handle it.  We even let you do this from the jconfig.h file.  However,
    1.55 + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
    1.56 + * sometimes emits noncompliant files doesn't mean you should too.
    1.57 + */
    1.58 +#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
    1.59 +#ifndef D_MAX_BLOCKS_IN_MCU
    1.60 +#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
    1.61 +#endif
    1.62 +
    1.63 +
    1.64 +/* Data structures for images (arrays of samples and of DCT coefficients).
    1.65 + * On 80x86 machines, the image arrays are too big for near pointers,
    1.66 + * but the pointer arrays can fit in near memory.
    1.67 + */
    1.68 +
    1.69 +typedef JSAMPLE FAR *JSAMPROW;	/* ptr to one image row of pixel samples. */
    1.70 +typedef JSAMPROW *JSAMPARRAY;	/* ptr to some rows (a 2-D sample array) */
    1.71 +typedef JSAMPARRAY *JSAMPIMAGE;	/* a 3-D sample array: top index is color */
    1.72 +
    1.73 +typedef JCOEF JBLOCK[DCTSIZE2];	/* one block of coefficients */
    1.74 +typedef JBLOCK FAR *JBLOCKROW;	/* pointer to one row of coefficient blocks */
    1.75 +typedef JBLOCKROW *JBLOCKARRAY;		/* a 2-D array of coefficient blocks */
    1.76 +typedef JBLOCKARRAY *JBLOCKIMAGE;	/* a 3-D array of coefficient blocks */
    1.77 +
    1.78 +typedef JCOEF FAR *JCOEFPTR;	/* useful in a couple of places */
    1.79 +
    1.80 +
    1.81 +/* Types for JPEG compression parameters and working tables. */
    1.82 +
    1.83 +
    1.84 +/* DCT coefficient quantization tables. */
    1.85 +
    1.86 +typedef struct {
    1.87 +  /* This array gives the coefficient quantizers in natural array order
    1.88 +   * (not the zigzag order in which they are stored in a JPEG DQT marker).
    1.89 +   * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
    1.90 +   */
    1.91 +  UINT16 quantval[DCTSIZE2];	/* quantization step for each coefficient */
    1.92 +  /* This field is used only during compression.  It's initialized FALSE when
    1.93 +   * the table is created, and set TRUE when it's been output to the file.
    1.94 +   * You could suppress output of a table by setting this to TRUE.
    1.95 +   * (See jpeg_suppress_tables for an example.)
    1.96 +   */
    1.97 +  boolean sent_table;		/* TRUE when table has been output */
    1.98 +} JQUANT_TBL;
    1.99 +
   1.100 +
   1.101 +/* Huffman coding tables. */
   1.102 +
   1.103 +typedef struct {
   1.104 +  /* These two fields directly represent the contents of a JPEG DHT marker */
   1.105 +  UINT8 bits[17];		/* bits[k] = # of symbols with codes of */
   1.106 +				/* length k bits; bits[0] is unused */
   1.107 +  UINT8 huffval[256];		/* The symbols, in order of incr code length */
   1.108 +  /* This field is used only during compression.  It's initialized FALSE when
   1.109 +   * the table is created, and set TRUE when it's been output to the file.
   1.110 +   * You could suppress output of a table by setting this to TRUE.
   1.111 +   * (See jpeg_suppress_tables for an example.)
   1.112 +   */
   1.113 +  boolean sent_table;		/* TRUE when table has been output */
   1.114 +} JHUFF_TBL;
   1.115 +
   1.116 +
   1.117 +/* Basic info about one component (color channel). */
   1.118 +
   1.119 +typedef struct {
   1.120 +  /* These values are fixed over the whole image. */
   1.121 +  /* For compression, they must be supplied by parameter setup; */
   1.122 +  /* for decompression, they are read from the SOF marker. */
   1.123 +  int component_id;		/* identifier for this component (0..255) */
   1.124 +  int component_index;		/* its index in SOF or cinfo->comp_info[] */
   1.125 +  int h_samp_factor;		/* horizontal sampling factor (1..4) */
   1.126 +  int v_samp_factor;		/* vertical sampling factor (1..4) */
   1.127 +  int quant_tbl_no;		/* quantization table selector (0..3) */
   1.128 +  /* These values may vary between scans. */
   1.129 +  /* For compression, they must be supplied by parameter setup; */
   1.130 +  /* for decompression, they are read from the SOS marker. */
   1.131 +  /* The decompressor output side may not use these variables. */
   1.132 +  int dc_tbl_no;		/* DC entropy table selector (0..3) */
   1.133 +  int ac_tbl_no;		/* AC entropy table selector (0..3) */
   1.134 +  
   1.135 +  /* Remaining fields should be treated as private by applications. */
   1.136 +  
   1.137 +  /* These values are computed during compression or decompression startup: */
   1.138 +  /* Component's size in DCT blocks.
   1.139 +   * Any dummy blocks added to complete an MCU are not counted; therefore
   1.140 +   * these values do not depend on whether a scan is interleaved or not.
   1.141 +   */
   1.142 +  JDIMENSION width_in_blocks;
   1.143 +  JDIMENSION height_in_blocks;
   1.144 +  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
   1.145 +   * For decompression this is the size of the output from one DCT block,
   1.146 +   * reflecting any scaling we choose to apply during the IDCT step.
   1.147 +   * Values of 1,2,4,8 are likely to be supported.  Note that different
   1.148 +   * components may receive different IDCT scalings.
   1.149 +   */
   1.150 +  int DCT_scaled_size;
   1.151 +  /* The downsampled dimensions are the component's actual, unpadded number
   1.152 +   * of samples at the main buffer (preprocessing/compression interface), thus
   1.153 +   * downsampled_width = ceil(image_width * Hi/Hmax)
   1.154 +   * and similarly for height.  For decompression, IDCT scaling is included, so
   1.155 +   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
   1.156 +   */
   1.157 +  JDIMENSION downsampled_width;	 /* actual width in samples */
   1.158 +  JDIMENSION downsampled_height; /* actual height in samples */
   1.159 +  /* This flag is used only for decompression.  In cases where some of the
   1.160 +   * components will be ignored (eg grayscale output from YCbCr image),
   1.161 +   * we can skip most computations for the unused components.
   1.162 +   */
   1.163 +  boolean component_needed;	/* do we need the value of this component? */
   1.164 +
   1.165 +  /* These values are computed before starting a scan of the component. */
   1.166 +  /* The decompressor output side may not use these variables. */
   1.167 +  int MCU_width;		/* number of blocks per MCU, horizontally */
   1.168 +  int MCU_height;		/* number of blocks per MCU, vertically */
   1.169 +  int MCU_blocks;		/* MCU_width * MCU_height */
   1.170 +  int MCU_sample_width;		/* MCU width in samples, MCU_width*DCT_scaled_size */
   1.171 +  int last_col_width;		/* # of non-dummy blocks across in last MCU */
   1.172 +  int last_row_height;		/* # of non-dummy blocks down in last MCU */
   1.173 +
   1.174 +  /* Saved quantization table for component; NULL if none yet saved.
   1.175 +   * See jdinput.c comments about the need for this information.
   1.176 +   * This field is currently used only for decompression.
   1.177 +   */
   1.178 +  JQUANT_TBL * quant_table;
   1.179 +
   1.180 +  /* Private per-component storage for DCT or IDCT subsystem. */
   1.181 +  void * dct_table;
   1.182 +} jpeg_component_info;
   1.183 +
   1.184 +
   1.185 +/* The script for encoding a multiple-scan file is an array of these: */
   1.186 +
   1.187 +typedef struct {
   1.188 +  int comps_in_scan;		/* number of components encoded in this scan */
   1.189 +  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
   1.190 +  int Ss, Se;			/* progressive JPEG spectral selection parms */
   1.191 +  int Ah, Al;			/* progressive JPEG successive approx. parms */
   1.192 +} jpeg_scan_info;
   1.193 +
   1.194 +/* The decompressor can save APPn and COM markers in a list of these: */
   1.195 +
   1.196 +typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
   1.197 +
   1.198 +struct jpeg_marker_struct {
   1.199 +  jpeg_saved_marker_ptr next;	/* next in list, or NULL */
   1.200 +  UINT8 marker;			/* marker code: JPEG_COM, or JPEG_APP0+n */
   1.201 +  unsigned int original_length;	/* # bytes of data in the file */
   1.202 +  unsigned int data_length;	/* # bytes of data saved at data[] */
   1.203 +  JOCTET FAR * data;		/* the data contained in the marker */
   1.204 +  /* the marker length word is not counted in data_length or original_length */
   1.205 +};
   1.206 +
   1.207 +/* Known color spaces. */
   1.208 +
   1.209 +typedef enum {
   1.210 +	JCS_UNKNOWN,		/* error/unspecified */
   1.211 +	JCS_GRAYSCALE,		/* monochrome */
   1.212 +	JCS_RGB,		/* red/green/blue */
   1.213 +	JCS_YCbCr,		/* Y/Cb/Cr (also known as YUV) */
   1.214 +	JCS_CMYK,		/* C/M/Y/K */
   1.215 +	JCS_YCCK		/* Y/Cb/Cr/K */
   1.216 +} J_COLOR_SPACE;
   1.217 +
   1.218 +/* DCT/IDCT algorithm options. */
   1.219 +
   1.220 +typedef enum {
   1.221 +	JDCT_ISLOW,		/* slow but accurate integer algorithm */
   1.222 +	JDCT_IFAST,		/* faster, less accurate integer method */
   1.223 +	JDCT_FLOAT		/* floating-point: accurate, fast on fast HW */
   1.224 +} J_DCT_METHOD;
   1.225 +
   1.226 +#ifndef JDCT_DEFAULT		/* may be overridden in jconfig.h */
   1.227 +#define JDCT_DEFAULT  JDCT_ISLOW
   1.228 +#endif
   1.229 +#ifndef JDCT_FASTEST		/* may be overridden in jconfig.h */
   1.230 +#define JDCT_FASTEST  JDCT_IFAST
   1.231 +#endif
   1.232 +
   1.233 +/* Dithering options for decompression. */
   1.234 +
   1.235 +typedef enum {
   1.236 +	JDITHER_NONE,		/* no dithering */
   1.237 +	JDITHER_ORDERED,	/* simple ordered dither */
   1.238 +	JDITHER_FS		/* Floyd-Steinberg error diffusion dither */
   1.239 +} J_DITHER_MODE;
   1.240 +
   1.241 +
   1.242 +/* Common fields between JPEG compression and decompression master structs. */
   1.243 +
   1.244 +#define jpeg_common_fields \
   1.245 +  struct jpeg_error_mgr * err;	/* Error handler module */\
   1.246 +  struct jpeg_memory_mgr * mem;	/* Memory manager module */\
   1.247 +  struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
   1.248 +  void * client_data;		/* Available for use by application */\
   1.249 +  boolean is_decompressor;	/* So common code can tell which is which */\
   1.250 +  int global_state		/* For checking call sequence validity */
   1.251 +
   1.252 +/* Routines that are to be used by both halves of the library are declared
   1.253 + * to receive a pointer to this structure.  There are no actual instances of
   1.254 + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
   1.255 + */
   1.256 +struct jpeg_common_struct {
   1.257 +  jpeg_common_fields;		/* Fields common to both master struct types */
   1.258 +  /* Additional fields follow in an actual jpeg_compress_struct or
   1.259 +   * jpeg_decompress_struct.  All three structs must agree on these
   1.260 +   * initial fields!  (This would be a lot cleaner in C++.)
   1.261 +   */
   1.262 +};
   1.263 +
   1.264 +typedef struct jpeg_common_struct * j_common_ptr;
   1.265 +typedef struct jpeg_compress_struct * j_compress_ptr;
   1.266 +typedef struct jpeg_decompress_struct * j_decompress_ptr;
   1.267 +
   1.268 +
   1.269 +/* Master record for a compression instance */
   1.270 +
   1.271 +struct jpeg_compress_struct {
   1.272 +  jpeg_common_fields;		/* Fields shared with jpeg_decompress_struct */
   1.273 +
   1.274 +  /* Destination for compressed data */
   1.275 +  struct jpeg_destination_mgr * dest;
   1.276 +
   1.277 +  /* Description of source image --- these fields must be filled in by
   1.278 +   * outer application before starting compression.  in_color_space must
   1.279 +   * be correct before you can even call jpeg_set_defaults().
   1.280 +   */
   1.281 +
   1.282 +  JDIMENSION image_width;	/* input image width */
   1.283 +  JDIMENSION image_height;	/* input image height */
   1.284 +  int input_components;		/* # of color components in input image */
   1.285 +  J_COLOR_SPACE in_color_space;	/* colorspace of input image */
   1.286 +
   1.287 +  double input_gamma;		/* image gamma of input image */
   1.288 +
   1.289 +  /* Compression parameters --- these fields must be set before calling
   1.290 +   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
   1.291 +   * initialize everything to reasonable defaults, then changing anything
   1.292 +   * the application specifically wants to change.  That way you won't get
   1.293 +   * burnt when new parameters are added.  Also note that there are several
   1.294 +   * helper routines to simplify changing parameters.
   1.295 +   */
   1.296 +
   1.297 +  int data_precision;		/* bits of precision in image data */
   1.298 +
   1.299 +  int num_components;		/* # of color components in JPEG image */
   1.300 +  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
   1.301 +
   1.302 +  jpeg_component_info * comp_info;
   1.303 +  /* comp_info[i] describes component that appears i'th in SOF */
   1.304 +  
   1.305 +  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
   1.306 +  /* ptrs to coefficient quantization tables, or NULL if not defined */
   1.307 +  
   1.308 +  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
   1.309 +  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
   1.310 +  /* ptrs to Huffman coding tables, or NULL if not defined */
   1.311 +  
   1.312 +  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
   1.313 +  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
   1.314 +  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
   1.315 +
   1.316 +  int num_scans;		/* # of entries in scan_info array */
   1.317 +  const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
   1.318 +  /* The default value of scan_info is NULL, which causes a single-scan
   1.319 +   * sequential JPEG file to be emitted.  To create a multi-scan file,
   1.320 +   * set num_scans and scan_info to point to an array of scan definitions.
   1.321 +   */
   1.322 +
   1.323 +  boolean raw_data_in;		/* TRUE=caller supplies downsampled data */
   1.324 +  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
   1.325 +  boolean optimize_coding;	/* TRUE=optimize entropy encoding parms */
   1.326 +  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
   1.327 +  int smoothing_factor;		/* 1..100, or 0 for no input smoothing */
   1.328 +  J_DCT_METHOD dct_method;	/* DCT algorithm selector */
   1.329 +
   1.330 +  /* The restart interval can be specified in absolute MCUs by setting
   1.331 +   * restart_interval, or in MCU rows by setting restart_in_rows
   1.332 +   * (in which case the correct restart_interval will be figured
   1.333 +   * for each scan).
   1.334 +   */
   1.335 +  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
   1.336 +  int restart_in_rows;		/* if > 0, MCU rows per restart interval */
   1.337 +
   1.338 +  /* Parameters controlling emission of special markers. */
   1.339 +
   1.340 +  boolean write_JFIF_header;	/* should a JFIF marker be written? */
   1.341 +  UINT8 JFIF_major_version;	/* What to write for the JFIF version number */
   1.342 +  UINT8 JFIF_minor_version;
   1.343 +  /* These three values are not used by the JPEG code, merely copied */
   1.344 +  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
   1.345 +  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
   1.346 +  /* ratio is defined by X_density/Y_density even when density_unit=0. */
   1.347 +  UINT8 density_unit;		/* JFIF code for pixel size units */
   1.348 +  UINT16 X_density;		/* Horizontal pixel density */
   1.349 +  UINT16 Y_density;		/* Vertical pixel density */
   1.350 +  boolean write_Adobe_marker;	/* should an Adobe marker be written? */
   1.351 +  
   1.352 +  /* State variable: index of next scanline to be written to
   1.353 +   * jpeg_write_scanlines().  Application may use this to control its
   1.354 +   * processing loop, e.g., "while (next_scanline < image_height)".
   1.355 +   */
   1.356 +
   1.357 +  JDIMENSION next_scanline;	/* 0 .. image_height-1  */
   1.358 +
   1.359 +  /* Remaining fields are known throughout compressor, but generally
   1.360 +   * should not be touched by a surrounding application.
   1.361 +   */
   1.362 +
   1.363 +  /*
   1.364 +   * These fields are computed during compression startup
   1.365 +   */
   1.366 +  boolean progressive_mode;	/* TRUE if scan script uses progressive mode */
   1.367 +  int max_h_samp_factor;	/* largest h_samp_factor */
   1.368 +  int max_v_samp_factor;	/* largest v_samp_factor */
   1.369 +
   1.370 +  JDIMENSION total_iMCU_rows;	/* # of iMCU rows to be input to coef ctlr */
   1.371 +  /* The coefficient controller receives data in units of MCU rows as defined
   1.372 +   * for fully interleaved scans (whether the JPEG file is interleaved or not).
   1.373 +   * There are v_samp_factor * DCTSIZE sample rows of each component in an
   1.374 +   * "iMCU" (interleaved MCU) row.
   1.375 +   */
   1.376 +  
   1.377 +  /*
   1.378 +   * These fields are valid during any one scan.
   1.379 +   * They describe the components and MCUs actually appearing in the scan.
   1.380 +   */
   1.381 +  int comps_in_scan;		/* # of JPEG components in this scan */
   1.382 +  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
   1.383 +  /* *cur_comp_info[i] describes component that appears i'th in SOS */
   1.384 +  
   1.385 +  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
   1.386 +  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
   1.387 +  
   1.388 +  int blocks_in_MCU;		/* # of DCT blocks per MCU */
   1.389 +  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
   1.390 +  /* MCU_membership[i] is index in cur_comp_info of component owning */
   1.391 +  /* i'th block in an MCU */
   1.392 +
   1.393 +  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
   1.394 +
   1.395 +  /*
   1.396 +   * Links to compression subobjects (methods and private variables of modules)
   1.397 +   */
   1.398 +  struct jpeg_comp_master * master;
   1.399 +  struct jpeg_c_main_controller * main;
   1.400 +  struct jpeg_c_prep_controller * prep;
   1.401 +  struct jpeg_c_coef_controller * coef;
   1.402 +  struct jpeg_marker_writer * marker;
   1.403 +  struct jpeg_color_converter * cconvert;
   1.404 +  struct jpeg_downsampler * downsample;
   1.405 +  struct jpeg_forward_dct * fdct;
   1.406 +  struct jpeg_entropy_encoder * entropy;
   1.407 +  jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
   1.408 +  int script_space_size;
   1.409 +};
   1.410 +
   1.411 +
   1.412 +/* Master record for a decompression instance */
   1.413 +
   1.414 +struct jpeg_decompress_struct {
   1.415 +  jpeg_common_fields;		/* Fields shared with jpeg_compress_struct */
   1.416 +
   1.417 +  /* Source of compressed data */
   1.418 +  struct jpeg_source_mgr * src;
   1.419 +
   1.420 +  /* Basic description of image --- filled in by jpeg_read_header(). */
   1.421 +  /* Application may inspect these values to decide how to process image. */
   1.422 +
   1.423 +  JDIMENSION image_width;	/* nominal image width (from SOF marker) */
   1.424 +  JDIMENSION image_height;	/* nominal image height */
   1.425 +  int num_components;		/* # of color components in JPEG image */
   1.426 +  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
   1.427 +
   1.428 +  /* Decompression processing parameters --- these fields must be set before
   1.429 +   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
   1.430 +   * them to default values.
   1.431 +   */
   1.432 +
   1.433 +  J_COLOR_SPACE out_color_space; /* colorspace for output */
   1.434 +
   1.435 +  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
   1.436 +
   1.437 +  double output_gamma;		/* image gamma wanted in output */
   1.438 +
   1.439 +  boolean buffered_image;	/* TRUE=multiple output passes */
   1.440 +  boolean raw_data_out;		/* TRUE=downsampled data wanted */
   1.441 +
   1.442 +  J_DCT_METHOD dct_method;	/* IDCT algorithm selector */
   1.443 +  boolean do_fancy_upsampling;	/* TRUE=apply fancy upsampling */
   1.444 +  boolean do_block_smoothing;	/* TRUE=apply interblock smoothing */
   1.445 +
   1.446 +  boolean quantize_colors;	/* TRUE=colormapped output wanted */
   1.447 +  /* the following are ignored if not quantize_colors: */
   1.448 +  J_DITHER_MODE dither_mode;	/* type of color dithering to use */
   1.449 +  boolean two_pass_quantize;	/* TRUE=use two-pass color quantization */
   1.450 +  int desired_number_of_colors;	/* max # colors to use in created colormap */
   1.451 +  /* these are significant only in buffered-image mode: */
   1.452 +  boolean enable_1pass_quant;	/* enable future use of 1-pass quantizer */
   1.453 +  boolean enable_external_quant;/* enable future use of external colormap */
   1.454 +  boolean enable_2pass_quant;	/* enable future use of 2-pass quantizer */
   1.455 +
   1.456 +  /* Description of actual output image that will be returned to application.
   1.457 +   * These fields are computed by jpeg_start_decompress().
   1.458 +   * You can also use jpeg_calc_output_dimensions() to determine these values
   1.459 +   * in advance of calling jpeg_start_decompress().
   1.460 +   */
   1.461 +
   1.462 +  JDIMENSION output_width;	/* scaled image width */
   1.463 +  JDIMENSION output_height;	/* scaled image height */
   1.464 +  int out_color_components;	/* # of color components in out_color_space */
   1.465 +  int output_components;	/* # of color components returned */
   1.466 +  /* output_components is 1 (a colormap index) when quantizing colors;
   1.467 +   * otherwise it equals out_color_components.
   1.468 +   */
   1.469 +  int rec_outbuf_height;	/* min recommended height of scanline buffer */
   1.470 +  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
   1.471 +   * high, space and time will be wasted due to unnecessary data copying.
   1.472 +   * Usually rec_outbuf_height will be 1 or 2, at most 4.
   1.473 +   */
   1.474 +
   1.475 +  /* When quantizing colors, the output colormap is described by these fields.
   1.476 +   * The application can supply a colormap by setting colormap non-NULL before
   1.477 +   * calling jpeg_start_decompress; otherwise a colormap is created during
   1.478 +   * jpeg_start_decompress or jpeg_start_output.
   1.479 +   * The map has out_color_components rows and actual_number_of_colors columns.
   1.480 +   */
   1.481 +  int actual_number_of_colors;	/* number of entries in use */
   1.482 +  JSAMPARRAY colormap;		/* The color map as a 2-D pixel array */
   1.483 +
   1.484 +  /* State variables: these variables indicate the progress of decompression.
   1.485 +   * The application may examine these but must not modify them.
   1.486 +   */
   1.487 +
   1.488 +  /* Row index of next scanline to be read from jpeg_read_scanlines().
   1.489 +   * Application may use this to control its processing loop, e.g.,
   1.490 +   * "while (output_scanline < output_height)".
   1.491 +   */
   1.492 +  JDIMENSION output_scanline;	/* 0 .. output_height-1  */
   1.493 +
   1.494 +  /* Current input scan number and number of iMCU rows completed in scan.
   1.495 +   * These indicate the progress of the decompressor input side.
   1.496 +   */
   1.497 +  int input_scan_number;	/* Number of SOS markers seen so far */
   1.498 +  JDIMENSION input_iMCU_row;	/* Number of iMCU rows completed */
   1.499 +
   1.500 +  /* The "output scan number" is the notional scan being displayed by the
   1.501 +   * output side.  The decompressor will not allow output scan/row number
   1.502 +   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
   1.503 +   */
   1.504 +  int output_scan_number;	/* Nominal scan number being displayed */
   1.505 +  JDIMENSION output_iMCU_row;	/* Number of iMCU rows read */
   1.506 +
   1.507 +  /* Current progression status.  coef_bits[c][i] indicates the precision
   1.508 +   * with which component c's DCT coefficient i (in zigzag order) is known.
   1.509 +   * It is -1 when no data has yet been received, otherwise it is the point
   1.510 +   * transform (shift) value for the most recent scan of the coefficient
   1.511 +   * (thus, 0 at completion of the progression).
   1.512 +   * This pointer is NULL when reading a non-progressive file.
   1.513 +   */
   1.514 +  int (*coef_bits)[DCTSIZE2];	/* -1 or current Al value for each coef */
   1.515 +
   1.516 +  /* Internal JPEG parameters --- the application usually need not look at
   1.517 +   * these fields.  Note that the decompressor output side may not use
   1.518 +   * any parameters that can change between scans.
   1.519 +   */
   1.520 +
   1.521 +  /* Quantization and Huffman tables are carried forward across input
   1.522 +   * datastreams when processing abbreviated JPEG datastreams.
   1.523 +   */
   1.524 +
   1.525 +  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
   1.526 +  /* ptrs to coefficient quantization tables, or NULL if not defined */
   1.527 +
   1.528 +  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
   1.529 +  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
   1.530 +  /* ptrs to Huffman coding tables, or NULL if not defined */
   1.531 +
   1.532 +  /* These parameters are never carried across datastreams, since they
   1.533 +   * are given in SOF/SOS markers or defined to be reset by SOI.
   1.534 +   */
   1.535 +
   1.536 +  int data_precision;		/* bits of precision in image data */
   1.537 +
   1.538 +  jpeg_component_info * comp_info;
   1.539 +  /* comp_info[i] describes component that appears i'th in SOF */
   1.540 +
   1.541 +  boolean progressive_mode;	/* TRUE if SOFn specifies progressive mode */
   1.542 +  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
   1.543 +
   1.544 +  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
   1.545 +  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
   1.546 +  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
   1.547 +
   1.548 +  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
   1.549 +
   1.550 +  /* These fields record data obtained from optional markers recognized by
   1.551 +   * the JPEG library.
   1.552 +   */
   1.553 +  boolean saw_JFIF_marker;	/* TRUE iff a JFIF APP0 marker was found */
   1.554 +  /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
   1.555 +  UINT8 JFIF_major_version;	/* JFIF version number */
   1.556 +  UINT8 JFIF_minor_version;
   1.557 +  UINT8 density_unit;		/* JFIF code for pixel size units */
   1.558 +  UINT16 X_density;		/* Horizontal pixel density */
   1.559 +  UINT16 Y_density;		/* Vertical pixel density */
   1.560 +  boolean saw_Adobe_marker;	/* TRUE iff an Adobe APP14 marker was found */
   1.561 +  UINT8 Adobe_transform;	/* Color transform code from Adobe marker */
   1.562 +
   1.563 +  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
   1.564 +
   1.565 +  /* Aside from the specific data retained from APPn markers known to the
   1.566 +   * library, the uninterpreted contents of any or all APPn and COM markers
   1.567 +   * can be saved in a list for examination by the application.
   1.568 +   */
   1.569 +  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
   1.570 +
   1.571 +  /* Remaining fields are known throughout decompressor, but generally
   1.572 +   * should not be touched by a surrounding application.
   1.573 +   */
   1.574 +
   1.575 +  /*
   1.576 +   * These fields are computed during decompression startup
   1.577 +   */
   1.578 +  int max_h_samp_factor;	/* largest h_samp_factor */
   1.579 +  int max_v_samp_factor;	/* largest v_samp_factor */
   1.580 +
   1.581 +  int min_DCT_scaled_size;	/* smallest DCT_scaled_size of any component */
   1.582 +
   1.583 +  JDIMENSION total_iMCU_rows;	/* # of iMCU rows in image */
   1.584 +  /* The coefficient controller's input and output progress is measured in
   1.585 +   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
   1.586 +   * in fully interleaved JPEG scans, but are used whether the scan is
   1.587 +   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
   1.588 +   * rows of each component.  Therefore, the IDCT output contains
   1.589 +   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
   1.590 +   */
   1.591 +
   1.592 +  JSAMPLE * sample_range_limit; /* table for fast range-limiting */
   1.593 +
   1.594 +  /*
   1.595 +   * These fields are valid during any one scan.
   1.596 +   * They describe the components and MCUs actually appearing in the scan.
   1.597 +   * Note that the decompressor output side must not use these fields.
   1.598 +   */
   1.599 +  int comps_in_scan;		/* # of JPEG components in this scan */
   1.600 +  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
   1.601 +  /* *cur_comp_info[i] describes component that appears i'th in SOS */
   1.602 +
   1.603 +  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
   1.604 +  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
   1.605 +
   1.606 +  int blocks_in_MCU;		/* # of DCT blocks per MCU */
   1.607 +  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
   1.608 +  /* MCU_membership[i] is index in cur_comp_info of component owning */
   1.609 +  /* i'th block in an MCU */
   1.610 +
   1.611 +  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
   1.612 +
   1.613 +  /* This field is shared between entropy decoder and marker parser.
   1.614 +   * It is either zero or the code of a JPEG marker that has been
   1.615 +   * read from the data source, but has not yet been processed.
   1.616 +   */
   1.617 +  int unread_marker;
   1.618 +
   1.619 +  /*
   1.620 +   * Links to decompression subobjects (methods, private variables of modules)
   1.621 +   */
   1.622 +  struct jpeg_decomp_master * master;
   1.623 +  struct jpeg_d_main_controller * main;
   1.624 +  struct jpeg_d_coef_controller * coef;
   1.625 +  struct jpeg_d_post_controller * post;
   1.626 +  struct jpeg_input_controller * inputctl;
   1.627 +  struct jpeg_marker_reader * marker;
   1.628 +  struct jpeg_entropy_decoder * entropy;
   1.629 +  struct jpeg_inverse_dct * idct;
   1.630 +  struct jpeg_upsampler * upsample;
   1.631 +  struct jpeg_color_deconverter * cconvert;
   1.632 +  struct jpeg_color_quantizer * cquantize;
   1.633 +};
   1.634 +
   1.635 +
   1.636 +/* "Object" declarations for JPEG modules that may be supplied or called
   1.637 + * directly by the surrounding application.
   1.638 + * As with all objects in the JPEG library, these structs only define the
   1.639 + * publicly visible methods and state variables of a module.  Additional
   1.640 + * private fields may exist after the public ones.
   1.641 + */
   1.642 +
   1.643 +
   1.644 +/* Error handler object */
   1.645 +
   1.646 +struct jpeg_error_mgr {
   1.647 +  /* Error exit handler: does not return to caller */
   1.648 +  JMETHOD(void, error_exit, (j_common_ptr cinfo));
   1.649 +  /* Conditionally emit a trace or warning message */
   1.650 +  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
   1.651 +  /* Routine that actually outputs a trace or error message */
   1.652 +  JMETHOD(void, output_message, (j_common_ptr cinfo));
   1.653 +  /* Format a message string for the most recent JPEG error or message */
   1.654 +  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
   1.655 +#define JMSG_LENGTH_MAX  200	/* recommended size of format_message buffer */
   1.656 +  /* Reset error state variables at start of a new image */
   1.657 +  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
   1.658 +  
   1.659 +  /* The message ID code and any parameters are saved here.
   1.660 +   * A message can have one string parameter or up to 8 int parameters.
   1.661 +   */
   1.662 +  int msg_code;
   1.663 +#define JMSG_STR_PARM_MAX  80
   1.664 +  union {
   1.665 +    int i[8];
   1.666 +    char s[JMSG_STR_PARM_MAX];
   1.667 +  } msg_parm;
   1.668 +  
   1.669 +  /* Standard state variables for error facility */
   1.670 +  
   1.671 +  int trace_level;		/* max msg_level that will be displayed */
   1.672 +  
   1.673 +  /* For recoverable corrupt-data errors, we emit a warning message,
   1.674 +   * but keep going unless emit_message chooses to abort.  emit_message
   1.675 +   * should count warnings in num_warnings.  The surrounding application
   1.676 +   * can check for bad data by seeing if num_warnings is nonzero at the
   1.677 +   * end of processing.
   1.678 +   */
   1.679 +  long num_warnings;		/* number of corrupt-data warnings */
   1.680 +
   1.681 +  /* These fields point to the table(s) of error message strings.
   1.682 +   * An application can change the table pointer to switch to a different
   1.683 +   * message list (typically, to change the language in which errors are
   1.684 +   * reported).  Some applications may wish to add additional error codes
   1.685 +   * that will be handled by the JPEG library error mechanism; the second
   1.686 +   * table pointer is used for this purpose.
   1.687 +   *
   1.688 +   * First table includes all errors generated by JPEG library itself.
   1.689 +   * Error code 0 is reserved for a "no such error string" message.
   1.690 +   */
   1.691 +  const char * const * jpeg_message_table; /* Library errors */
   1.692 +  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
   1.693 +  /* Second table can be added by application (see cjpeg/djpeg for example).
   1.694 +   * It contains strings numbered first_addon_message..last_addon_message.
   1.695 +   */
   1.696 +  const char * const * addon_message_table; /* Non-library errors */
   1.697 +  int first_addon_message;	/* code for first string in addon table */
   1.698 +  int last_addon_message;	/* code for last string in addon table */
   1.699 +};
   1.700 +
   1.701 +
   1.702 +/* Progress monitor object */
   1.703 +
   1.704 +struct jpeg_progress_mgr {
   1.705 +  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
   1.706 +
   1.707 +  long pass_counter;		/* work units completed in this pass */
   1.708 +  long pass_limit;		/* total number of work units in this pass */
   1.709 +  int completed_passes;		/* passes completed so far */
   1.710 +  int total_passes;		/* total number of passes expected */
   1.711 +};
   1.712 +
   1.713 +
   1.714 +/* Data destination object for compression */
   1.715 +
   1.716 +struct jpeg_destination_mgr {
   1.717 +  JOCTET * next_output_byte;	/* => next byte to write in buffer */
   1.718 +  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
   1.719 +
   1.720 +  JMETHOD(void, init_destination, (j_compress_ptr cinfo));
   1.721 +  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
   1.722 +  JMETHOD(void, term_destination, (j_compress_ptr cinfo));
   1.723 +};
   1.724 +
   1.725 +
   1.726 +/* Data source object for decompression */
   1.727 +
   1.728 +struct jpeg_source_mgr {
   1.729 +  const JOCTET * next_input_byte; /* => next byte to read from buffer */
   1.730 +  size_t bytes_in_buffer;	/* # of bytes remaining in buffer */
   1.731 +
   1.732 +  JMETHOD(void, init_source, (j_decompress_ptr cinfo));
   1.733 +  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
   1.734 +  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
   1.735 +  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
   1.736 +  JMETHOD(void, term_source, (j_decompress_ptr cinfo));
   1.737 +};
   1.738 +
   1.739 +
   1.740 +/* Memory manager object.
   1.741 + * Allocates "small" objects (a few K total), "large" objects (tens of K),
   1.742 + * and "really big" objects (virtual arrays with backing store if needed).
   1.743 + * The memory manager does not allow individual objects to be freed; rather,
   1.744 + * each created object is assigned to a pool, and whole pools can be freed
   1.745 + * at once.  This is faster and more convenient than remembering exactly what
   1.746 + * to free, especially where malloc()/free() are not too speedy.
   1.747 + * NB: alloc routines never return NULL.  They exit to error_exit if not
   1.748 + * successful.
   1.749 + */
   1.750 +
   1.751 +#define JPOOL_PERMANENT	0	/* lasts until master record is destroyed */
   1.752 +#define JPOOL_IMAGE	1	/* lasts until done with image/datastream */
   1.753 +#define JPOOL_NUMPOOLS	2
   1.754 +
   1.755 +typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
   1.756 +typedef struct jvirt_barray_control * jvirt_barray_ptr;
   1.757 +
   1.758 +
   1.759 +struct jpeg_memory_mgr {
   1.760 +  /* Method pointers */
   1.761 +  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
   1.762 +				size_t sizeofobject));
   1.763 +  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
   1.764 +				     size_t sizeofobject));
   1.765 +  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
   1.766 +				     JDIMENSION samplesperrow,
   1.767 +				     JDIMENSION numrows));
   1.768 +  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
   1.769 +				      JDIMENSION blocksperrow,
   1.770 +				      JDIMENSION numrows));
   1.771 +  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
   1.772 +						  int pool_id,
   1.773 +						  boolean pre_zero,
   1.774 +						  JDIMENSION samplesperrow,
   1.775 +						  JDIMENSION numrows,
   1.776 +						  JDIMENSION maxaccess));
   1.777 +  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
   1.778 +						  int pool_id,
   1.779 +						  boolean pre_zero,
   1.780 +						  JDIMENSION blocksperrow,
   1.781 +						  JDIMENSION numrows,
   1.782 +						  JDIMENSION maxaccess));
   1.783 +  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
   1.784 +  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
   1.785 +					   jvirt_sarray_ptr ptr,
   1.786 +					   JDIMENSION start_row,
   1.787 +					   JDIMENSION num_rows,
   1.788 +					   boolean writable));
   1.789 +  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
   1.790 +					    jvirt_barray_ptr ptr,
   1.791 +					    JDIMENSION start_row,
   1.792 +					    JDIMENSION num_rows,
   1.793 +					    boolean writable));
   1.794 +  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
   1.795 +  JMETHOD(void, self_destruct, (j_common_ptr cinfo));
   1.796 +
   1.797 +  /* Limit on memory allocation for this JPEG object.  (Note that this is
   1.798 +   * merely advisory, not a guaranteed maximum; it only affects the space
   1.799 +   * used for virtual-array buffers.)  May be changed by outer application
   1.800 +   * after creating the JPEG object.
   1.801 +   */
   1.802 +  long max_memory_to_use;
   1.803 +
   1.804 +  /* Maximum allocation request accepted by alloc_large. */
   1.805 +  long max_alloc_chunk;
   1.806 +};
   1.807 +
   1.808 +
   1.809 +/* Routine signature for application-supplied marker processing methods.
   1.810 + * Need not pass marker code since it is stored in cinfo->unread_marker.
   1.811 + */
   1.812 +typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
   1.813 +
   1.814 +
   1.815 +/* Declarations for routines called by application.
   1.816 + * The JPP macro hides prototype parameters from compilers that can't cope.
   1.817 + * Note JPP requires double parentheses.
   1.818 + */
   1.819 +
   1.820 +#ifdef HAVE_PROTOTYPES
   1.821 +#define JPP(arglist)	arglist
   1.822 +#else
   1.823 +#define JPP(arglist)	()
   1.824 +#endif
   1.825 +
   1.826 +
   1.827 +/* Short forms of external names for systems with brain-damaged linkers.
   1.828 + * We shorten external names to be unique in the first six letters, which
   1.829 + * is good enough for all known systems.
   1.830 + * (If your compiler itself needs names to be unique in less than 15 
   1.831 + * characters, you are out of luck.  Get a better compiler.)
   1.832 + */
   1.833 +
   1.834 +#ifdef NEED_SHORT_EXTERNAL_NAMES
   1.835 +#define jpeg_std_error		jStdError
   1.836 +#define jpeg_CreateCompress	jCreaCompress
   1.837 +#define jpeg_CreateDecompress	jCreaDecompress
   1.838 +#define jpeg_destroy_compress	jDestCompress
   1.839 +#define jpeg_destroy_decompress	jDestDecompress
   1.840 +#define jpeg_stdio_dest		jStdDest
   1.841 +#define jpeg_stdio_src		jStdSrc
   1.842 +#define jpeg_set_defaults	jSetDefaults
   1.843 +#define jpeg_set_colorspace	jSetColorspace
   1.844 +#define jpeg_default_colorspace	jDefColorspace
   1.845 +#define jpeg_set_quality	jSetQuality
   1.846 +#define jpeg_set_linear_quality	jSetLQuality
   1.847 +#define jpeg_add_quant_table	jAddQuantTable
   1.848 +#define jpeg_quality_scaling	jQualityScaling
   1.849 +#define jpeg_simple_progression	jSimProgress
   1.850 +#define jpeg_suppress_tables	jSuppressTables
   1.851 +#define jpeg_alloc_quant_table	jAlcQTable
   1.852 +#define jpeg_alloc_huff_table	jAlcHTable
   1.853 +#define jpeg_start_compress	jStrtCompress
   1.854 +#define jpeg_write_scanlines	jWrtScanlines
   1.855 +#define jpeg_finish_compress	jFinCompress
   1.856 +#define jpeg_write_raw_data	jWrtRawData
   1.857 +#define jpeg_write_marker	jWrtMarker
   1.858 +#define jpeg_write_m_header	jWrtMHeader
   1.859 +#define jpeg_write_m_byte	jWrtMByte
   1.860 +#define jpeg_write_tables	jWrtTables
   1.861 +#define jpeg_read_header	jReadHeader
   1.862 +#define jpeg_start_decompress	jStrtDecompress
   1.863 +#define jpeg_read_scanlines	jReadScanlines
   1.864 +#define jpeg_finish_decompress	jFinDecompress
   1.865 +#define jpeg_read_raw_data	jReadRawData
   1.866 +#define jpeg_has_multiple_scans	jHasMultScn
   1.867 +#define jpeg_start_output	jStrtOutput
   1.868 +#define jpeg_finish_output	jFinOutput
   1.869 +#define jpeg_input_complete	jInComplete
   1.870 +#define jpeg_new_colormap	jNewCMap
   1.871 +#define jpeg_consume_input	jConsumeInput
   1.872 +#define jpeg_calc_output_dimensions	jCalcDimensions
   1.873 +#define jpeg_save_markers	jSaveMarkers
   1.874 +#define jpeg_set_marker_processor	jSetMarker
   1.875 +#define jpeg_read_coefficients	jReadCoefs
   1.876 +#define jpeg_write_coefficients	jWrtCoefs
   1.877 +#define jpeg_copy_critical_parameters	jCopyCrit
   1.878 +#define jpeg_abort_compress	jAbrtCompress
   1.879 +#define jpeg_abort_decompress	jAbrtDecompress
   1.880 +#define jpeg_abort		jAbort
   1.881 +#define jpeg_destroy		jDestroy
   1.882 +#define jpeg_resync_to_restart	jResyncRestart
   1.883 +#endif /* NEED_SHORT_EXTERNAL_NAMES */
   1.884 +
   1.885 +
   1.886 +/* Default error-management setup */
   1.887 +EXTERN(struct jpeg_error_mgr *) jpeg_std_error
   1.888 +	JPP((struct jpeg_error_mgr * err));
   1.889 +
   1.890 +/* Initialization of JPEG compression objects.
   1.891 + * jpeg_create_compress() and jpeg_create_decompress() are the exported
   1.892 + * names that applications should call.  These expand to calls on
   1.893 + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
   1.894 + * passed for version mismatch checking.
   1.895 + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
   1.896 + */
   1.897 +#define jpeg_create_compress(cinfo) \
   1.898 +    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
   1.899 +			(size_t) sizeof(struct jpeg_compress_struct))
   1.900 +#define jpeg_create_decompress(cinfo) \
   1.901 +    jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
   1.902 +			  (size_t) sizeof(struct jpeg_decompress_struct))
   1.903 +EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
   1.904 +				      int version, size_t structsize));
   1.905 +EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
   1.906 +					int version, size_t structsize));
   1.907 +/* Destruction of JPEG compression objects */
   1.908 +EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
   1.909 +EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
   1.910 +
   1.911 +/* Standard data source and destination managers: stdio streams. */
   1.912 +/* Caller is responsible for opening the file before and closing after. */
   1.913 +EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
   1.914 +EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
   1.915 +
   1.916 +/* Default parameter setup for compression */
   1.917 +EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
   1.918 +/* Compression parameter setup aids */
   1.919 +EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
   1.920 +				      J_COLOR_SPACE colorspace));
   1.921 +EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
   1.922 +EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
   1.923 +				   boolean force_baseline));
   1.924 +EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
   1.925 +					  int scale_factor,
   1.926 +					  boolean force_baseline));
   1.927 +EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
   1.928 +				       const unsigned int *basic_table,
   1.929 +				       int scale_factor,
   1.930 +				       boolean force_baseline));
   1.931 +EXTERN(int) jpeg_quality_scaling JPP((int quality));
   1.932 +EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
   1.933 +EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
   1.934 +				       boolean suppress));
   1.935 +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
   1.936 +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
   1.937 +
   1.938 +/* Main entry points for compression */
   1.939 +EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
   1.940 +				      boolean write_all_tables));
   1.941 +EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
   1.942 +					     JSAMPARRAY scanlines,
   1.943 +					     JDIMENSION num_lines));
   1.944 +EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
   1.945 +
   1.946 +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
   1.947 +EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
   1.948 +					    JSAMPIMAGE data,
   1.949 +					    JDIMENSION num_lines));
   1.950 +
   1.951 +/* Write a special marker.  See libjpeg.doc concerning safe usage. */
   1.952 +EXTERN(void) jpeg_write_marker
   1.953 +	JPP((j_compress_ptr cinfo, int marker,
   1.954 +	     const JOCTET * dataptr, unsigned int datalen));
   1.955 +/* Same, but piecemeal. */
   1.956 +EXTERN(void) jpeg_write_m_header
   1.957 +	JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
   1.958 +EXTERN(void) jpeg_write_m_byte
   1.959 +	JPP((j_compress_ptr cinfo, int val));
   1.960 +
   1.961 +/* Alternate compression function: just write an abbreviated table file */
   1.962 +EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
   1.963 +
   1.964 +/* Decompression startup: read start of JPEG datastream to see what's there */
   1.965 +EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
   1.966 +				  boolean require_image));
   1.967 +/* Return value is one of: */
   1.968 +#define JPEG_SUSPENDED		0 /* Suspended due to lack of input data */
   1.969 +#define JPEG_HEADER_OK		1 /* Found valid image datastream */
   1.970 +#define JPEG_HEADER_TABLES_ONLY	2 /* Found valid table-specs-only datastream */
   1.971 +/* If you pass require_image = TRUE (normal case), you need not check for
   1.972 + * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
   1.973 + * JPEG_SUSPENDED is only possible if you use a data source module that can
   1.974 + * give a suspension return (the stdio source module doesn't).
   1.975 + */
   1.976 +
   1.977 +/* Main entry points for decompression */
   1.978 +EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
   1.979 +EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
   1.980 +					    JSAMPARRAY scanlines,
   1.981 +					    JDIMENSION max_lines));
   1.982 +EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
   1.983 +
   1.984 +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
   1.985 +EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
   1.986 +					   JSAMPIMAGE data,
   1.987 +					   JDIMENSION max_lines));
   1.988 +
   1.989 +/* Additional entry points for buffered-image mode. */
   1.990 +EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
   1.991 +EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
   1.992 +				       int scan_number));
   1.993 +EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
   1.994 +EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
   1.995 +EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
   1.996 +EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
   1.997 +/* Return value is one of: */
   1.998 +/* #define JPEG_SUSPENDED	0    Suspended due to lack of input data */
   1.999 +#define JPEG_REACHED_SOS	1 /* Reached start of new scan */
  1.1000 +#define JPEG_REACHED_EOI	2 /* Reached end of image */
  1.1001 +#define JPEG_ROW_COMPLETED	3 /* Completed one iMCU row */
  1.1002 +#define JPEG_SCAN_COMPLETED	4 /* Completed last iMCU row of a scan */
  1.1003 +
  1.1004 +/* Precalculate output dimensions for current decompression parameters. */
  1.1005 +EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
  1.1006 +
  1.1007 +/* Control saving of COM and APPn markers into marker_list. */
  1.1008 +EXTERN(void) jpeg_save_markers
  1.1009 +	JPP((j_decompress_ptr cinfo, int marker_code,
  1.1010 +	     unsigned int length_limit));
  1.1011 +
  1.1012 +/* Install a special processing method for COM or APPn markers. */
  1.1013 +EXTERN(void) jpeg_set_marker_processor
  1.1014 +	JPP((j_decompress_ptr cinfo, int marker_code,
  1.1015 +	     jpeg_marker_parser_method routine));
  1.1016 +
  1.1017 +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
  1.1018 +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
  1.1019 +EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
  1.1020 +					  jvirt_barray_ptr * coef_arrays));
  1.1021 +EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
  1.1022 +						j_compress_ptr dstinfo));
  1.1023 +
  1.1024 +/* If you choose to abort compression or decompression before completing
  1.1025 + * jpeg_finish_(de)compress, then you need to clean up to release memory,
  1.1026 + * temporary files, etc.  You can just call jpeg_destroy_(de)compress
  1.1027 + * if you're done with the JPEG object, but if you want to clean it up and
  1.1028 + * reuse it, call this:
  1.1029 + */
  1.1030 +EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
  1.1031 +EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
  1.1032 +
  1.1033 +/* Generic versions of jpeg_abort and jpeg_destroy that work on either
  1.1034 + * flavor of JPEG object.  These may be more convenient in some places.
  1.1035 + */
  1.1036 +EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
  1.1037 +EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
  1.1038 +
  1.1039 +/* Default restart-marker-resync procedure for use by data source modules */
  1.1040 +EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
  1.1041 +					    int desired));
  1.1042 +
  1.1043 +
  1.1044 +/* These marker codes are exported since applications and data source modules
  1.1045 + * are likely to want to use them.
  1.1046 + */
  1.1047 +
  1.1048 +#define JPEG_RST0	0xD0	/* RST0 marker code */
  1.1049 +#define JPEG_EOI	0xD9	/* EOI marker code */
  1.1050 +#define JPEG_APP0	0xE0	/* APP0 marker code */
  1.1051 +#define JPEG_COM	0xFE	/* COM marker code */
  1.1052 +
  1.1053 +
  1.1054 +/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
  1.1055 + * for structure definitions that are never filled in, keep it quiet by
  1.1056 + * supplying dummy definitions for the various substructures.
  1.1057 + */
  1.1058 +
  1.1059 +#ifdef INCOMPLETE_TYPES_BROKEN
  1.1060 +#ifndef JPEG_INTERNALS		/* will be defined in jpegint.h */
  1.1061 +struct jvirt_sarray_control { long dummy; };
  1.1062 +struct jvirt_barray_control { long dummy; };
  1.1063 +struct jpeg_comp_master { long dummy; };
  1.1064 +struct jpeg_c_main_controller { long dummy; };
  1.1065 +struct jpeg_c_prep_controller { long dummy; };
  1.1066 +struct jpeg_c_coef_controller { long dummy; };
  1.1067 +struct jpeg_marker_writer { long dummy; };
  1.1068 +struct jpeg_color_converter { long dummy; };
  1.1069 +struct jpeg_downsampler { long dummy; };
  1.1070 +struct jpeg_forward_dct { long dummy; };
  1.1071 +struct jpeg_entropy_encoder { long dummy; };
  1.1072 +struct jpeg_decomp_master { long dummy; };
  1.1073 +struct jpeg_d_main_controller { long dummy; };
  1.1074 +struct jpeg_d_coef_controller { long dummy; };
  1.1075 +struct jpeg_d_post_controller { long dummy; };
  1.1076 +struct jpeg_input_controller { long dummy; };
  1.1077 +struct jpeg_marker_reader { long dummy; };
  1.1078 +struct jpeg_entropy_decoder { long dummy; };
  1.1079 +struct jpeg_inverse_dct { long dummy; };
  1.1080 +struct jpeg_upsampler { long dummy; };
  1.1081 +struct jpeg_color_deconverter { long dummy; };
  1.1082 +struct jpeg_color_quantizer { long dummy; };
  1.1083 +#endif /* JPEG_INTERNALS */
  1.1084 +#endif /* INCOMPLETE_TYPES_BROKEN */
  1.1085 +
  1.1086 +
  1.1087 +/*
  1.1088 + * The JPEG library modules define JPEG_INTERNALS before including this file.
  1.1089 + * The internal structure declarations are read only when that is true.
  1.1090 + * Applications using the library should not include jpegint.h, but may wish
  1.1091 + * to include jerror.h.
  1.1092 + */
  1.1093 +
  1.1094 +#ifdef JPEG_INTERNALS
  1.1095 +#include "jpegint.h"		/* fetch private declarations */
  1.1096 +#include "jerror.h"		/* fetch error codes too */
  1.1097 +#endif
  1.1098 +
  1.1099 +#endif /* JPEGLIB_H */