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