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