jpegint.h (15486B)
1 /* 2 * jpegint.h 3 * 4 * Copyright (C) 1991-1995, 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 provides common declarations for the various JPEG modules. 9 * These declarations are considered internal to the JPEG library; most 10 * applications using the library shouldn't need to include this file. 11 */ 12 13 14 /* Declarations for both compression & decompression */ 15 16 typedef enum { /* Operating modes for buffer controllers */ 17 JBUF_PASS_THRU, /* Plain stripwise operation */ 18 /* Remaining modes require a full-image buffer to have been created */ 19 JBUF_SAVE_SOURCE, /* Run source subobject only, save output */ 20 JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */ 21 JBUF_SAVE_AND_PASS /* Run both subobjects, save output */ 22 } J_BUF_MODE; 23 24 /* Values of global_state field (jdapi.c has some dependencies on ordering!) */ 25 #define CSTATE_START 100 /* after create_compress */ 26 #define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */ 27 #define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */ 28 #define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */ 29 #define DSTATE_START 200 /* after create_decompress */ 30 #define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */ 31 #define DSTATE_READY 202 /* found SOS, ready for start_decompress */ 32 #define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/ 33 #define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */ 34 #define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */ 35 #define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */ 36 #define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */ 37 #define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */ 38 #define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */ 39 #define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */ 40 41 42 /* Declarations for compression modules */ 43 44 /* Master control module */ 45 struct jpeg_comp_master { 46 JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo)); 47 JMETHOD(void, pass_startup, (j_compress_ptr cinfo)); 48 JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); 49 50 /* State variables made visible to other modules */ 51 boolean call_pass_startup; /* True if pass_startup must be called */ 52 boolean is_last_pass; /* True during last pass */ 53 }; 54 55 /* Main buffer control (downsampled-data buffer) */ 56 struct jpeg_c_main_controller { 57 JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); 58 JMETHOD(void, process_data, (j_compress_ptr cinfo, 59 JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, 60 JDIMENSION in_rows_avail)); 61 }; 62 63 /* Compression preprocessing (downsampling input buffer control) */ 64 struct jpeg_c_prep_controller { 65 JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); 66 JMETHOD(void, pre_process_data, (j_compress_ptr cinfo, 67 JSAMPARRAY input_buf, 68 JDIMENSION *in_row_ctr, 69 JDIMENSION in_rows_avail, 70 JSAMPIMAGE output_buf, 71 JDIMENSION *out_row_group_ctr, 72 JDIMENSION out_row_groups_avail)); 73 }; 74 75 /* Coefficient buffer control */ 76 struct jpeg_c_coef_controller { 77 JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); 78 JMETHOD(boolean, compress_data, (j_compress_ptr cinfo, 79 JSAMPIMAGE input_buf)); 80 }; 81 82 /* Colorspace conversion */ 83 struct jpeg_color_converter { 84 JMETHOD(void, start_pass, (j_compress_ptr cinfo)); 85 JMETHOD(void, color_convert, (j_compress_ptr cinfo, 86 JSAMPARRAY input_buf, JSAMPIMAGE output_buf, 87 JDIMENSION output_row, int num_rows)); 88 }; 89 90 /* Downsampling */ 91 struct jpeg_downsampler { 92 JMETHOD(void, start_pass, (j_compress_ptr cinfo)); 93 JMETHOD(void, downsample, (j_compress_ptr cinfo, 94 JSAMPIMAGE input_buf, JDIMENSION in_row_index, 95 JSAMPIMAGE output_buf, 96 JDIMENSION out_row_group_index)); 97 98 boolean need_context_rows; /* TRUE if need rows above & below */ 99 }; 100 101 /* Forward DCT (also controls coefficient quantization) */ 102 struct jpeg_forward_dct { 103 JMETHOD(void, start_pass, (j_compress_ptr cinfo)); 104 /* perhaps this should be an array??? */ 105 JMETHOD(void, forward_DCT, (j_compress_ptr cinfo, 106 jpeg_component_info * compptr, 107 JSAMPARRAY sample_data, JBLOCKROW coef_blocks, 108 JDIMENSION start_row, JDIMENSION start_col, 109 JDIMENSION num_blocks)); 110 }; 111 112 /* Entropy encoding */ 113 struct jpeg_entropy_encoder { 114 JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); 115 JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); 116 JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); 117 }; 118 119 /* Marker writing */ 120 struct jpeg_marker_writer { 121 /* write_any_marker is exported for use by applications */ 122 /* Probably only COM and APPn markers should be written */ 123 JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker, 124 const JOCTET *dataptr, unsigned int datalen)); 125 JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); 126 JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); 127 JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); 128 JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); 129 JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); 130 }; 131 132 133 /* Declarations for decompression modules */ 134 135 /* Master control module */ 136 struct jpeg_decomp_master { 137 JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); 138 JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); 139 140 /* State variables made visible to other modules */ 141 boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ 142 }; 143 144 /* Input control module */ 145 struct jpeg_input_controller { 146 JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); 147 JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); 148 JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); 149 JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); 150 151 /* State variables made visible to other modules */ 152 boolean has_multiple_scans; /* True if file has multiple scans */ 153 boolean eoi_reached; /* True when EOI has been consumed */ 154 }; 155 156 /* Main buffer control (downsampled-data buffer) */ 157 struct jpeg_d_main_controller { 158 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); 159 JMETHOD(void, process_data, (j_decompress_ptr cinfo, 160 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, 161 JDIMENSION out_rows_avail)); 162 }; 163 164 /* Coefficient buffer control */ 165 struct jpeg_d_coef_controller { 166 JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); 167 JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); 168 JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); 169 JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, 170 JSAMPIMAGE output_buf)); 171 /* Pointer to array of coefficient virtual arrays, or NULL if none */ 172 jvirt_barray_ptr *coef_arrays; 173 }; 174 175 /* Decompression postprocessing (color quantization buffer control) */ 176 struct jpeg_d_post_controller { 177 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); 178 JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, 179 JSAMPIMAGE input_buf, 180 JDIMENSION *in_row_group_ctr, 181 JDIMENSION in_row_groups_avail, 182 JSAMPARRAY output_buf, 183 JDIMENSION *out_row_ctr, 184 JDIMENSION out_rows_avail)); 185 }; 186 187 /* Marker reading & parsing */ 188 struct jpeg_marker_reader { 189 JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); 190 /* Read markers until SOS or EOI. 191 * Returns same codes as are defined for jpeg_consume_input: 192 * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. 193 */ 194 JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); 195 /* Read a restart marker --- exported for use by entropy decoder only */ 196 jpeg_marker_parser_method read_restart_marker; 197 /* Application-overridable marker processing methods */ 198 jpeg_marker_parser_method process_COM; 199 jpeg_marker_parser_method process_APPn[16]; 200 201 /* State of marker reader --- nominally internal, but applications 202 * supplying COM or APPn handlers might like to know the state. 203 */ 204 boolean saw_SOI; /* found SOI? */ 205 boolean saw_SOF; /* found SOF? */ 206 int next_restart_num; /* next restart number expected (0-7) */ 207 unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ 208 }; 209 210 /* Entropy decoding */ 211 struct jpeg_entropy_decoder { 212 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); 213 JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, 214 JBLOCKROW *MCU_data)); 215 }; 216 217 /* Inverse DCT (also performs dequantization) */ 218 typedef JMETHOD(void, inverse_DCT_method_ptr, 219 (j_decompress_ptr cinfo, jpeg_component_info * compptr, 220 JCOEFPTR coef_block, 221 JSAMPARRAY output_buf, JDIMENSION output_col)); 222 223 struct jpeg_inverse_dct { 224 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); 225 /* It is useful to allow each component to have a separate IDCT method. */ 226 inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; 227 }; 228 229 /* Upsampling (note that upsampler must also call color converter) */ 230 struct jpeg_upsampler { 231 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); 232 JMETHOD(void, upsample, (j_decompress_ptr cinfo, 233 JSAMPIMAGE input_buf, 234 JDIMENSION *in_row_group_ctr, 235 JDIMENSION in_row_groups_avail, 236 JSAMPARRAY output_buf, 237 JDIMENSION *out_row_ctr, 238 JDIMENSION out_rows_avail)); 239 240 boolean need_context_rows; /* TRUE if need rows above & below */ 241 }; 242 243 /* Colorspace conversion */ 244 struct jpeg_color_deconverter { 245 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); 246 JMETHOD(void, color_convert, (j_decompress_ptr cinfo, 247 JSAMPIMAGE input_buf, JDIMENSION input_row, 248 JSAMPARRAY output_buf, int num_rows)); 249 }; 250 251 /* Color quantization or color precision reduction */ 252 struct jpeg_color_quantizer { 253 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); 254 JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, 255 JSAMPARRAY input_buf, JSAMPARRAY output_buf, 256 int num_rows)); 257 JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); 258 JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); 259 }; 260 261 262 /* Miscellaneous useful macros */ 263 264 #undef MAX 265 #define MAX(a,b) ((a) > (b) ? (a) : (b)) 266 #undef MIN 267 #define MIN(a,b) ((a) < (b) ? (a) : (b)) 268 269 270 /* We assume that right shift corresponds to signed division by 2 with 271 * rounding towards minus infinity. This is correct for typical "arithmetic 272 * shift" instructions that shift in copies of the sign bit. But some 273 * C compilers implement >> with an unsigned shift. For these machines you 274 * must define RIGHT_SHIFT_IS_UNSIGNED. 275 * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. 276 * It is only applied with constant shift counts. SHIFT_TEMPS must be 277 * included in the variables of any routine using RIGHT_SHIFT. 278 */ 279 280 #ifdef RIGHT_SHIFT_IS_UNSIGNED 281 #define SHIFT_TEMPS INT32 shift_temp; 282 #define RIGHT_SHIFT(x,shft) \ 283 ((shift_temp = (x)) < 0 ? \ 284 (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ 285 (shift_temp >> (shft))) 286 #else 287 #define SHIFT_TEMPS 288 #define RIGHT_SHIFT(x,shft) ((x) >> (shft)) 289 #endif 290 291 292 /* Short forms of external names for systems with brain-damaged linkers. */ 293 294 #ifdef NEED_SHORT_EXTERNAL_NAMES 295 #define jinit_compress_master jICompress 296 #define jinit_c_master_control jICMaster 297 #define jinit_c_main_controller jICMainC 298 #define jinit_c_prep_controller jICPrepC 299 #define jinit_c_coef_controller jICCoefC 300 #define jinit_color_converter jICColor 301 #define jinit_downsampler jIDownsampler 302 #define jinit_forward_dct jIFDCT 303 #define jinit_huff_encoder jIHEncoder 304 #define jinit_phuff_encoder jIPHEncoder 305 #define jinit_marker_writer jIMWriter 306 #define jinit_master_decompress jIDMaster 307 #define jinit_d_main_controller jIDMainC 308 #define jinit_d_coef_controller jIDCoefC 309 #define jinit_d_post_controller jIDPostC 310 #define jinit_input_controller jIInCtlr 311 #define jinit_marker_reader jIMReader 312 #define jinit_huff_decoder jIHDecoder 313 #define jinit_phuff_decoder jIPHDecoder 314 #define jinit_inverse_dct jIIDCT 315 #define jinit_upsampler jIUpsampler 316 #define jinit_color_deconverter jIDColor 317 #define jinit_1pass_quantizer jI1Quant 318 #define jinit_2pass_quantizer jI2Quant 319 #define jinit_merged_upsampler jIMUpsampler 320 #define jinit_memory_mgr jIMemMgr 321 #define jdiv_round_up jDivRound 322 #define jround_up jRound 323 #define jcopy_sample_rows jCopySamples 324 #define jcopy_block_row jCopyBlocks 325 #define jzero_far jZeroFar 326 #define jpeg_zigzag_order jZIGTable 327 #define jpeg_natural_order jZAGTable 328 #endif /* NEED_SHORT_EXTERNAL_NAMES */ 329 330 331 /* Compression module initialization routines */ 332 EXTERN void jinit_compress_master JPP((j_compress_ptr cinfo)); 333 EXTERN void jinit_c_master_control JPP((j_compress_ptr cinfo, 334 boolean transcode_only)); 335 EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo, 336 boolean need_full_buffer)); 337 EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo, 338 boolean need_full_buffer)); 339 EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo, 340 boolean need_full_buffer)); 341 EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo)); 342 EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo)); 343 EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo)); 344 EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo)); 345 EXTERN void jinit_phuff_encoder JPP((j_compress_ptr cinfo)); 346 EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo)); 347 /* Decompression module initialization routines */ 348 EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo)); 349 EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo, 350 boolean need_full_buffer)); 351 EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo, 352 boolean need_full_buffer)); 353 EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo, 354 boolean need_full_buffer)); 355 EXTERN void jinit_input_controller JPP((j_decompress_ptr cinfo)); 356 EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo)); 357 EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo)); 358 EXTERN void jinit_phuff_decoder JPP((j_decompress_ptr cinfo)); 359 EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo)); 360 EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo)); 361 EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo)); 362 EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); 363 EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); 364 EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); 365 /* Memory manager initialization */ 366 EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo)); 367 368 /* Utility routines in jutils.c */ 369 EXTERN long jdiv_round_up JPP((long a, long b)); 370 EXTERN long jround_up JPP((long a, long b)); 371 EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, 372 JSAMPARRAY output_array, int dest_row, 373 int num_rows, JDIMENSION num_cols)); 374 EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, 375 JDIMENSION num_blocks)); 376 EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero)); 377 /* Constant tables in jutils.c */ 378 extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ 379 extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ 380 381 /* Suppress undefined-structure complaints if necessary. */ 382 383 #ifdef INCOMPLETE_TYPES_BROKEN 384 #ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ 385 struct jvirt_sarray_control { long dummy; }; 386 struct jvirt_barray_control { long dummy; }; 387 #endif 388 #endif /* INCOMPLETE_TYPES_BROKEN */