|
1 /* |
|
2 * jpegint.h |
|
3 * |
|
4 * Copyright (C) 1991-1997, 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 JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); |
|
122 JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); |
|
123 JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); |
|
124 JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); |
|
125 JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); |
|
126 /* These routines are exported to allow insertion of extra markers */ |
|
127 /* Probably only COM and APPn markers should be written this way */ |
|
128 JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, |
|
129 unsigned int datalen)); |
|
130 JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); |
|
131 }; |
|
132 |
|
133 |
|
134 /* Declarations for decompression modules */ |
|
135 |
|
136 /* Master control module */ |
|
137 struct jpeg_decomp_master { |
|
138 JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); |
|
139 JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); |
|
140 |
|
141 /* State variables made visible to other modules */ |
|
142 boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ |
|
143 }; |
|
144 |
|
145 /* Input control module */ |
|
146 struct jpeg_input_controller { |
|
147 JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); |
|
148 JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); |
|
149 JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); |
|
150 JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); |
|
151 |
|
152 /* State variables made visible to other modules */ |
|
153 boolean has_multiple_scans; /* True if file has multiple scans */ |
|
154 boolean eoi_reached; /* True when EOI has been consumed */ |
|
155 }; |
|
156 |
|
157 /* Main buffer control (downsampled-data buffer) */ |
|
158 struct jpeg_d_main_controller { |
|
159 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); |
|
160 JMETHOD(void, process_data, (j_decompress_ptr cinfo, |
|
161 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, |
|
162 JDIMENSION out_rows_avail)); |
|
163 }; |
|
164 |
|
165 /* Coefficient buffer control */ |
|
166 struct jpeg_d_coef_controller { |
|
167 JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); |
|
168 JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); |
|
169 JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); |
|
170 JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, |
|
171 JSAMPIMAGE output_buf)); |
|
172 /* Pointer to array of coefficient virtual arrays, or NULL if none */ |
|
173 jvirt_barray_ptr *coef_arrays; |
|
174 }; |
|
175 |
|
176 /* Decompression postprocessing (color quantization buffer control) */ |
|
177 struct jpeg_d_post_controller { |
|
178 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); |
|
179 JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, |
|
180 JSAMPIMAGE input_buf, |
|
181 JDIMENSION *in_row_group_ctr, |
|
182 JDIMENSION in_row_groups_avail, |
|
183 JSAMPARRAY output_buf, |
|
184 JDIMENSION *out_row_ctr, |
|
185 JDIMENSION out_rows_avail)); |
|
186 }; |
|
187 |
|
188 /* Marker reading & parsing */ |
|
189 struct jpeg_marker_reader { |
|
190 JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); |
|
191 /* Read markers until SOS or EOI. |
|
192 * Returns same codes as are defined for jpeg_consume_input: |
|
193 * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. |
|
194 */ |
|
195 JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); |
|
196 /* Read a restart marker --- exported for use by entropy decoder only */ |
|
197 jpeg_marker_parser_method read_restart_marker; |
|
198 |
|
199 /* State of marker reader --- nominally internal, but applications |
|
200 * supplying COM or APPn handlers might like to know the state. |
|
201 */ |
|
202 boolean saw_SOI; /* found SOI? */ |
|
203 boolean saw_SOF; /* found SOF? */ |
|
204 int next_restart_num; /* next restart number expected (0-7) */ |
|
205 unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ |
|
206 }; |
|
207 |
|
208 /* Entropy decoding */ |
|
209 struct jpeg_entropy_decoder { |
|
210 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); |
|
211 JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, |
|
212 JBLOCKROW *MCU_data)); |
|
213 |
|
214 /* This is here to share code between baseline and progressive decoders; */ |
|
215 /* other modules probably should not use it */ |
|
216 boolean insufficient_data; /* set TRUE after emitting warning */ |
|
217 }; |
|
218 |
|
219 /* Inverse DCT (also performs dequantization) */ |
|
220 typedef JMETHOD(void, inverse_DCT_method_ptr, |
|
221 (j_decompress_ptr cinfo, jpeg_component_info * compptr, |
|
222 JCOEFPTR coef_block, |
|
223 JSAMPARRAY output_buf, JDIMENSION output_col)); |
|
224 |
|
225 struct jpeg_inverse_dct { |
|
226 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); |
|
227 /* It is useful to allow each component to have a separate IDCT method. */ |
|
228 inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; |
|
229 }; |
|
230 |
|
231 /* Upsampling (note that upsampler must also call color converter) */ |
|
232 struct jpeg_upsampler { |
|
233 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); |
|
234 JMETHOD(void, upsample, (j_decompress_ptr cinfo, |
|
235 JSAMPIMAGE input_buf, |
|
236 JDIMENSION *in_row_group_ctr, |
|
237 JDIMENSION in_row_groups_avail, |
|
238 JSAMPARRAY output_buf, |
|
239 JDIMENSION *out_row_ctr, |
|
240 JDIMENSION out_rows_avail)); |
|
241 |
|
242 boolean need_context_rows; /* TRUE if need rows above & below */ |
|
243 }; |
|
244 |
|
245 /* Colorspace conversion */ |
|
246 struct jpeg_color_deconverter { |
|
247 JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); |
|
248 JMETHOD(void, color_convert, (j_decompress_ptr cinfo, |
|
249 JSAMPIMAGE input_buf, JDIMENSION input_row, |
|
250 JSAMPARRAY output_buf, int num_rows)); |
|
251 }; |
|
252 |
|
253 /* Color quantization or color precision reduction */ |
|
254 struct jpeg_color_quantizer { |
|
255 JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); |
|
256 JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, |
|
257 JSAMPARRAY input_buf, JSAMPARRAY output_buf, |
|
258 int num_rows)); |
|
259 JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); |
|
260 JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); |
|
261 }; |
|
262 |
|
263 |
|
264 /* Miscellaneous useful macros */ |
|
265 |
|
266 #undef MAX |
|
267 #define MAX(a,b) ((a) > (b) ? (a) : (b)) |
|
268 #undef MIN |
|
269 #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
|
270 |
|
271 |
|
272 /* We assume that right shift corresponds to signed division by 2 with |
|
273 * rounding towards minus infinity. This is correct for typical "arithmetic |
|
274 * shift" instructions that shift in copies of the sign bit. But some |
|
275 * C compilers implement >> with an unsigned shift. For these machines you |
|
276 * must define RIGHT_SHIFT_IS_UNSIGNED. |
|
277 * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. |
|
278 * It is only applied with constant shift counts. SHIFT_TEMPS must be |
|
279 * included in the variables of any routine using RIGHT_SHIFT. |
|
280 */ |
|
281 |
|
282 #ifdef RIGHT_SHIFT_IS_UNSIGNED |
|
283 #define SHIFT_TEMPS INT32 shift_temp; |
|
284 #define RIGHT_SHIFT(x,shft) \ |
|
285 ((shift_temp = (x)) < 0 ? \ |
|
286 (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ |
|
287 (shift_temp >> (shft))) |
|
288 #else |
|
289 #define SHIFT_TEMPS |
|
290 #define RIGHT_SHIFT(x,shft) ((x) >> (shft)) |
|
291 #endif |
|
292 |
|
293 |
|
294 /* Short forms of external names for systems with brain-damaged linkers. */ |
|
295 |
|
296 #ifdef NEED_SHORT_EXTERNAL_NAMES |
|
297 #define jinit_compress_master jICompress |
|
298 #define jinit_c_master_control jICMaster |
|
299 #define jinit_c_main_controller jICMainC |
|
300 #define jinit_c_prep_controller jICPrepC |
|
301 #define jinit_c_coef_controller jICCoefC |
|
302 #define jinit_color_converter jICColor |
|
303 #define jinit_downsampler jIDownsampler |
|
304 #define jinit_forward_dct jIFDCT |
|
305 #define jinit_huff_encoder jIHEncoder |
|
306 #define jinit_phuff_encoder jIPHEncoder |
|
307 #define jinit_marker_writer jIMWriter |
|
308 #define jinit_master_decompress jIDMaster |
|
309 #define jinit_d_main_controller jIDMainC |
|
310 #define jinit_d_coef_controller jIDCoefC |
|
311 #define jinit_d_post_controller jIDPostC |
|
312 #define jinit_input_controller jIInCtlr |
|
313 #define jinit_marker_reader jIMReader |
|
314 #define jinit_huff_decoder jIHDecoder |
|
315 #define jinit_phuff_decoder jIPHDecoder |
|
316 #define jinit_inverse_dct jIIDCT |
|
317 #define jinit_upsampler jIUpsampler |
|
318 #define jinit_color_deconverter jIDColor |
|
319 #define jinit_1pass_quantizer jI1Quant |
|
320 #define jinit_2pass_quantizer jI2Quant |
|
321 #define jinit_merged_upsampler jIMUpsampler |
|
322 #define jinit_memory_mgr jIMemMgr |
|
323 #define jdiv_round_up jDivRound |
|
324 #define jround_up jRound |
|
325 #define jcopy_sample_rows jCopySamples |
|
326 #define jcopy_block_row jCopyBlocks |
|
327 #define jzero_far jZeroFar |
|
328 #define jpeg_zigzag_order jZIGTable |
|
329 #define jpeg_natural_order jZAGTable |
|
330 #endif /* NEED_SHORT_EXTERNAL_NAMES */ |
|
331 |
|
332 |
|
333 /* Compression module initialization routines */ |
|
334 EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); |
|
335 EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, |
|
336 boolean transcode_only)); |
|
337 EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, |
|
338 boolean need_full_buffer)); |
|
339 EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, |
|
340 boolean need_full_buffer)); |
|
341 EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, |
|
342 boolean need_full_buffer)); |
|
343 EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); |
|
344 EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); |
|
345 EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); |
|
346 EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); |
|
347 EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo)); |
|
348 EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); |
|
349 /* Decompression module initialization routines */ |
|
350 EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); |
|
351 EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, |
|
352 boolean need_full_buffer)); |
|
353 EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, |
|
354 boolean need_full_buffer)); |
|
355 EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, |
|
356 boolean need_full_buffer)); |
|
357 EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); |
|
358 EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); |
|
359 EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); |
|
360 EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo)); |
|
361 EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); |
|
362 EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); |
|
363 EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); |
|
364 EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); |
|
365 EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); |
|
366 EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); |
|
367 /* Memory manager initialization */ |
|
368 EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); |
|
369 |
|
370 /* Utility routines in jutils.c */ |
|
371 EXTERN(long) jdiv_round_up JPP((long a, long b)); |
|
372 EXTERN(long) jround_up JPP((long a, long b)); |
|
373 EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, |
|
374 JSAMPARRAY output_array, int dest_row, |
|
375 int num_rows, JDIMENSION num_cols)); |
|
376 EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, |
|
377 JDIMENSION num_blocks)); |
|
378 EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); |
|
379 /* Constant tables in jutils.c */ |
|
380 #if 0 /* This table is not actually needed in v6a */ |
|
381 extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ |
|
382 #endif |
|
383 extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ |
|
384 |
|
385 /* Suppress undefined-structure complaints if necessary. */ |
|
386 |
|
387 #ifdef INCOMPLETE_TYPES_BROKEN |
|
388 #ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ |
|
389 struct jvirt_sarray_control { long dummy; }; |
|
390 struct jvirt_barray_control { long dummy; }; |
|
391 #endif |
|
392 #endif /* INCOMPLETE_TYPES_BROKEN */ |