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