diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jpegint.h')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jpegint.h | 426 |
1 files changed, 0 insertions, 426 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jpegint.h b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jpegint.h deleted file mode 100644 index c0d5c14..0000000 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jpegint.h +++ /dev/null | |||
@@ -1,426 +0,0 @@ | |||
1 | /* | ||
2 | * jpegint.h | ||
3 | * | ||
4 | * Copyright (C) 1991-1997, Thomas G. Lane. | ||
5 | * Modified 1997-2011 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 | typedef JMETHOD(void, forward_DCT_ptr, | ||
104 | (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
105 | JSAMPARRAY sample_data, JBLOCKROW coef_blocks, | ||
106 | JDIMENSION start_row, JDIMENSION start_col, | ||
107 | JDIMENSION num_blocks)); | ||
108 | |||
109 | struct jpeg_forward_dct { | ||
110 | JMETHOD(void, start_pass, (j_compress_ptr cinfo)); | ||
111 | /* It is useful to allow each component to have a separate FDCT method. */ | ||
112 | forward_DCT_ptr forward_DCT[MAX_COMPONENTS]; | ||
113 | }; | ||
114 | |||
115 | /* Entropy encoding */ | ||
116 | struct jpeg_entropy_encoder { | ||
117 | JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); | ||
118 | JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); | ||
119 | JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); | ||
120 | }; | ||
121 | |||
122 | /* Marker writing */ | ||
123 | struct jpeg_marker_writer { | ||
124 | JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); | ||
125 | JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); | ||
126 | JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); | ||
127 | JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); | ||
128 | JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); | ||
129 | /* These routines are exported to allow insertion of extra markers */ | ||
130 | /* Probably only COM and APPn markers should be written this way */ | ||
131 | JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, | ||
132 | unsigned int datalen)); | ||
133 | JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); | ||
134 | }; | ||
135 | |||
136 | |||
137 | /* Declarations for decompression modules */ | ||
138 | |||
139 | /* Master control module */ | ||
140 | struct jpeg_decomp_master { | ||
141 | JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); | ||
142 | JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); | ||
143 | |||
144 | /* State variables made visible to other modules */ | ||
145 | boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ | ||
146 | }; | ||
147 | |||
148 | /* Input control module */ | ||
149 | struct jpeg_input_controller { | ||
150 | JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); | ||
151 | JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); | ||
152 | JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); | ||
153 | JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); | ||
154 | |||
155 | /* State variables made visible to other modules */ | ||
156 | boolean has_multiple_scans; /* True if file has multiple scans */ | ||
157 | boolean eoi_reached; /* True when EOI has been consumed */ | ||
158 | }; | ||
159 | |||
160 | /* Main buffer control (downsampled-data buffer) */ | ||
161 | struct jpeg_d_main_controller { | ||
162 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); | ||
163 | JMETHOD(void, process_data, (j_decompress_ptr cinfo, | ||
164 | JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, | ||
165 | JDIMENSION out_rows_avail)); | ||
166 | }; | ||
167 | |||
168 | /* Coefficient buffer control */ | ||
169 | struct jpeg_d_coef_controller { | ||
170 | JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); | ||
171 | JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); | ||
172 | JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); | ||
173 | JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, | ||
174 | JSAMPIMAGE output_buf)); | ||
175 | /* Pointer to array of coefficient virtual arrays, or NULL if none */ | ||
176 | jvirt_barray_ptr *coef_arrays; | ||
177 | }; | ||
178 | |||
179 | /* Decompression postprocessing (color quantization buffer control) */ | ||
180 | struct jpeg_d_post_controller { | ||
181 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); | ||
182 | JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, | ||
183 | JSAMPIMAGE input_buf, | ||
184 | JDIMENSION *in_row_group_ctr, | ||
185 | JDIMENSION in_row_groups_avail, | ||
186 | JSAMPARRAY output_buf, | ||
187 | JDIMENSION *out_row_ctr, | ||
188 | JDIMENSION out_rows_avail)); | ||
189 | }; | ||
190 | |||
191 | /* Marker reading & parsing */ | ||
192 | struct jpeg_marker_reader { | ||
193 | JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); | ||
194 | /* Read markers until SOS or EOI. | ||
195 | * Returns same codes as are defined for jpeg_consume_input: | ||
196 | * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. | ||
197 | */ | ||
198 | JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); | ||
199 | /* Read a restart marker --- exported for use by entropy decoder only */ | ||
200 | jpeg_marker_parser_method read_restart_marker; | ||
201 | |||
202 | /* State of marker reader --- nominally internal, but applications | ||
203 | * supplying COM or APPn handlers might like to know the state. | ||
204 | */ | ||
205 | boolean saw_SOI; /* found SOI? */ | ||
206 | boolean saw_SOF; /* found SOF? */ | ||
207 | int next_restart_num; /* next restart number expected (0-7) */ | ||
208 | unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ | ||
209 | }; | ||
210 | |||
211 | /* Entropy decoding */ | ||
212 | struct jpeg_entropy_decoder { | ||
213 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); | ||
214 | JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, | ||
215 | JBLOCKROW *MCU_data)); | ||
216 | }; | ||
217 | |||
218 | /* Inverse DCT (also performs dequantization) */ | ||
219 | typedef JMETHOD(void, inverse_DCT_method_ptr, | ||
220 | (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
221 | JCOEFPTR coef_block, | ||
222 | JSAMPARRAY output_buf, JDIMENSION output_col)); | ||
223 | |||
224 | struct jpeg_inverse_dct { | ||
225 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); | ||
226 | /* It is useful to allow each component to have a separate IDCT method. */ | ||
227 | inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; | ||
228 | }; | ||
229 | |||
230 | /* Upsampling (note that upsampler must also call color converter) */ | ||
231 | struct jpeg_upsampler { | ||
232 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); | ||
233 | JMETHOD(void, upsample, (j_decompress_ptr cinfo, | ||
234 | JSAMPIMAGE input_buf, | ||
235 | JDIMENSION *in_row_group_ctr, | ||
236 | JDIMENSION in_row_groups_avail, | ||
237 | JSAMPARRAY output_buf, | ||
238 | JDIMENSION *out_row_ctr, | ||
239 | JDIMENSION out_rows_avail)); | ||
240 | |||
241 | boolean need_context_rows; /* TRUE if need rows above & below */ | ||
242 | }; | ||
243 | |||
244 | /* Colorspace conversion */ | ||
245 | struct jpeg_color_deconverter { | ||
246 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); | ||
247 | JMETHOD(void, color_convert, (j_decompress_ptr cinfo, | ||
248 | JSAMPIMAGE input_buf, JDIMENSION input_row, | ||
249 | JSAMPARRAY output_buf, int num_rows)); | ||
250 | }; | ||
251 | |||
252 | /* Color quantization or color precision reduction */ | ||
253 | struct jpeg_color_quantizer { | ||
254 | JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); | ||
255 | JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, | ||
256 | JSAMPARRAY input_buf, JSAMPARRAY output_buf, | ||
257 | int num_rows)); | ||
258 | JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); | ||
259 | JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); | ||
260 | }; | ||
261 | |||
262 | |||
263 | /* Miscellaneous useful macros */ | ||
264 | |||
265 | #undef MAX | ||
266 | #define MAX(a,b) ((a) > (b) ? (a) : (b)) | ||
267 | #undef MIN | ||
268 | #define MIN(a,b) ((a) < (b) ? (a) : (b)) | ||
269 | |||
270 | |||
271 | /* We assume that right shift corresponds to signed division by 2 with | ||
272 | * rounding towards minus infinity. This is correct for typical "arithmetic | ||
273 | * shift" instructions that shift in copies of the sign bit. But some | ||
274 | * C compilers implement >> with an unsigned shift. For these machines you | ||
275 | * must define RIGHT_SHIFT_IS_UNSIGNED. | ||
276 | * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. | ||
277 | * It is only applied with constant shift counts. SHIFT_TEMPS must be | ||
278 | * included in the variables of any routine using RIGHT_SHIFT. | ||
279 | */ | ||
280 | |||
281 | #ifdef RIGHT_SHIFT_IS_UNSIGNED | ||
282 | #define SHIFT_TEMPS INT32 shift_temp; | ||
283 | #define RIGHT_SHIFT(x,shft) \ | ||
284 | ((shift_temp = (x)) < 0 ? \ | ||
285 | (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ | ||
286 | (shift_temp >> (shft))) | ||
287 | #else | ||
288 | #define SHIFT_TEMPS | ||
289 | #define RIGHT_SHIFT(x,shft) ((x) >> (shft)) | ||
290 | #endif | ||
291 | |||
292 | |||
293 | /* Short forms of external names for systems with brain-damaged linkers. */ | ||
294 | |||
295 | #ifdef NEED_SHORT_EXTERNAL_NAMES | ||
296 | #define jinit_compress_master jICompress | ||
297 | #define jinit_c_master_control jICMaster | ||
298 | #define jinit_c_main_controller jICMainC | ||
299 | #define jinit_c_prep_controller jICPrepC | ||
300 | #define jinit_c_coef_controller jICCoefC | ||
301 | #define jinit_color_converter jICColor | ||
302 | #define jinit_downsampler jIDownsampler | ||
303 | #define jinit_forward_dct jIFDCT | ||
304 | #define jinit_huff_encoder jIHEncoder | ||
305 | #define jinit_arith_encoder jIAEncoder | ||
306 | #define jinit_marker_writer jIMWriter | ||
307 | #define jinit_master_decompress jIDMaster | ||
308 | #define jinit_d_main_controller jIDMainC | ||
309 | #define jinit_d_coef_controller jIDCoefC | ||
310 | #define jinit_d_post_controller jIDPostC | ||
311 | #define jinit_input_controller jIInCtlr | ||
312 | #define jinit_marker_reader jIMReader | ||
313 | #define jinit_huff_decoder jIHDecoder | ||
314 | #define jinit_arith_decoder jIADecoder | ||
315 | #define jinit_inverse_dct jIIDCT | ||
316 | #define jinit_upsampler jIUpsampler | ||
317 | #define jinit_color_deconverter jIDColor | ||
318 | #define jinit_1pass_quantizer jI1Quant | ||
319 | #define jinit_2pass_quantizer jI2Quant | ||
320 | #define jinit_merged_upsampler jIMUpsampler | ||
321 | #define jinit_memory_mgr jIMemMgr | ||
322 | #define jdiv_round_up jDivRound | ||
323 | #define jround_up jRound | ||
324 | #define jzero_far jZeroFar | ||
325 | #define jcopy_sample_rows jCopySamples | ||
326 | #define jcopy_block_row jCopyBlocks | ||
327 | #define jpeg_zigzag_order jZIGTable | ||
328 | #define jpeg_natural_order jZAGTable | ||
329 | #define jpeg_natural_order7 jZAG7Table | ||
330 | #define jpeg_natural_order6 jZAG6Table | ||
331 | #define jpeg_natural_order5 jZAG5Table | ||
332 | #define jpeg_natural_order4 jZAG4Table | ||
333 | #define jpeg_natural_order3 jZAG3Table | ||
334 | #define jpeg_natural_order2 jZAG2Table | ||
335 | #define jpeg_aritab jAriTab | ||
336 | #endif /* NEED_SHORT_EXTERNAL_NAMES */ | ||
337 | |||
338 | |||
339 | /* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays | ||
340 | * and coefficient-block arrays. This won't work on 80x86 because the arrays | ||
341 | * are FAR and we're assuming a small-pointer memory model. However, some | ||
342 | * DOS compilers provide far-pointer versions of memcpy() and memset() even | ||
343 | * in the small-model libraries. These will be used if USE_FMEM is defined. | ||
344 | * Otherwise, the routines in jutils.c do it the hard way. | ||
345 | */ | ||
346 | |||
347 | #ifndef NEED_FAR_POINTERS /* normal case, same as regular macro */ | ||
348 | #define FMEMZERO(target,size) MEMZERO(target,size) | ||
349 | #else /* 80x86 case */ | ||
350 | #ifdef USE_FMEM | ||
351 | #define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size)) | ||
352 | #else | ||
353 | EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); | ||
354 | #define FMEMZERO(target,size) jzero_far(target, size) | ||
355 | #endif | ||
356 | #endif | ||
357 | |||
358 | |||
359 | /* Compression module initialization routines */ | ||
360 | EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); | ||
361 | EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, | ||
362 | boolean transcode_only)); | ||
363 | EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, | ||
364 | boolean need_full_buffer)); | ||
365 | EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, | ||
366 | boolean need_full_buffer)); | ||
367 | EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, | ||
368 | boolean need_full_buffer)); | ||
369 | EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); | ||
370 | EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); | ||
371 | EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); | ||
372 | EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); | ||
373 | EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo)); | ||
374 | EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); | ||
375 | /* Decompression module initialization routines */ | ||
376 | EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); | ||
377 | EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, | ||
378 | boolean need_full_buffer)); | ||
379 | EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, | ||
380 | boolean need_full_buffer)); | ||
381 | EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, | ||
382 | boolean need_full_buffer)); | ||
383 | EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); | ||
384 | EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); | ||
385 | EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); | ||
386 | EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo)); | ||
387 | EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); | ||
388 | EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); | ||
389 | EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); | ||
390 | EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); | ||
391 | EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); | ||
392 | EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); | ||
393 | /* Memory manager initialization */ | ||
394 | EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); | ||
395 | |||
396 | /* Utility routines in jutils.c */ | ||
397 | EXTERN(long) jdiv_round_up JPP((long a, long b)); | ||
398 | EXTERN(long) jround_up JPP((long a, long b)); | ||
399 | EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, | ||
400 | JSAMPARRAY output_array, int dest_row, | ||
401 | int num_rows, JDIMENSION num_cols)); | ||
402 | EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, | ||
403 | JDIMENSION num_blocks)); | ||
404 | /* Constant tables in jutils.c */ | ||
405 | #if 0 /* This table is not actually needed in v6a */ | ||
406 | extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ | ||
407 | #endif | ||
408 | extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ | ||
409 | extern const int jpeg_natural_order7[]; /* zz to natural order for 7x7 block */ | ||
410 | extern const int jpeg_natural_order6[]; /* zz to natural order for 6x6 block */ | ||
411 | extern const int jpeg_natural_order5[]; /* zz to natural order for 5x5 block */ | ||
412 | extern const int jpeg_natural_order4[]; /* zz to natural order for 4x4 block */ | ||
413 | extern const int jpeg_natural_order3[]; /* zz to natural order for 3x3 block */ | ||
414 | extern const int jpeg_natural_order2[]; /* zz to natural order for 2x2 block */ | ||
415 | |||
416 | /* Arithmetic coding probability estimation tables in jaricom.c */ | ||
417 | extern const INT32 jpeg_aritab[]; | ||
418 | |||
419 | /* Suppress undefined-structure complaints if necessary. */ | ||
420 | |||
421 | #ifdef INCOMPLETE_TYPES_BROKEN | ||
422 | #ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ | ||
423 | struct jvirt_sarray_control { long dummy; }; | ||
424 | struct jvirt_barray_control { long dummy; }; | ||
425 | #endif | ||
426 | #endif /* INCOMPLETE_TYPES_BROKEN */ | ||