Thomas G. Lane | 2cbeb8a | 1991-10-07 00:00:00 +0000 | [diff] [blame^] | 1 | /* |
| 2 | * jpegdata.h |
| 3 | * |
| 4 | * Copyright (C) 1991, Thomas G. Lane. |
| 5 | * This file is part of the Independent JPEG Group's software. |
| 6 | * For conditions of distribution and use, see the accompanying README file. |
| 7 | * |
| 8 | * This file defines shared data structures for the various JPEG modules. |
| 9 | */ |
| 10 | |
| 11 | |
| 12 | /* |
| 13 | * You might need to change some of the following declarations if you are |
| 14 | * using the JPEG software within a surrounding application program |
| 15 | * or porting it to an unusual system. |
| 16 | */ |
| 17 | |
| 18 | |
| 19 | /* If the source or destination of image data is not to be stdio streams, |
| 20 | * these types may need work. You can replace them with some kind of |
| 21 | * pointer or indicator that is useful to you, or just ignore 'em. |
| 22 | * Note that the user interface and the various jrdxxx/jwrxxx modules |
| 23 | * will also need work for non-stdio input/output. |
| 24 | */ |
| 25 | |
| 26 | typedef FILE * JFILEREF; /* source or dest of JPEG-compressed data */ |
| 27 | |
| 28 | typedef FILE * IFILEREF; /* source or dest of non-JPEG image data */ |
| 29 | |
| 30 | |
| 31 | /* These defines are used in all function definitions and extern declarations. |
| 32 | * You could modify them if you need to change function linkage conventions, |
| 33 | * as is shown below for use with C++. Another application would be to make |
| 34 | * all functions global for use with code profilers that require it. |
| 35 | * NOTE: the C++ test does the right thing if you are reading this include |
| 36 | * file in a C++ application to link to JPEG code that's been compiled with a |
| 37 | * regular C compiler. I'm not sure it works if you try to compile the JPEG |
| 38 | * code with C++. |
| 39 | */ |
| 40 | |
| 41 | #define METHODDEF static /* a function called through method pointers */ |
| 42 | #define LOCAL static /* a function used only in its module */ |
| 43 | #define GLOBAL /* a function referenced thru EXTERNs */ |
| 44 | #ifdef __cplusplus |
| 45 | #define EXTERN extern "C" /* a reference to a GLOBAL function */ |
| 46 | #else |
| 47 | #define EXTERN extern /* a reference to a GLOBAL function */ |
| 48 | #endif |
| 49 | |
| 50 | |
| 51 | /* Here is the pseudo-keyword for declaring pointers that must be "far" |
| 52 | * on 80x86 machines. Most of the specialized coding for 80x86 is handled |
| 53 | * by just saying "FAR *" where such a pointer is needed. In a few places |
| 54 | * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. |
| 55 | */ |
| 56 | |
| 57 | #ifdef NEED_FAR_POINTERS |
| 58 | #define FAR far |
| 59 | #else |
| 60 | #define FAR |
| 61 | #endif |
| 62 | |
| 63 | |
| 64 | |
| 65 | /* The remaining declarations are not system-dependent, we hope. */ |
| 66 | |
| 67 | |
| 68 | /* |
| 69 | * NOTE: if you have an ancient, strict-K&R C compiler, it may choke on the |
| 70 | * similarly-named fields in compress_info_struct and decompress_info_struct. |
| 71 | * If this happens, you can get around it by rearranging the two structs so |
| 72 | * that the similarly-named fields appear first and in the same order in |
| 73 | * each struct. Since such compilers are now pretty rare, we haven't done |
| 74 | * this in the portable code, preferring to maintain a logical ordering. |
| 75 | */ |
| 76 | |
| 77 | |
| 78 | |
| 79 | /* This macro is used to declare a "method", that is, a function pointer. */ |
| 80 | /* We want to supply prototype parameters if the compiler can cope. */ |
| 81 | /* Note that the arglist parameter must be parenthesized! */ |
| 82 | |
| 83 | #ifdef PROTO |
| 84 | #define METHOD(type,methodname,arglist) type (*methodname) arglist |
| 85 | #else |
| 86 | #define METHOD(type,methodname,arglist) type (*methodname) () |
| 87 | #endif |
| 88 | |
| 89 | /* Forward references to lists of method pointers */ |
| 90 | typedef struct external_methods_struct * external_methods_ptr; |
| 91 | typedef struct compress_methods_struct * compress_methods_ptr; |
| 92 | typedef struct decompress_methods_struct * decompress_methods_ptr; |
| 93 | |
| 94 | |
| 95 | /* Data structures for images containing either samples or coefficients. */ |
| 96 | /* Note that the topmost (leftmost) index is always color component. */ |
| 97 | /* On 80x86 machines, the image arrays are too big for near pointers, */ |
| 98 | /* but the pointer arrays can fit in near memory. */ |
| 99 | |
| 100 | typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ |
| 101 | typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ |
| 102 | typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ |
| 103 | |
| 104 | |
| 105 | #define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ |
| 106 | #define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ |
| 107 | |
| 108 | typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ |
| 109 | typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ |
| 110 | typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ |
| 111 | typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ |
| 112 | |
| 113 | typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ |
| 114 | |
| 115 | |
| 116 | /* The input and output data of the DCT transform subroutines are of |
| 117 | * the following type, which need not be the same as JCOEF. |
| 118 | * For example, on a machine with fast floating point, it might make sense |
| 119 | * to recode the DCT routines to use floating point; then DCTELEM would be |
| 120 | * 'float' or 'double'. |
| 121 | */ |
| 122 | |
| 123 | typedef JCOEF DCTELEM; |
| 124 | typedef DCTELEM DCTBLOCK[DCTSIZE2]; |
| 125 | |
| 126 | |
| 127 | /* Types for JPEG compression parameters and working tables. */ |
| 128 | |
| 129 | |
| 130 | typedef enum { /* defines known color spaces */ |
| 131 | CS_UNKNOWN, /* error/unspecified */ |
| 132 | CS_GRAYSCALE, /* monochrome (only 1 component) */ |
| 133 | CS_RGB, /* red/green/blue */ |
| 134 | CS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ |
| 135 | CS_YIQ, /* Y/I/Q */ |
| 136 | CS_CMYK /* C/M/Y/K */ |
| 137 | } COLOR_SPACE; |
| 138 | |
| 139 | |
| 140 | typedef struct { /* Basic info about one component */ |
| 141 | /* These values are fixed over the whole image */ |
| 142 | /* For compression, they must be supplied by the user interface; */ |
| 143 | /* for decompression, they are read from the SOF marker. */ |
| 144 | short component_id; /* identifier for this component (0..255) */ |
| 145 | short component_index; /* its index in SOF or cinfo->comp_info[] */ |
| 146 | short h_samp_factor; /* horizontal sampling factor (1..4) */ |
| 147 | short v_samp_factor; /* vertical sampling factor (1..4) */ |
| 148 | short quant_tbl_no; /* quantization table selector (0..3) */ |
| 149 | /* These values may vary between scans */ |
| 150 | /* For compression, they must be supplied by the user interface; */ |
| 151 | /* for decompression, they are read from the SOS marker. */ |
| 152 | short dc_tbl_no; /* DC entropy table selector (0..3) */ |
| 153 | short ac_tbl_no; /* AC entropy table selector (0..3) */ |
| 154 | /* These values are computed during compression or decompression startup */ |
| 155 | long true_comp_width; /* component's image width in samples */ |
| 156 | long true_comp_height; /* component's image height in samples */ |
| 157 | /* the above are the logical dimensions of the subsampled image */ |
| 158 | /* These values are computed before starting a scan of the component */ |
| 159 | short MCU_width; /* number of blocks per MCU, horizontally */ |
| 160 | short MCU_height; /* number of blocks per MCU, vertically */ |
| 161 | short MCU_blocks; /* MCU_width * MCU_height */ |
| 162 | long subsampled_width; /* image width in samples, after expansion */ |
| 163 | long subsampled_height; /* image height in samples, after expansion */ |
| 164 | /* the above are the true_comp_xxx values rounded up to multiples of */ |
| 165 | /* the MCU dimensions; these are the working dimensions of the array */ |
| 166 | /* as it is passed through the DCT or IDCT step. NOTE: these values */ |
| 167 | /* differ depending on whether the component is interleaved or not!! */ |
| 168 | } jpeg_component_info; |
| 169 | |
| 170 | |
| 171 | /* DCT coefficient quantization tables. |
| 172 | * For 8-bit precision, 'INT16' should be good enough for quantization values; |
| 173 | * for more precision, we go for the full 16 bits. 'INT16' provides a useful |
| 174 | * speedup on many machines (multiplication & division of JCOEFs by |
| 175 | * quantization values is a significant chunk of the runtime). |
| 176 | * Note: the values in a QUANT_TBL are always given in zigzag order. |
| 177 | */ |
| 178 | #ifdef EIGHT_BIT_SAMPLES |
| 179 | typedef INT16 QUANT_VAL; /* element of a quantization table */ |
| 180 | #else |
| 181 | typedef UINT16 QUANT_VAL; /* element of a quantization table */ |
| 182 | #endif |
| 183 | typedef QUANT_VAL QUANT_TBL[DCTSIZE2]; /* A quantization table */ |
| 184 | typedef QUANT_VAL * QUANT_TBL_PTR; /* pointer to same */ |
| 185 | |
| 186 | |
| 187 | typedef struct { /* A Huffman coding table */ |
| 188 | /* These two fields directly represent the contents of a JPEG DHT marker */ |
| 189 | UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ |
| 190 | /* length k bits; bits[0] is unused */ |
| 191 | UINT8 huffval[256]; /* The symbols, in order of incr code length */ |
| 192 | /* This field is used only during compression. It's initialized FALSE when |
| 193 | * the table is created, and set TRUE when it's been output to the file. |
| 194 | */ |
| 195 | boolean sent_table; /* TRUE when table has been output */ |
| 196 | /* The remaining fields are computed from the above to allow more efficient |
| 197 | * coding and decoding. These fields should be considered private to the |
| 198 | * Huffman compression & decompression modules. |
| 199 | */ |
| 200 | UINT16 ehufco[256]; /* code for each symbol */ |
| 201 | char ehufsi[256]; /* length of code for each symbol */ |
| 202 | UINT16 mincode[17]; /* smallest code of length k */ |
| 203 | INT32 maxcode[17]; /* largest code of length k (-1 if none) */ |
| 204 | short valptr[17]; /* huffval[] index of 1st symbol of length k */ |
| 205 | } HUFF_TBL; |
| 206 | |
| 207 | |
| 208 | #define NUM_QUANT_TBLS 4 /* quantization tables are numbered 0..3 */ |
| 209 | #define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ |
| 210 | #define NUM_ARITH_TBLS 16 /* arith-coding tables are numbered 0..15 */ |
| 211 | #define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ |
| 212 | #define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ |
| 213 | #define MAX_BLOCKS_IN_MCU 10 /* JPEG limit on # of blocks in an MCU */ |
| 214 | |
| 215 | |
| 216 | /* Working data for compression */ |
| 217 | |
| 218 | struct compress_info_struct { |
| 219 | /* |
| 220 | * All of these fields shall be established by the user interface before |
| 221 | * calling jpeg_compress, or by the input_init or c_ui_method_selection |
| 222 | * methods. |
| 223 | * Most parameters can be set to reasonable defaults by j_default_compression. |
| 224 | * Note that the UI must supply the storage for the main methods struct, |
| 225 | * though it sets only a few of the methods there. |
| 226 | */ |
| 227 | compress_methods_ptr methods; /* Points to list of methods to use */ |
| 228 | |
| 229 | external_methods_ptr emethods; /* Points to list of methods to use */ |
| 230 | |
| 231 | IFILEREF input_file; /* tells input routines where to read image */ |
| 232 | JFILEREF output_file; /* tells output routines where to write JPEG */ |
| 233 | |
| 234 | long image_width; /* input image width */ |
| 235 | long image_height; /* input image height */ |
| 236 | short input_components; /* # of color components in input image */ |
| 237 | |
| 238 | short data_precision; /* bits of precision in image data */ |
| 239 | |
| 240 | COLOR_SPACE in_color_space; /* colorspace of input file */ |
| 241 | COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */ |
| 242 | |
| 243 | double input_gamma; /* image gamma of input file */ |
| 244 | |
| 245 | boolean write_JFIF_header; /* should a JFIF marker be written? */ |
| 246 | /* These three values are not used by the JPEG code, only copied */ |
| 247 | /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ |
| 248 | /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ |
| 249 | /* ratio is defined by X_density/Y_density even when density_unit=0. */ |
| 250 | UINT8 density_unit; /* JFIF code for pixel size units */ |
| 251 | UINT16 X_density; /* Horizontal pixel density */ |
| 252 | UINT16 Y_density; /* Vertical pixel density */ |
| 253 | |
| 254 | short num_components; /* # of color components in JPEG image */ |
| 255 | jpeg_component_info * comp_info; |
| 256 | /* comp_info[i] describes component that appears i'th in SOF */ |
| 257 | |
| 258 | QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS]; |
| 259 | /* ptrs to coefficient quantization tables, or NULL if not defined */ |
| 260 | |
| 261 | HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; |
| 262 | HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; |
| 263 | /* ptrs to Huffman coding tables, or NULL if not defined */ |
| 264 | |
| 265 | UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arithmetic-coding tables */ |
| 266 | UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arithmetic-coding tables */ |
| 267 | UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arithmetic-coding tables */ |
| 268 | |
| 269 | boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ |
| 270 | boolean interleave; /* TRUE=interleaved output, FALSE=not */ |
| 271 | boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ |
| 272 | boolean CCIR601_sampling; /* TRUE=first samples are cosited */ |
| 273 | |
| 274 | UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */ |
| 275 | |
| 276 | /* |
| 277 | * These fields are computed during jpeg_compress startup |
| 278 | */ |
| 279 | short max_h_samp_factor; /* largest h_samp_factor */ |
| 280 | short max_v_samp_factor; /* largest v_samp_factor */ |
| 281 | |
| 282 | /* |
| 283 | * These fields are valid during any one scan |
| 284 | */ |
| 285 | short comps_in_scan; /* # of JPEG components output this time */ |
| 286 | jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; |
| 287 | /* *cur_comp_info[i] describes component that appears i'th in SOS */ |
| 288 | |
| 289 | long MCUs_per_row; /* # of MCUs across the image */ |
| 290 | long MCU_rows_in_scan; /* # of MCU rows in the image */ |
| 291 | |
| 292 | short blocks_in_MCU; /* # of DCT blocks per MCU */ |
| 293 | short MCU_membership[MAX_BLOCKS_IN_MCU]; |
| 294 | /* MCU_membership[i] is index in cur_comp_info of component owning */ |
| 295 | /* i'th block in an MCU */ |
| 296 | |
| 297 | /* these fields are private data for the entropy encoder */ |
| 298 | JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */ |
| 299 | JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */ |
| 300 | UINT16 restarts_to_go; /* MDUs left in this restart interval */ |
| 301 | short next_restart_num; /* # of next RSTn marker (0..7) */ |
| 302 | }; |
| 303 | |
| 304 | typedef struct compress_info_struct * compress_info_ptr; |
| 305 | |
| 306 | |
| 307 | /* Working data for decompression */ |
| 308 | |
| 309 | struct decompress_info_struct { |
| 310 | /* |
| 311 | * These fields shall be established by the user interface before |
| 312 | * calling jpeg_decompress. Note that the UI must supply the storage for |
| 313 | * the main methods struct, though it sets only a few of the methods there. |
| 314 | */ |
| 315 | decompress_methods_ptr methods; /* Points to list of methods to use */ |
| 316 | |
| 317 | external_methods_ptr emethods; /* Points to list of methods to use */ |
| 318 | |
| 319 | JFILEREF input_file; /* tells input routines where to read JPEG */ |
| 320 | IFILEREF output_file; /* tells output routines where to write image */ |
| 321 | |
| 322 | /* these can be set at d_ui_method_selection time: */ |
| 323 | |
| 324 | COLOR_SPACE out_color_space; /* colorspace of output */ |
| 325 | |
| 326 | double output_gamma; /* image gamma wanted in output */ |
| 327 | |
| 328 | boolean quantize_colors; /* T if output is a colormapped format */ |
| 329 | /* the following are ignored if not quantize_colors: */ |
| 330 | boolean two_pass_quantize; /* use two-pass color quantization? */ |
| 331 | boolean use_dithering; /* want color dithering? */ |
| 332 | int desired_number_of_colors; /* number of colors to use */ |
| 333 | |
| 334 | boolean do_block_smoothing; /* T = apply cross-block smoothing */ |
| 335 | boolean do_pixel_smoothing; /* T = apply post-subsampling smoothing */ |
| 336 | |
| 337 | /* |
| 338 | * These fields are used for efficient buffering of data between read_jpeg_data |
| 339 | * and the entropy decoding object. By using a shared buffer, we avoid copying |
| 340 | * data and eliminate the need for an "unget" operation at the end of a scan. |
| 341 | * The actual source of the data is known only to read_jpeg_data; see the |
| 342 | * JGETC macro, below. |
| 343 | * Note: the user interface is expected to allocate the input_buffer and |
| 344 | * initialize bytes_in_buffer to 0. Also, for JFIF/raw-JPEG input, the UI |
| 345 | * actually supplies the read_jpeg_data method. |
| 346 | */ |
| 347 | char * input_buffer; /* start of buffer (private to input code) */ |
| 348 | char * next_input_byte; /* => next byte to read from buffer */ |
| 349 | int bytes_in_buffer; /* # of bytes remaining in buffer */ |
| 350 | |
| 351 | /* |
| 352 | * These fields are set by read_file_header or read_scan_header |
| 353 | */ |
| 354 | long image_width; /* overall image width */ |
| 355 | long image_height; /* overall image height */ |
| 356 | |
| 357 | short data_precision; /* bits of precision in image data */ |
| 358 | |
| 359 | COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */ |
| 360 | |
| 361 | /* These three values are not used by the JPEG code, merely copied */ |
| 362 | /* from the JFIF APP0 marker (if any). */ |
| 363 | UINT8 density_unit; /* JFIF code for pixel size units */ |
| 364 | UINT16 X_density; /* Horizontal pixel density */ |
| 365 | UINT16 Y_density; /* Vertical pixel density */ |
| 366 | |
| 367 | short num_components; /* # of color components in JPEG image */ |
| 368 | jpeg_component_info * comp_info; |
| 369 | /* comp_info[i] describes component that appears i'th in SOF */ |
| 370 | |
| 371 | QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS]; |
| 372 | /* ptrs to coefficient quantization tables, or NULL if not defined */ |
| 373 | |
| 374 | HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; |
| 375 | HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; |
| 376 | /* ptrs to Huffman coding tables, or NULL if not defined */ |
| 377 | |
| 378 | UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ |
| 379 | UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ |
| 380 | UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ |
| 381 | |
| 382 | boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ |
| 383 | boolean CCIR601_sampling; /* TRUE=first samples are cosited */ |
| 384 | |
| 385 | UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */ |
| 386 | |
| 387 | /* |
| 388 | * These fields are computed during jpeg_decompress startup |
| 389 | */ |
| 390 | short max_h_samp_factor; /* largest h_samp_factor */ |
| 391 | short max_v_samp_factor; /* largest v_samp_factor */ |
| 392 | |
| 393 | short color_out_comps; /* # of color components output by color_convert */ |
| 394 | /* (need not match num_components) */ |
| 395 | short final_out_comps; /* # of color components in output image */ |
| 396 | /* (1 when quantizing colors, else same as color_out_comps) */ |
| 397 | |
| 398 | /* |
| 399 | * These fields are valid during any one scan |
| 400 | */ |
| 401 | short comps_in_scan; /* # of JPEG components input this time */ |
| 402 | jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; |
| 403 | /* *cur_comp_info[i] describes component that appears i'th in SOS */ |
| 404 | |
| 405 | long MCUs_per_row; /* # of MCUs across the image */ |
| 406 | long MCU_rows_in_scan; /* # of MCU rows in the image */ |
| 407 | |
| 408 | short blocks_in_MCU; /* # of DCT blocks per MCU */ |
| 409 | short MCU_membership[MAX_BLOCKS_IN_MCU]; |
| 410 | /* MCU_membership[i] is index in cur_comp_info of component owning */ |
| 411 | /* i'th block in an MCU */ |
| 412 | |
| 413 | /* these fields are private data for the entropy encoder */ |
| 414 | JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */ |
| 415 | JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */ |
| 416 | UINT16 restarts_to_go; /* MDUs left in this restart interval */ |
| 417 | short next_restart_num; /* # of next RSTn marker (0..7) */ |
| 418 | }; |
| 419 | |
| 420 | typedef struct decompress_info_struct * decompress_info_ptr; |
| 421 | |
| 422 | |
| 423 | /* Macros for reading data from the decompression input buffer */ |
| 424 | |
| 425 | #ifdef CHAR_IS_UNSIGNED |
| 426 | #define JGETC(cinfo) ( --(cinfo)->bytes_in_buffer < 0 ? \ |
| 427 | (*(cinfo)->methods->read_jpeg_data) (cinfo) : \ |
| 428 | (int) *(cinfo)->next_input_byte++ ) |
| 429 | #else |
| 430 | #define JGETC(cinfo) ( --(cinfo)->bytes_in_buffer < 0 ? \ |
| 431 | (*(cinfo)->methods->read_jpeg_data) (cinfo) : \ |
| 432 | (int) (*(cinfo)->next_input_byte++) & 0xFF ) |
| 433 | #endif |
| 434 | |
| 435 | #define JUNGETC(ch,cinfo) ((cinfo)->bytes_in_buffer++, \ |
| 436 | *(--((cinfo)->next_input_byte)) = (ch)) |
| 437 | |
| 438 | #define MIN_UNGET 2 /* may always do at least 2 JUNGETCs */ |
| 439 | |
| 440 | |
| 441 | /* A virtual image has a control block whose contents are private to the |
| 442 | * memory manager module (and may differ between managers). The rest of the |
| 443 | * code only refers to virtual images by these pointer types. |
| 444 | */ |
| 445 | |
| 446 | typedef struct big_sarray_control * big_sarray_ptr; |
| 447 | typedef struct big_barray_control * big_barray_ptr; |
| 448 | |
| 449 | |
| 450 | /* Method types that need typedefs */ |
| 451 | |
| 452 | typedef METHOD(void, MCU_output_method_ptr, (compress_info_ptr cinfo, |
| 453 | JBLOCK *MCU_data)); |
| 454 | typedef METHOD(void, MCU_output_caller_ptr, (compress_info_ptr cinfo, |
| 455 | MCU_output_method_ptr output_method)); |
| 456 | typedef METHOD(void, subsample_ptr, (compress_info_ptr cinfo, |
| 457 | int which_component, |
| 458 | long input_cols, int input_rows, |
| 459 | long output_cols, int output_rows, |
| 460 | JSAMPARRAY above, |
| 461 | JSAMPARRAY input_data, |
| 462 | JSAMPARRAY below, |
| 463 | JSAMPARRAY output_data)); |
| 464 | typedef METHOD(void, unsubsample_ptr, (decompress_info_ptr cinfo, |
| 465 | int which_component, |
| 466 | long input_cols, int input_rows, |
| 467 | long output_cols, int output_rows, |
| 468 | JSAMPARRAY above, |
| 469 | JSAMPARRAY input_data, |
| 470 | JSAMPARRAY below, |
| 471 | JSAMPARRAY output_data)); |
| 472 | typedef METHOD(void, quantize_method_ptr, (decompress_info_ptr cinfo, |
| 473 | int num_rows, |
| 474 | JSAMPIMAGE input_data, |
| 475 | JSAMPARRAY output_workspace)); |
| 476 | typedef METHOD(void, quantize_caller_ptr, (decompress_info_ptr cinfo, |
| 477 | quantize_method_ptr quantize_method)); |
| 478 | |
| 479 | |
| 480 | /* These structs contain function pointers for the various JPEG methods. */ |
| 481 | |
| 482 | /* Routines to be provided by the surrounding application, rather than the |
| 483 | * portable JPEG code proper. These are the same for compression and |
| 484 | * decompression. |
| 485 | */ |
| 486 | |
| 487 | struct external_methods_struct { |
| 488 | /* User interface: error exit and trace message routines */ |
| 489 | /* NOTE: the string msgtext parameters will eventually be replaced */ |
| 490 | /* by an enumerated-type code so that non-English error messages */ |
| 491 | /* can be substituted easily. This will not be done until all the */ |
| 492 | /* code is in place, so that we know what messages are needed. */ |
| 493 | METHOD(void, error_exit, (char *msgtext)); |
| 494 | METHOD(void, trace_message, (char *msgtext)); |
| 495 | |
| 496 | /* Working data for error/trace facility */ |
| 497 | /* See macros below for the usage of these variables */ |
| 498 | int trace_level; /* level of detail of tracing messages */ |
| 499 | /* Use level 0 for unsuppressable messages (nonfatal errors) */ |
| 500 | /* Use levels 1, 2, 3 for successively more detailed trace options */ |
| 501 | |
| 502 | int message_parm[8]; /* store numeric parms for messages here */ |
| 503 | |
| 504 | /* Memory management */ |
| 505 | /* NB: alloc routines never return NULL. They exit to */ |
| 506 | /* error_exit if not successful. */ |
| 507 | METHOD(void *, alloc_small, (size_t sizeofobject)); |
| 508 | METHOD(void, free_small, (void *ptr)); |
| 509 | #ifdef NEED_FAR_POINTERS /* routines for getting far-heap space */ |
| 510 | METHOD(void FAR *, alloc_medium, (size_t sizeofobject)); |
| 511 | METHOD(void, free_medium, (void FAR *ptr)); |
| 512 | #else |
| 513 | #define alloc_medium alloc_small |
| 514 | #define free_medium free_small |
| 515 | #endif |
| 516 | METHOD(JSAMPARRAY, alloc_small_sarray, (long samplesperrow, |
| 517 | long numrows)); |
| 518 | METHOD(void, free_small_sarray, (JSAMPARRAY ptr, |
| 519 | long numrows)); |
| 520 | METHOD(JBLOCKARRAY, alloc_small_barray, (long blocksperrow, |
| 521 | long numrows)); |
| 522 | METHOD(void, free_small_barray, (JBLOCKARRAY ptr, |
| 523 | long numrows)); |
| 524 | METHOD(big_sarray_ptr, request_big_sarray, (long samplesperrow, |
| 525 | long numrows, |
| 526 | long unitheight)); |
| 527 | METHOD(big_barray_ptr, request_big_barray, (long blocksperrow, |
| 528 | long numrows, |
| 529 | long unitheight)); |
| 530 | METHOD(void, alloc_big_arrays, (long extra_small_samples, |
| 531 | long extra_small_blocks, |
| 532 | long extra_medium_space)); |
| 533 | METHOD(JSAMPARRAY, access_big_sarray, (big_sarray_ptr ptr, |
| 534 | long start_row, |
| 535 | boolean writable)); |
| 536 | METHOD(JBLOCKARRAY, access_big_barray, (big_barray_ptr ptr, |
| 537 | long start_row, |
| 538 | boolean writable)); |
| 539 | METHOD(void, free_big_sarray, (big_sarray_ptr ptr)); |
| 540 | METHOD(void, free_big_barray, (big_barray_ptr ptr)); |
| 541 | }; |
| 542 | |
| 543 | /* Macros to simplify using the error and trace message stuff */ |
| 544 | /* The first parameter is generally cinfo->emethods */ |
| 545 | |
| 546 | #define ERREXIT(emeth,msg) ((*(emeth)->error_exit) (msg)) |
| 547 | #define ERREXIT1(emeth,msg,p1) ((emeth)->message_parm[0] = (p1), \ |
| 548 | (*(emeth)->error_exit) (msg)) |
| 549 | #define ERREXIT2(emeth,msg,p1,p2) ((emeth)->message_parm[0] = (p1), \ |
| 550 | (emeth)->message_parm[1] = (p2), \ |
| 551 | (*(emeth)->error_exit) (msg)) |
| 552 | #define ERREXIT3(emeth,msg,p1,p2,p3) ((emeth)->message_parm[0] = (p1), \ |
| 553 | (emeth)->message_parm[1] = (p2), \ |
| 554 | (emeth)->message_parm[2] = (p3), \ |
| 555 | (*(emeth)->error_exit) (msg)) |
| 556 | #define ERREXIT4(emeth,msg,p1,p2,p3,p4) ((emeth)->message_parm[0] = (p1), \ |
| 557 | (emeth)->message_parm[1] = (p2), \ |
| 558 | (emeth)->message_parm[2] = (p3), \ |
| 559 | (emeth)->message_parm[3] = (p4), \ |
| 560 | (*(emeth)->error_exit) (msg)) |
| 561 | |
| 562 | #define TRACEMS(emeth,lvl,msg) \ |
| 563 | ( (emeth)->trace_level >= (lvl) ? \ |
| 564 | ((*(emeth)->trace_message) (msg), 0) : 0) |
| 565 | #define TRACEMS1(emeth,lvl,msg,p1) \ |
| 566 | ( (emeth)->trace_level >= (lvl) ? \ |
| 567 | ((emeth)->message_parm[0] = (p1), \ |
| 568 | (*(emeth)->trace_message) (msg), 0) : 0) |
| 569 | #define TRACEMS2(emeth,lvl,msg,p1,p2) \ |
| 570 | ( (emeth)->trace_level >= (lvl) ? \ |
| 571 | ((emeth)->message_parm[0] = (p1), \ |
| 572 | (emeth)->message_parm[1] = (p2), \ |
| 573 | (*(emeth)->trace_message) (msg), 0) : 0) |
| 574 | #define TRACEMS3(emeth,lvl,msg,p1,p2,p3) \ |
| 575 | ( (emeth)->trace_level >= (lvl) ? \ |
| 576 | ((emeth)->message_parm[0] = (p1), \ |
| 577 | (emeth)->message_parm[1] = (p2), \ |
| 578 | (emeth)->message_parm[2] = (p3), \ |
| 579 | (*(emeth)->trace_message) (msg), 0) : 0) |
| 580 | #define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4) \ |
| 581 | ( (emeth)->trace_level >= (lvl) ? \ |
| 582 | ((emeth)->message_parm[0] = (p1), \ |
| 583 | (emeth)->message_parm[1] = (p2), \ |
| 584 | (emeth)->message_parm[2] = (p3), \ |
| 585 | (emeth)->message_parm[3] = (p4), \ |
| 586 | (*(emeth)->trace_message) (msg), 0) : 0) |
| 587 | #define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8) \ |
| 588 | ( (emeth)->trace_level >= (lvl) ? \ |
| 589 | ((emeth)->message_parm[0] = (p1), \ |
| 590 | (emeth)->message_parm[1] = (p2), \ |
| 591 | (emeth)->message_parm[2] = (p3), \ |
| 592 | (emeth)->message_parm[3] = (p4), \ |
| 593 | (emeth)->message_parm[4] = (p5), \ |
| 594 | (emeth)->message_parm[5] = (p6), \ |
| 595 | (emeth)->message_parm[6] = (p7), \ |
| 596 | (emeth)->message_parm[7] = (p8), \ |
| 597 | (*(emeth)->trace_message) (msg), 0) : 0) |
| 598 | |
| 599 | |
| 600 | /* Methods used during JPEG compression. */ |
| 601 | |
| 602 | struct compress_methods_struct { |
| 603 | /* Hook for user interface to get control after input_init */ |
| 604 | METHOD(void, c_ui_method_selection, (compress_info_ptr cinfo)); |
| 605 | /* Input image reading & conversion to standard form */ |
| 606 | METHOD(void, input_init, (compress_info_ptr cinfo)); |
| 607 | METHOD(void, get_input_row, (compress_info_ptr cinfo, |
| 608 | JSAMPARRAY pixel_row)); |
| 609 | METHOD(void, input_term, (compress_info_ptr cinfo)); |
| 610 | /* Gamma and color space conversion */ |
| 611 | METHOD(void, colorin_init, (compress_info_ptr cinfo)); |
| 612 | METHOD(void, get_sample_rows, (compress_info_ptr cinfo, |
| 613 | int rows_to_read, |
| 614 | JSAMPIMAGE image_data)); |
| 615 | METHOD(void, colorin_term, (compress_info_ptr cinfo)); |
| 616 | /* Expand picture data at edges */ |
| 617 | METHOD(void, edge_expand, (compress_info_ptr cinfo, |
| 618 | long input_cols, int input_rows, |
| 619 | long output_cols, int output_rows, |
| 620 | JSAMPIMAGE image_data)); |
| 621 | /* Subsample pixel values of a single component */ |
| 622 | /* There can be a different subsample method for each component */ |
| 623 | METHOD(void, subsample_init, (compress_info_ptr cinfo)); |
| 624 | subsample_ptr subsample[MAX_COMPS_IN_SCAN]; |
| 625 | METHOD(void, subsample_term, (compress_info_ptr cinfo)); |
| 626 | /* Extract samples in MCU order, process & hand off to output_method */ |
| 627 | /* The input is always exactly N MCU rows worth of data */ |
| 628 | METHOD(void, extract_init, (compress_info_ptr cinfo)); |
| 629 | METHOD(void, extract_MCUs, (compress_info_ptr cinfo, |
| 630 | JSAMPIMAGE image_data, |
| 631 | int num_mcu_rows, |
| 632 | MCU_output_method_ptr output_method)); |
| 633 | METHOD(void, extract_term, (compress_info_ptr cinfo)); |
| 634 | /* Entropy encoding parameter optimization */ |
| 635 | METHOD(void, entropy_optimize, (compress_info_ptr cinfo, |
| 636 | MCU_output_caller_ptr source_method)); |
| 637 | /* Entropy encoding */ |
| 638 | METHOD(void, entropy_encoder_init, (compress_info_ptr cinfo)); |
| 639 | METHOD(void, entropy_encode, (compress_info_ptr cinfo, |
| 640 | JBLOCK *MCU_data)); |
| 641 | METHOD(void, entropy_encoder_term, (compress_info_ptr cinfo)); |
| 642 | /* JPEG file header construction */ |
| 643 | METHOD(void, write_file_header, (compress_info_ptr cinfo)); |
| 644 | METHOD(void, write_scan_header, (compress_info_ptr cinfo)); |
| 645 | METHOD(void, write_jpeg_data, (compress_info_ptr cinfo, |
| 646 | char *dataptr, |
| 647 | int datacount)); |
| 648 | METHOD(void, write_scan_trailer, (compress_info_ptr cinfo)); |
| 649 | METHOD(void, write_file_trailer, (compress_info_ptr cinfo)); |
| 650 | /* Pipeline control */ |
| 651 | METHOD(void, c_pipeline_controller, (compress_info_ptr cinfo)); |
| 652 | METHOD(void, entropy_output, (compress_info_ptr cinfo, |
| 653 | char *dataptr, |
| 654 | int datacount)); |
| 655 | /* Overall control */ |
| 656 | METHOD(void, c_per_scan_method_selection, (compress_info_ptr cinfo)); |
| 657 | }; |
| 658 | |
| 659 | /* Methods used during JPEG decompression. */ |
| 660 | |
| 661 | struct decompress_methods_struct { |
| 662 | /* Hook for user interface to get control after reading file header */ |
| 663 | METHOD(void, d_ui_method_selection, (decompress_info_ptr cinfo)); |
| 664 | /* JPEG file scanning */ |
| 665 | /* Note: user interface supplies read_jpeg_data for JFIF/raw-JPEG |
| 666 | * reading. For file formats that require random access (eg, TIFF) |
| 667 | * the JPEG file header module will override the UI read_jpeg_data. |
| 668 | */ |
| 669 | METHOD(void, read_file_header, (decompress_info_ptr cinfo)); |
| 670 | METHOD(boolean, read_scan_header, (decompress_info_ptr cinfo)); |
| 671 | METHOD(int, read_jpeg_data, (decompress_info_ptr cinfo)); |
| 672 | METHOD(void, read_scan_trailer, (decompress_info_ptr cinfo)); |
| 673 | METHOD(void, read_file_trailer, (decompress_info_ptr cinfo)); |
| 674 | /* Entropy decoding */ |
| 675 | METHOD(void, entropy_decoder_init, (decompress_info_ptr cinfo)); |
| 676 | METHOD(void, entropy_decode, (decompress_info_ptr cinfo, |
| 677 | JBLOCK *MCU_data)); |
| 678 | METHOD(void, entropy_decoder_term, (decompress_info_ptr cinfo)); |
| 679 | /* MCU disassembly: fetch MCUs from entropy_decode, build coef array */ |
| 680 | METHOD(void, disassemble_init, (decompress_info_ptr cinfo)); |
| 681 | METHOD(void, disassemble_MCU, (decompress_info_ptr cinfo, |
| 682 | JBLOCKIMAGE image_data)); |
| 683 | METHOD(void, disassemble_term, (decompress_info_ptr cinfo)); |
| 684 | /* Cross-block smoothing */ |
| 685 | METHOD(void, smooth_coefficients, (decompress_info_ptr cinfo, |
| 686 | jpeg_component_info *compptr, |
| 687 | JBLOCKROW above, |
| 688 | JBLOCKROW currow, |
| 689 | JBLOCKROW below, |
| 690 | JBLOCKROW output)); |
| 691 | /* Un-subsample pixel values of a single component */ |
| 692 | /* There can be a different unsubsample method for each component */ |
| 693 | METHOD(void, unsubsample_init, (decompress_info_ptr cinfo)); |
| 694 | unsubsample_ptr unsubsample[MAX_COMPS_IN_SCAN]; |
| 695 | METHOD(void, unsubsample_term, (decompress_info_ptr cinfo)); |
| 696 | /* Gamma and color space conversion */ |
| 697 | METHOD(void, colorout_init, (decompress_info_ptr cinfo)); |
| 698 | METHOD(void, color_convert, (decompress_info_ptr cinfo, |
| 699 | int num_rows, |
| 700 | JSAMPIMAGE input_data, |
| 701 | JSAMPIMAGE output_data)); |
| 702 | METHOD(void, colorout_term, (decompress_info_ptr cinfo)); |
| 703 | /* Color quantization */ |
| 704 | METHOD(void, color_quant_init, (decompress_info_ptr cinfo)); |
| 705 | METHOD(void, color_quantize, (decompress_info_ptr cinfo, |
| 706 | int num_rows, |
| 707 | JSAMPIMAGE input_data, |
| 708 | JSAMPARRAY output_data)); |
| 709 | METHOD(void, color_quant_prescan, (decompress_info_ptr cinfo, |
| 710 | int num_rows, |
| 711 | JSAMPIMAGE image_data)); |
| 712 | METHOD(void, color_quant_doit, (decompress_info_ptr cinfo, |
| 713 | quantize_caller_ptr source_method)); |
| 714 | METHOD(void, color_quant_term, (decompress_info_ptr cinfo)); |
| 715 | /* Output image writing */ |
| 716 | METHOD(void, output_init, (decompress_info_ptr cinfo)); |
| 717 | METHOD(void, put_color_map, (decompress_info_ptr cinfo, |
| 718 | int num_colors, JSAMPARRAY colormap)); |
| 719 | METHOD(void, put_pixel_rows, (decompress_info_ptr cinfo, |
| 720 | int num_rows, |
| 721 | JSAMPIMAGE pixel_data)); |
| 722 | METHOD(void, output_term, (decompress_info_ptr cinfo)); |
| 723 | /* Pipeline control */ |
| 724 | METHOD(void, d_pipeline_controller, (decompress_info_ptr cinfo)); |
| 725 | /* Overall control */ |
| 726 | METHOD(void, d_per_scan_method_selection, (decompress_info_ptr cinfo)); |
| 727 | }; |
| 728 | |
| 729 | |
| 730 | /* External declarations for routines that aren't called via method ptrs. */ |
| 731 | /* Note: use "j" as first char of names to minimize namespace pollution. */ |
| 732 | /* The PP macro hides prototype parameters from compilers that can't cope. */ |
| 733 | |
| 734 | #ifdef PROTO |
| 735 | #define PP(arglist) arglist |
| 736 | #else |
| 737 | #define PP(arglist) () |
| 738 | #endif |
| 739 | |
| 740 | |
| 741 | /* main entry for compression */ |
| 742 | EXTERN void jpeg_compress PP((compress_info_ptr cinfo)); |
| 743 | /* default parameter setup for compression */ |
| 744 | EXTERN void j_default_compression PP((compress_info_ptr cinfo, int quality)); |
| 745 | EXTERN void j_monochrome_default PP((compress_info_ptr cinfo)); |
| 746 | EXTERN void j_set_quality PP((compress_info_ptr cinfo, int quality, |
| 747 | boolean force_baseline)); |
| 748 | EXTERN void j_free_defaults PP((compress_info_ptr cinfo)); |
| 749 | |
| 750 | /* main entry for decompression */ |
| 751 | EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo)); |
| 752 | |
| 753 | /* forward DCT */ |
| 754 | EXTERN void j_fwd_dct PP((DCTBLOCK data)); |
| 755 | /* inverse DCT */ |
| 756 | EXTERN void j_rev_dct PP((DCTBLOCK data)); |
| 757 | |
| 758 | /* utility routines in jutils.c */ |
| 759 | EXTERN long jround_up PP((long a, long b)); |
| 760 | EXTERN void jcopy_sample_rows PP((JSAMPARRAY input_array, int source_row, |
| 761 | JSAMPARRAY output_array, int dest_row, |
| 762 | int num_rows, long num_cols)); |
| 763 | EXTERN void jcopy_block_row PP((JBLOCKROW input_row, JBLOCKROW output_row, |
| 764 | long num_blocks)); |
| 765 | EXTERN void jzero_far PP((void FAR * target, size_t bytestozero)); |
| 766 | |
| 767 | /* method selection routines for compression modules */ |
| 768 | EXTERN void jselcpipeline PP((compress_info_ptr cinfo)); /* jcpipe.c */ |
| 769 | EXTERN void jselchuffman PP((compress_info_ptr cinfo)); /* jchuff.c */ |
| 770 | EXTERN void jselcarithmetic PP((compress_info_ptr cinfo)); /* jcarith.c */ |
| 771 | EXTERN void jselexpand PP((compress_info_ptr cinfo)); /* jcexpand.c */ |
| 772 | EXTERN void jselsubsample PP((compress_info_ptr cinfo)); /* jcsample.c */ |
| 773 | EXTERN void jselcmcu PP((compress_info_ptr cinfo)); /* jcmcu.c */ |
| 774 | EXTERN void jselccolor PP((compress_info_ptr cinfo)); /* jccolor.c */ |
| 775 | /* The user interface should call one of these to select input format: */ |
| 776 | EXTERN void jselrgif PP((compress_info_ptr cinfo)); /* jrdgif.c */ |
| 777 | EXTERN void jselrppm PP((compress_info_ptr cinfo)); /* jrdppm.c */ |
| 778 | /* and one of these to select output header format: */ |
| 779 | EXTERN void jselwjfif PP((compress_info_ptr cinfo)); /* jwrjfif.c */ |
| 780 | |
| 781 | /* method selection routines for decompression modules */ |
| 782 | EXTERN void jseldpipeline PP((decompress_info_ptr cinfo)); /* jdpipe.c */ |
| 783 | EXTERN void jseldhuffman PP((decompress_info_ptr cinfo)); /* jdhuff.c */ |
| 784 | EXTERN void jseldarithmetic PP((decompress_info_ptr cinfo)); /* jdarith.c */ |
| 785 | EXTERN void jseldmcu PP((decompress_info_ptr cinfo)); /* jdmcu.c */ |
| 786 | EXTERN void jselbsmooth PP((decompress_info_ptr cinfo)); /* jbsmooth.c */ |
| 787 | EXTERN void jselunsubsample PP((decompress_info_ptr cinfo)); /* jdsample.c */ |
| 788 | EXTERN void jseldcolor PP((decompress_info_ptr cinfo)); /* jdcolor.c */ |
| 789 | EXTERN void jsel1quantize PP((decompress_info_ptr cinfo)); /* jquant1.c */ |
| 790 | EXTERN void jsel2quantize PP((decompress_info_ptr cinfo)); /* jquant2.c */ |
| 791 | /* The user interface should call one of these to select input format: */ |
| 792 | EXTERN void jselrjfif PP((decompress_info_ptr cinfo)); /* jrdjfif.c */ |
| 793 | /* and one of these to select output image format: */ |
| 794 | EXTERN void jselwgif PP((decompress_info_ptr cinfo)); /* jwrgif.c */ |
| 795 | EXTERN void jselwppm PP((decompress_info_ptr cinfo)); /* jwrppm.c */ |
| 796 | |
| 797 | /* method selection routines for system-dependent modules */ |
| 798 | EXTERN void jselerror PP((external_methods_ptr emethods)); /* jerror.c */ |
| 799 | EXTERN void jselvirtmem PP((external_methods_ptr emethods)); /* jvirtmem.c */ |
| 800 | |
| 801 | /* debugging hook in jvirtmem.c */ |
| 802 | #ifdef MEM_STATS |
| 803 | EXTERN void j_mem_stats PP((void)); |
| 804 | #endif |
| 805 | |
| 806 | /* Miscellaneous useful macros */ |
| 807 | |
| 808 | #define MAX(a,b) ((a) > (b) ? (a) : (b)) |
| 809 | #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
| 810 | |
| 811 | |
| 812 | #define RST0 0xD0 /* RST0 marker code */ |