istereo2
diff libs/libjpeg/jpeglib.h @ 2:81d35769f546
added the tunnel effect source
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sat, 19 Sep 2015 05:51:51 +0300 |
| parents | |
| children |
line diff
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/libs/libjpeg/jpeglib.h Sat Sep 19 05:51:51 2015 +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 */