Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 1 | /* |
2 | * jdinput.c |
||
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 contains input control logic for the JPEG decompressor. |
||
9 | * These routines are concerned with controlling the decompressor's input |
||
10 | * processing (marker reading and coefficient decoding). The actual input |
||
11 | * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c. |
||
12 | */ |
||
13 | |||
14 | #define JPEG_INTERNALS |
||
15 | #include "jinclude.h" |
||
16 | #include "jpeglib.h" |
||
17 | |||
18 | |||
19 | /* Private state */ |
||
20 | |||
21 | typedef struct { |
||
22 | struct jpeg_input_controller pub; /* public fields */ |
||
23 | |||
24 | boolean inheaders; /* TRUE until first SOS is reached */ |
||
25 | } my_input_controller; |
||
26 | |||
27 | typedef my_input_controller * my_inputctl_ptr; |
||
28 | |||
29 | |||
30 | /* Forward declarations */ |
||
31 | METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo)); |
||
32 | |||
33 | |||
34 | /* |
||
35 | * Routines to calculate various quantities related to the size of the image. |
||
36 | */ |
||
37 | |||
38 | LOCAL(void) |
||
39 | initial_setup (j_decompress_ptr cinfo) |
||
40 | /* Called once, when first SOS marker is reached */ |
||
41 | { |
||
42 | int ci; |
||
43 | jpeg_component_info *compptr; |
||
44 | |||
45 | /* Make sure image isn't bigger than I can handle */ |
||
46 | if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || |
||
47 | (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) |
||
48 | ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); |
||
49 | |||
50 | /* For now, precision must match compiled-in value... */ |
||
51 | if (cinfo->data_precision != BITS_IN_JSAMPLE) |
||
52 | ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); |
||
53 | |||
54 | /* Check that number of components won't exceed internal array sizes */ |
||
55 | if (cinfo->num_components > MAX_COMPONENTS) |
||
56 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, |
||
57 | MAX_COMPONENTS); |
||
58 | |||
59 | /* Compute maximum sampling factors; check factor validity */ |
||
60 | cinfo->max_h_samp_factor = 1; |
||
61 | cinfo->max_v_samp_factor = 1; |
||
62 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
63 | ci++, compptr++) { |
||
64 | if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || |
||
65 | compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) |
||
66 | ERREXIT(cinfo, JERR_BAD_SAMPLING); |
||
67 | cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, |
||
68 | compptr->h_samp_factor); |
||
69 | cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, |
||
70 | compptr->v_samp_factor); |
||
71 | } |
||
72 | |||
73 | /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE. |
||
74 | * In the full decompressor, this will be overridden by jdmaster.c; |
||
75 | * but in the transcoder, jdmaster.c is not used, so we must do it here. |
||
76 | */ |
||
77 | cinfo->min_DCT_scaled_size = DCTSIZE; |
||
78 | |||
79 | /* Compute dimensions of components */ |
||
80 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
81 | ci++, compptr++) { |
||
82 | compptr->DCT_scaled_size = DCTSIZE; |
||
83 | /* Size in DCT blocks */ |
||
84 | compptr->width_in_blocks = (JDIMENSION) |
||
85 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, |
||
86 | (long) (cinfo->max_h_samp_factor * DCTSIZE)); |
||
87 | compptr->height_in_blocks = (JDIMENSION) |
||
88 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, |
||
89 | (long) (cinfo->max_v_samp_factor * DCTSIZE)); |
||
90 | /* downsampled_width and downsampled_height will also be overridden by |
||
91 | * jdmaster.c if we are doing full decompression. The transcoder library |
||
92 | * doesn't use these values, but the calling application might. |
||
93 | */ |
||
94 | /* Size in samples */ |
||
95 | compptr->downsampled_width = (JDIMENSION) |
||
96 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, |
||
97 | (long) cinfo->max_h_samp_factor); |
||
98 | compptr->downsampled_height = (JDIMENSION) |
||
99 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, |
||
100 | (long) cinfo->max_v_samp_factor); |
||
101 | /* Mark component needed, until color conversion says otherwise */ |
||
102 | compptr->component_needed = TRUE; |
||
103 | /* Mark no quantization table yet saved for component */ |
||
104 | compptr->quant_table = NULL; |
||
105 | } |
||
106 | |||
107 | /* Compute number of fully interleaved MCU rows. */ |
||
108 | cinfo->total_iMCU_rows = (JDIMENSION) |
||
109 | jdiv_round_up((long) cinfo->image_height, |
||
110 | (long) (cinfo->max_v_samp_factor*DCTSIZE)); |
||
111 | |||
112 | /* Decide whether file contains multiple scans */ |
||
113 | if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode) |
||
114 | cinfo->inputctl->has_multiple_scans = TRUE; |
||
115 | else |
||
116 | cinfo->inputctl->has_multiple_scans = FALSE; |
||
117 | } |
||
118 | |||
119 | |||
120 | LOCAL(void) |
||
121 | per_scan_setup (j_decompress_ptr cinfo) |
||
122 | /* Do computations that are needed before processing a JPEG scan */ |
||
123 | /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */ |
||
124 | { |
||
125 | int ci, mcublks, tmp; |
||
126 | jpeg_component_info *compptr; |
||
127 | |||
128 | if (cinfo->comps_in_scan == 1) { |
||
129 | |||
130 | /* Noninterleaved (single-component) scan */ |
||
131 | compptr = cinfo->cur_comp_info[0]; |
||
132 | |||
133 | /* Overall image size in MCUs */ |
||
134 | cinfo->MCUs_per_row = compptr->width_in_blocks; |
||
135 | cinfo->MCU_rows_in_scan = compptr->height_in_blocks; |
||
136 | |||
137 | /* For noninterleaved scan, always one block per MCU */ |
||
138 | compptr->MCU_width = 1; |
||
139 | compptr->MCU_height = 1; |
||
140 | compptr->MCU_blocks = 1; |
||
141 | compptr->MCU_sample_width = compptr->DCT_scaled_size; |
||
142 | compptr->last_col_width = 1; |
||
143 | /* For noninterleaved scans, it is convenient to define last_row_height |
||
144 | * as the number of block rows present in the last iMCU row. |
||
145 | */ |
||
146 | tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); |
||
147 | if (tmp == 0) tmp = compptr->v_samp_factor; |
||
148 | compptr->last_row_height = tmp; |
||
149 | |||
150 | /* Prepare array describing MCU composition */ |
||
151 | cinfo->blocks_in_MCU = 1; |
||
152 | cinfo->MCU_membership[0] = 0; |
||
153 | |||
154 | } else { |
||
155 | |||
156 | /* Interleaved (multi-component) scan */ |
||
157 | if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) |
||
158 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, |
||
159 | MAX_COMPS_IN_SCAN); |
||
160 | |||
161 | /* Overall image size in MCUs */ |
||
162 | cinfo->MCUs_per_row = (JDIMENSION) |
||
163 | jdiv_round_up((long) cinfo->image_width, |
||
164 | (long) (cinfo->max_h_samp_factor*DCTSIZE)); |
||
165 | cinfo->MCU_rows_in_scan = (JDIMENSION) |
||
166 | jdiv_round_up((long) cinfo->image_height, |
||
167 | (long) (cinfo->max_v_samp_factor*DCTSIZE)); |
||
168 | |||
169 | cinfo->blocks_in_MCU = 0; |
||
170 | |||
171 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
||
172 | compptr = cinfo->cur_comp_info[ci]; |
||
173 | /* Sampling factors give # of blocks of component in each MCU */ |
||
174 | compptr->MCU_width = compptr->h_samp_factor; |
||
175 | compptr->MCU_height = compptr->v_samp_factor; |
||
176 | compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; |
||
177 | compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size; |
||
178 | /* Figure number of non-dummy blocks in last MCU column & row */ |
||
179 | tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); |
||
180 | if (tmp == 0) tmp = compptr->MCU_width; |
||
181 | compptr->last_col_width = tmp; |
||
182 | tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); |
||
183 | if (tmp == 0) tmp = compptr->MCU_height; |
||
184 | compptr->last_row_height = tmp; |
||
185 | /* Prepare array describing MCU composition */ |
||
186 | mcublks = compptr->MCU_blocks; |
||
187 | if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU) |
||
188 | ERREXIT(cinfo, JERR_BAD_MCU_SIZE); |
||
189 | while (mcublks-- > 0) { |
||
190 | cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; |
||
191 | } |
||
192 | } |
||
193 | |||
194 | } |
||
195 | } |
||
196 | |||
197 | |||
198 | /* |
||
199 | * Save away a copy of the Q-table referenced by each component present |
||
200 | * in the current scan, unless already saved during a prior scan. |
||
201 | * |
||
202 | * In a multiple-scan JPEG file, the encoder could assign different components |
||
203 | * the same Q-table slot number, but change table definitions between scans |
||
204 | * so that each component uses a different Q-table. (The IJG encoder is not |
||
205 | * currently capable of doing this, but other encoders might.) Since we want |
||
206 | * to be able to dequantize all the components at the end of the file, this |
||
207 | * means that we have to save away the table actually used for each component. |
||
208 | * We do this by copying the table at the start of the first scan containing |
||
209 | * the component. |
||
210 | * The JPEG spec prohibits the encoder from changing the contents of a Q-table |
||
211 | * slot between scans of a component using that slot. If the encoder does so |
||
212 | * anyway, this decoder will simply use the Q-table values that were current |
||
213 | * at the start of the first scan for the component. |
||
214 | * |
||
215 | * The decompressor output side looks only at the saved quant tables, |
||
216 | * not at the current Q-table slots. |
||
217 | */ |
||
218 | |||
219 | LOCAL(void) |
||
220 | latch_quant_tables (j_decompress_ptr cinfo) |
||
221 | { |
||
222 | int ci, qtblno; |
||
223 | jpeg_component_info *compptr; |
||
224 | JQUANT_TBL * qtbl; |
||
225 | |||
226 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
||
227 | compptr = cinfo->cur_comp_info[ci]; |
||
228 | /* No work if we already saved Q-table for this component */ |
||
229 | if (compptr->quant_table != NULL) |
||
230 | continue; |
||
231 | /* Make sure specified quantization table is present */ |
||
232 | qtblno = compptr->quant_tbl_no; |
||
233 | if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || |
||
234 | cinfo->quant_tbl_ptrs[qtblno] == NULL) |
||
235 | ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); |
||
236 | /* OK, save away the quantization table */ |
||
237 | qtbl = (JQUANT_TBL *) |
||
238 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
||
239 | SIZEOF(JQUANT_TBL)); |
||
240 | MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL)); |
||
241 | compptr->quant_table = qtbl; |
||
242 | } |
||
243 | } |
||
244 | |||
245 | |||
246 | /* |
||
247 | * Initialize the input modules to read a scan of compressed data. |
||
248 | * The first call to this is done by jdmaster.c after initializing |
||
249 | * the entire decompressor (during jpeg_start_decompress). |
||
250 | * Subsequent calls come from consume_markers, below. |
||
251 | */ |
||
252 | |||
253 | METHODDEF(void) |
||
254 | start_input_pass (j_decompress_ptr cinfo) |
||
255 | { |
||
256 | per_scan_setup(cinfo); |
||
257 | latch_quant_tables(cinfo); |
||
258 | (*cinfo->entropy->start_pass) (cinfo); |
||
259 | (*cinfo->coef->start_input_pass) (cinfo); |
||
260 | cinfo->inputctl->consume_input = cinfo->coef->consume_data; |
||
261 | } |
||
262 | |||
263 | |||
264 | /* |
||
265 | * Finish up after inputting a compressed-data scan. |
||
266 | * This is called by the coefficient controller after it's read all |
||
267 | * the expected data of the scan. |
||
268 | */ |
||
269 | |||
270 | METHODDEF(void) |
||
271 | finish_input_pass (j_decompress_ptr cinfo) |
||
272 | { |
||
273 | cinfo->inputctl->consume_input = consume_markers; |
||
274 | } |
||
275 | |||
276 | |||
277 | /* |
||
278 | * Read JPEG markers before, between, or after compressed-data scans. |
||
279 | * Change state as necessary when a new scan is reached. |
||
280 | * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. |
||
281 | * |
||
282 | * The consume_input method pointer points either here or to the |
||
283 | * coefficient controller's consume_data routine, depending on whether |
||
284 | * we are reading a compressed data segment or inter-segment markers. |
||
285 | */ |
||
286 | |||
287 | METHODDEF(int) |
||
288 | consume_markers (j_decompress_ptr cinfo) |
||
289 | { |
||
290 | my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; |
||
291 | int val; |
||
292 | |||
293 | if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */ |
||
294 | return JPEG_REACHED_EOI; |
||
295 | |||
296 | val = (*cinfo->marker->read_markers) (cinfo); |
||
297 | |||
298 | switch (val) { |
||
299 | case JPEG_REACHED_SOS: /* Found SOS */ |
||
300 | if (inputctl->inheaders) { /* 1st SOS */ |
||
301 | initial_setup(cinfo); |
||
302 | inputctl->inheaders = FALSE; |
||
303 | /* Note: start_input_pass must be called by jdmaster.c |
||
304 | * before any more input can be consumed. jdapimin.c is |
||
305 | * responsible for enforcing this sequencing. |
||
306 | */ |
||
307 | } else { /* 2nd or later SOS marker */ |
||
308 | if (! inputctl->pub.has_multiple_scans) |
||
309 | ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */ |
||
310 | start_input_pass(cinfo); |
||
311 | } |
||
312 | break; |
||
313 | case JPEG_REACHED_EOI: /* Found EOI */ |
||
314 | inputctl->pub.eoi_reached = TRUE; |
||
315 | if (inputctl->inheaders) { /* Tables-only datastream, apparently */ |
||
316 | if (cinfo->marker->saw_SOF) |
||
317 | ERREXIT(cinfo, JERR_SOF_NO_SOS); |
||
318 | } else { |
||
319 | /* Prevent infinite loop in coef ctlr's decompress_data routine |
||
320 | * if user set output_scan_number larger than number of scans. |
||
321 | */ |
||
322 | if (cinfo->output_scan_number > cinfo->input_scan_number) |
||
323 | cinfo->output_scan_number = cinfo->input_scan_number; |
||
324 | } |
||
325 | break; |
||
326 | case JPEG_SUSPENDED: |
||
327 | break; |
||
328 | } |
||
329 | |||
330 | return val; |
||
331 | } |
||
332 | |||
333 | |||
334 | /* |
||
335 | * Reset state to begin a fresh datastream. |
||
336 | */ |
||
337 | |||
338 | METHODDEF(void) |
||
339 | reset_input_controller (j_decompress_ptr cinfo) |
||
340 | { |
||
341 | my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; |
||
342 | |||
343 | inputctl->pub.consume_input = consume_markers; |
||
344 | inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ |
||
345 | inputctl->pub.eoi_reached = FALSE; |
||
346 | inputctl->inheaders = TRUE; |
||
347 | /* Reset other modules */ |
||
348 | (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); |
||
349 | (*cinfo->marker->reset_marker_reader) (cinfo); |
||
350 | /* Reset progression state -- would be cleaner if entropy decoder did this */ |
||
351 | cinfo->coef_bits = NULL; |
||
352 | } |
||
353 | |||
354 | |||
355 | /* |
||
356 | * Initialize the input controller module. |
||
357 | * This is called only once, when the decompression object is created. |
||
358 | */ |
||
359 | |||
360 | GLOBAL(void) |
||
361 | jinit_input_controller (j_decompress_ptr cinfo) |
||
362 | { |
||
363 | my_inputctl_ptr inputctl; |
||
364 | |||
365 | /* Create subobject in permanent pool */ |
||
366 | inputctl = (my_inputctl_ptr) |
||
367 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, |
||
368 | SIZEOF(my_input_controller)); |
||
369 | cinfo->inputctl = (struct jpeg_input_controller *) inputctl; |
||
370 | /* Initialize method pointers */ |
||
371 | inputctl->pub.consume_input = consume_markers; |
||
372 | inputctl->pub.reset_input_controller = reset_input_controller; |
||
373 | inputctl->pub.start_input_pass = start_input_pass; |
||
374 | inputctl->pub.finish_input_pass = finish_input_pass; |
||
375 | /* Initialize state: can't use reset_input_controller since we don't |
||
376 | * want to try to reset other modules yet. |
||
377 | */ |
||
378 | inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ |
||
379 | inputctl->pub.eoi_reached = FALSE; |
||
380 | inputctl->inheaders = TRUE; |
||
381 | }>>>=>>>=0>=0>> |