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