ReactOS  0.4.14-dev-376-gaedba84
jdinput.c
Go to the documentation of this file.
1 /*
2  * jdinput.c
3  *
4  * Copyright (C) 1991-1997, Thomas G. Lane.
5  * Modified 2002-2013 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 contains input control logic for the JPEG decompressor.
10  * These routines are concerned with controlling the decompressor's input
11  * processing (marker reading and coefficient decoding). The actual input
12  * reading is done in jdmarker.c, jdhuff.c, and jdarith.c.
13  */
14 
15 #define JPEG_INTERNALS
16 #include "jinclude.h"
17 #include "jpeglib.h"
18 
19 
20 /* Private state */
21 
22 typedef struct {
23  struct jpeg_input_controller pub; /* public fields */
24 
25  int inheaders; /* Nonzero until first SOS is reached */
27 
29 
30 
31 /* Forward declarations */
33 
34 
35 /*
36  * Routines to calculate various quantities related to the size of the image.
37  */
38 
39 
40 /*
41  * Compute output image dimensions and related values.
42  * NOTE: this is exported for possible use by application.
43  * Hence it mustn't do anything that can't be done twice.
44  */
45 
46 GLOBAL(void)
47 jpeg_core_output_dimensions (j_decompress_ptr cinfo)
48 /* Do computations that are needed before master selection phase.
49  * This function is used for transcoding and full decompression.
50  */
51 {
52 #ifdef IDCT_SCALING_SUPPORTED
53  int ci;
55 
56  /* Compute actual output image dimensions and DCT scaling choices. */
57  if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom) {
58  /* Provide 1/block_size scaling */
59  cinfo->output_width = (JDIMENSION)
60  jdiv_round_up((long) cinfo->image_width, (long) cinfo->block_size);
61  cinfo->output_height = (JDIMENSION)
62  jdiv_round_up((long) cinfo->image_height, (long) cinfo->block_size);
63  cinfo->min_DCT_h_scaled_size = 1;
64  cinfo->min_DCT_v_scaled_size = 1;
65  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 2) {
66  /* Provide 2/block_size scaling */
67  cinfo->output_width = (JDIMENSION)
68  jdiv_round_up((long) cinfo->image_width * 2L, (long) cinfo->block_size);
69  cinfo->output_height = (JDIMENSION)
70  jdiv_round_up((long) cinfo->image_height * 2L, (long) cinfo->block_size);
71  cinfo->min_DCT_h_scaled_size = 2;
72  cinfo->min_DCT_v_scaled_size = 2;
73  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 3) {
74  /* Provide 3/block_size scaling */
75  cinfo->output_width = (JDIMENSION)
76  jdiv_round_up((long) cinfo->image_width * 3L, (long) cinfo->block_size);
77  cinfo->output_height = (JDIMENSION)
78  jdiv_round_up((long) cinfo->image_height * 3L, (long) cinfo->block_size);
79  cinfo->min_DCT_h_scaled_size = 3;
80  cinfo->min_DCT_v_scaled_size = 3;
81  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 4) {
82  /* Provide 4/block_size scaling */
83  cinfo->output_width = (JDIMENSION)
84  jdiv_round_up((long) cinfo->image_width * 4L, (long) cinfo->block_size);
85  cinfo->output_height = (JDIMENSION)
86  jdiv_round_up((long) cinfo->image_height * 4L, (long) cinfo->block_size);
87  cinfo->min_DCT_h_scaled_size = 4;
88  cinfo->min_DCT_v_scaled_size = 4;
89  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 5) {
90  /* Provide 5/block_size scaling */
91  cinfo->output_width = (JDIMENSION)
92  jdiv_round_up((long) cinfo->image_width * 5L, (long) cinfo->block_size);
93  cinfo->output_height = (JDIMENSION)
94  jdiv_round_up((long) cinfo->image_height * 5L, (long) cinfo->block_size);
95  cinfo->min_DCT_h_scaled_size = 5;
96  cinfo->min_DCT_v_scaled_size = 5;
97  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 6) {
98  /* Provide 6/block_size scaling */
99  cinfo->output_width = (JDIMENSION)
100  jdiv_round_up((long) cinfo->image_width * 6L, (long) cinfo->block_size);
101  cinfo->output_height = (JDIMENSION)
102  jdiv_round_up((long) cinfo->image_height * 6L, (long) cinfo->block_size);
103  cinfo->min_DCT_h_scaled_size = 6;
104  cinfo->min_DCT_v_scaled_size = 6;
105  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 7) {
106  /* Provide 7/block_size scaling */
107  cinfo->output_width = (JDIMENSION)
108  jdiv_round_up((long) cinfo->image_width * 7L, (long) cinfo->block_size);
109  cinfo->output_height = (JDIMENSION)
110  jdiv_round_up((long) cinfo->image_height * 7L, (long) cinfo->block_size);
111  cinfo->min_DCT_h_scaled_size = 7;
112  cinfo->min_DCT_v_scaled_size = 7;
113  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 8) {
114  /* Provide 8/block_size scaling */
115  cinfo->output_width = (JDIMENSION)
116  jdiv_round_up((long) cinfo->image_width * 8L, (long) cinfo->block_size);
117  cinfo->output_height = (JDIMENSION)
118  jdiv_round_up((long) cinfo->image_height * 8L, (long) cinfo->block_size);
119  cinfo->min_DCT_h_scaled_size = 8;
120  cinfo->min_DCT_v_scaled_size = 8;
121  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 9) {
122  /* Provide 9/block_size scaling */
123  cinfo->output_width = (JDIMENSION)
124  jdiv_round_up((long) cinfo->image_width * 9L, (long) cinfo->block_size);
125  cinfo->output_height = (JDIMENSION)
126  jdiv_round_up((long) cinfo->image_height * 9L, (long) cinfo->block_size);
127  cinfo->min_DCT_h_scaled_size = 9;
128  cinfo->min_DCT_v_scaled_size = 9;
129  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 10) {
130  /* Provide 10/block_size scaling */
131  cinfo->output_width = (JDIMENSION)
132  jdiv_round_up((long) cinfo->image_width * 10L, (long) cinfo->block_size);
133  cinfo->output_height = (JDIMENSION)
134  jdiv_round_up((long) cinfo->image_height * 10L, (long) cinfo->block_size);
135  cinfo->min_DCT_h_scaled_size = 10;
136  cinfo->min_DCT_v_scaled_size = 10;
137  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 11) {
138  /* Provide 11/block_size scaling */
139  cinfo->output_width = (JDIMENSION)
140  jdiv_round_up((long) cinfo->image_width * 11L, (long) cinfo->block_size);
141  cinfo->output_height = (JDIMENSION)
142  jdiv_round_up((long) cinfo->image_height * 11L, (long) cinfo->block_size);
143  cinfo->min_DCT_h_scaled_size = 11;
144  cinfo->min_DCT_v_scaled_size = 11;
145  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 12) {
146  /* Provide 12/block_size scaling */
147  cinfo->output_width = (JDIMENSION)
148  jdiv_round_up((long) cinfo->image_width * 12L, (long) cinfo->block_size);
149  cinfo->output_height = (JDIMENSION)
150  jdiv_round_up((long) cinfo->image_height * 12L, (long) cinfo->block_size);
151  cinfo->min_DCT_h_scaled_size = 12;
152  cinfo->min_DCT_v_scaled_size = 12;
153  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 13) {
154  /* Provide 13/block_size scaling */
155  cinfo->output_width = (JDIMENSION)
156  jdiv_round_up((long) cinfo->image_width * 13L, (long) cinfo->block_size);
157  cinfo->output_height = (JDIMENSION)
158  jdiv_round_up((long) cinfo->image_height * 13L, (long) cinfo->block_size);
159  cinfo->min_DCT_h_scaled_size = 13;
160  cinfo->min_DCT_v_scaled_size = 13;
161  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 14) {
162  /* Provide 14/block_size scaling */
163  cinfo->output_width = (JDIMENSION)
164  jdiv_round_up((long) cinfo->image_width * 14L, (long) cinfo->block_size);
165  cinfo->output_height = (JDIMENSION)
166  jdiv_round_up((long) cinfo->image_height * 14L, (long) cinfo->block_size);
167  cinfo->min_DCT_h_scaled_size = 14;
168  cinfo->min_DCT_v_scaled_size = 14;
169  } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 15) {
170  /* Provide 15/block_size scaling */
171  cinfo->output_width = (JDIMENSION)
172  jdiv_round_up((long) cinfo->image_width * 15L, (long) cinfo->block_size);
173  cinfo->output_height = (JDIMENSION)
174  jdiv_round_up((long) cinfo->image_height * 15L, (long) cinfo->block_size);
175  cinfo->min_DCT_h_scaled_size = 15;
176  cinfo->min_DCT_v_scaled_size = 15;
177  } else {
178  /* Provide 16/block_size scaling */
179  cinfo->output_width = (JDIMENSION)
180  jdiv_round_up((long) cinfo->image_width * 16L, (long) cinfo->block_size);
181  cinfo->output_height = (JDIMENSION)
182  jdiv_round_up((long) cinfo->image_height * 16L, (long) cinfo->block_size);
183  cinfo->min_DCT_h_scaled_size = 16;
184  cinfo->min_DCT_v_scaled_size = 16;
185  }
186 
187  /* Recompute dimensions of components */
188  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
189  ci++, compptr++) {
192  }
193 
194 #else /* !IDCT_SCALING_SUPPORTED */
195 
196  /* Hardwire it to "no scaling" */
197  cinfo->output_width = cinfo->image_width;
198  cinfo->output_height = cinfo->image_height;
199  /* initial_setup has already initialized DCT_scaled_size,
200  * and has computed unscaled downsampled_width and downsampled_height.
201  */
202 
203 #endif /* IDCT_SCALING_SUPPORTED */
204 }
205 
206 
207 LOCAL(void)
209 /* Called once, when first SOS marker is reached */
210 {
211  int ci;
213 
214  /* Make sure image isn't bigger than I can handle */
215  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
216  (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
217  ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
218 
219  /* Only 8 to 12 bits data precision are supported for DCT based JPEG */
220  if (cinfo->data_precision < 8 || cinfo->data_precision > 12)
221  ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
222 
223  /* Check that number of components won't exceed internal array sizes */
224  if (cinfo->num_components > MAX_COMPONENTS)
225  ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
227 
228  /* Compute maximum sampling factors; check factor validity */
229  cinfo->max_h_samp_factor = 1;
230  cinfo->max_v_samp_factor = 1;
231  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
232  ci++, compptr++) {
235  ERREXIT(cinfo, JERR_BAD_SAMPLING);
236  cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
238  cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
240  }
241 
242  /* Derive block_size, natural_order, and lim_Se */
243  if (cinfo->is_baseline || (cinfo->progressive_mode &&
244  cinfo->comps_in_scan)) { /* no pseudo SOS marker */
245  cinfo->block_size = DCTSIZE;
246  cinfo->natural_order = jpeg_natural_order;
247  cinfo->lim_Se = DCTSIZE2-1;
248  } else
249  switch (cinfo->Se) {
250  case (1*1-1):
251  cinfo->block_size = 1;
252  cinfo->natural_order = jpeg_natural_order; /* not needed */
253  cinfo->lim_Se = cinfo->Se;
254  break;
255  case (2*2-1):
256  cinfo->block_size = 2;
257  cinfo->natural_order = jpeg_natural_order2;
258  cinfo->lim_Se = cinfo->Se;
259  break;
260  case (3*3-1):
261  cinfo->block_size = 3;
262  cinfo->natural_order = jpeg_natural_order3;
263  cinfo->lim_Se = cinfo->Se;
264  break;
265  case (4*4-1):
266  cinfo->block_size = 4;
267  cinfo->natural_order = jpeg_natural_order4;
268  cinfo->lim_Se = cinfo->Se;
269  break;
270  case (5*5-1):
271  cinfo->block_size = 5;
272  cinfo->natural_order = jpeg_natural_order5;
273  cinfo->lim_Se = cinfo->Se;
274  break;
275  case (6*6-1):
276  cinfo->block_size = 6;
277  cinfo->natural_order = jpeg_natural_order6;
278  cinfo->lim_Se = cinfo->Se;
279  break;
280  case (7*7-1):
281  cinfo->block_size = 7;
282  cinfo->natural_order = jpeg_natural_order7;
283  cinfo->lim_Se = cinfo->Se;
284  break;
285  case (8*8-1):
286  cinfo->block_size = 8;
287  cinfo->natural_order = jpeg_natural_order;
288  cinfo->lim_Se = DCTSIZE2-1;
289  break;
290  case (9*9-1):
291  cinfo->block_size = 9;
292  cinfo->natural_order = jpeg_natural_order;
293  cinfo->lim_Se = DCTSIZE2-1;
294  break;
295  case (10*10-1):
296  cinfo->block_size = 10;
297  cinfo->natural_order = jpeg_natural_order;
298  cinfo->lim_Se = DCTSIZE2-1;
299  break;
300  case (11*11-1):
301  cinfo->block_size = 11;
302  cinfo->natural_order = jpeg_natural_order;
303  cinfo->lim_Se = DCTSIZE2-1;
304  break;
305  case (12*12-1):
306  cinfo->block_size = 12;
307  cinfo->natural_order = jpeg_natural_order;
308  cinfo->lim_Se = DCTSIZE2-1;
309  break;
310  case (13*13-1):
311  cinfo->block_size = 13;
312  cinfo->natural_order = jpeg_natural_order;
313  cinfo->lim_Se = DCTSIZE2-1;
314  break;
315  case (14*14-1):
316  cinfo->block_size = 14;
317  cinfo->natural_order = jpeg_natural_order;
318  cinfo->lim_Se = DCTSIZE2-1;
319  break;
320  case (15*15-1):
321  cinfo->block_size = 15;
322  cinfo->natural_order = jpeg_natural_order;
323  cinfo->lim_Se = DCTSIZE2-1;
324  break;
325  case (16*16-1):
326  cinfo->block_size = 16;
327  cinfo->natural_order = jpeg_natural_order;
328  cinfo->lim_Se = DCTSIZE2-1;
329  break;
330  default:
331  ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
332  cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
333  break;
334  }
335 
336  /* We initialize DCT_scaled_size and min_DCT_scaled_size to block_size.
337  * In the full decompressor,
338  * this will be overridden by jpeg_calc_output_dimensions in jdmaster.c;
339  * but in the transcoder,
340  * jpeg_calc_output_dimensions is not used, so we must do it here.
341  */
342  cinfo->min_DCT_h_scaled_size = cinfo->block_size;
343  cinfo->min_DCT_v_scaled_size = cinfo->block_size;
344 
345  /* Compute dimensions of components */
346  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
347  ci++, compptr++) {
348  compptr->DCT_h_scaled_size = cinfo->block_size;
349  compptr->DCT_v_scaled_size = cinfo->block_size;
350  /* Size in DCT blocks */
352  jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
353  (long) (cinfo->max_h_samp_factor * cinfo->block_size));
355  jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
356  (long) (cinfo->max_v_samp_factor * cinfo->block_size));
357  /* downsampled_width and downsampled_height will also be overridden by
358  * jdmaster.c if we are doing full decompression. The transcoder library
359  * doesn't use these values, but the calling application might.
360  */
361  /* Size in samples */
363  jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
364  (long) cinfo->max_h_samp_factor);
366  jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
367  (long) cinfo->max_v_samp_factor);
368  /* Mark component needed, until color conversion says otherwise */
370  /* Mark no quantization table yet saved for component */
372  }
373 
374  /* Compute number of fully interleaved MCU rows. */
375  cinfo->total_iMCU_rows = (JDIMENSION)
376  jdiv_round_up((long) cinfo->image_height,
377  (long) (cinfo->max_v_samp_factor * cinfo->block_size));
378 
379  /* Decide whether file contains multiple scans */
380  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
381  cinfo->inputctl->has_multiple_scans = TRUE;
382  else
383  cinfo->inputctl->has_multiple_scans = FALSE;
384 }
385 
386 
387 LOCAL(void)
389 /* Do computations that are needed before processing a JPEG scan */
390 /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
391 {
392  int ci, mcublks, tmp;
394 
395  if (cinfo->comps_in_scan == 1) {
396 
397  /* Noninterleaved (single-component) scan */
398  compptr = cinfo->cur_comp_info[0];
399 
400  /* Overall image size in MCUs */
401  cinfo->MCUs_per_row = compptr->width_in_blocks;
402  cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
403 
404  /* For noninterleaved scan, always one block per MCU */
405  compptr->MCU_width = 1;
406  compptr->MCU_height = 1;
407  compptr->MCU_blocks = 1;
409  compptr->last_col_width = 1;
410  /* For noninterleaved scans, it is convenient to define last_row_height
411  * as the number of block rows present in the last iMCU row.
412  */
414  if (tmp == 0) tmp = compptr->v_samp_factor;
415  compptr->last_row_height = tmp;
416 
417  /* Prepare array describing MCU composition */
418  cinfo->blocks_in_MCU = 1;
419  cinfo->MCU_membership[0] = 0;
420 
421  } else {
422 
423  /* Interleaved (multi-component) scan */
424  if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
425  ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
427 
428  /* Overall image size in MCUs */
429  cinfo->MCUs_per_row = (JDIMENSION)
430  jdiv_round_up((long) cinfo->image_width,
431  (long) (cinfo->max_h_samp_factor * cinfo->block_size));
432  cinfo->MCU_rows_in_scan = (JDIMENSION)
433  jdiv_round_up((long) cinfo->image_height,
434  (long) (cinfo->max_v_samp_factor * cinfo->block_size));
435 
436  cinfo->blocks_in_MCU = 0;
437 
438  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
439  compptr = cinfo->cur_comp_info[ci];
440  /* Sampling factors give # of blocks of component in each MCU */
445  /* Figure number of non-dummy blocks in last MCU column & row */
447  if (tmp == 0) tmp = compptr->MCU_width;
448  compptr->last_col_width = tmp;
450  if (tmp == 0) tmp = compptr->MCU_height;
451  compptr->last_row_height = tmp;
452  /* Prepare array describing MCU composition */
453  mcublks = compptr->MCU_blocks;
454  if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
455  ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
456  while (mcublks-- > 0) {
457  cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
458  }
459  }
460 
461  }
462 }
463 
464 
465 /*
466  * Save away a copy of the Q-table referenced by each component present
467  * in the current scan, unless already saved during a prior scan.
468  *
469  * In a multiple-scan JPEG file, the encoder could assign different components
470  * the same Q-table slot number, but change table definitions between scans
471  * so that each component uses a different Q-table. (The IJG encoder is not
472  * currently capable of doing this, but other encoders might.) Since we want
473  * to be able to dequantize all the components at the end of the file, this
474  * means that we have to save away the table actually used for each component.
475  * We do this by copying the table at the start of the first scan containing
476  * the component.
477  * The JPEG spec prohibits the encoder from changing the contents of a Q-table
478  * slot between scans of a component using that slot. If the encoder does so
479  * anyway, this decoder will simply use the Q-table values that were current
480  * at the start of the first scan for the component.
481  *
482  * The decompressor output side looks only at the saved quant tables,
483  * not at the current Q-table slots.
484  */
485 
486 LOCAL(void)
488 {
489  int ci, qtblno;
491  JQUANT_TBL * qtbl;
492 
493  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
494  compptr = cinfo->cur_comp_info[ci];
495  /* No work if we already saved Q-table for this component */
496  if (compptr->quant_table != NULL)
497  continue;
498  /* Make sure specified quantization table is present */
499  qtblno = compptr->quant_tbl_no;
500  if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
501  cinfo->quant_tbl_ptrs[qtblno] == NULL)
502  ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
503  /* OK, save away the quantization table */
504  qtbl = (JQUANT_TBL *)
505  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
506  SIZEOF(JQUANT_TBL));
507  MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
508  compptr->quant_table = qtbl;
509  }
510 }
511 
512 
513 /*
514  * Initialize the input modules to read a scan of compressed data.
515  * The first call to this is done by jdmaster.c after initializing
516  * the entire decompressor (during jpeg_start_decompress).
517  * Subsequent calls come from consume_markers, below.
518  */
519 
520 METHODDEF(void)
522 {
523  per_scan_setup(cinfo);
524  latch_quant_tables(cinfo);
525  (*cinfo->entropy->start_pass) (cinfo);
526  (*cinfo->coef->start_input_pass) (cinfo);
527  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
528 }
529 
530 
531 /*
532  * Finish up after inputting a compressed-data scan.
533  * This is called by the coefficient controller after it's read all
534  * the expected data of the scan.
535  */
536 
537 METHODDEF(void)
539 {
540  (*cinfo->entropy->finish_pass) (cinfo);
541  cinfo->inputctl->consume_input = consume_markers;
542 }
543 
544 
545 /*
546  * Read JPEG markers before, between, or after compressed-data scans.
547  * Change state as necessary when a new scan is reached.
548  * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
549  *
550  * The consume_input method pointer points either here or to the
551  * coefficient controller's consume_data routine, depending on whether
552  * we are reading a compressed data segment or inter-segment markers.
553  *
554  * Note: This function should NOT return a pseudo SOS marker (with zero
555  * component number) to the caller. A pseudo marker received by
556  * read_markers is processed and then skipped for other markers.
557  */
558 
559 METHODDEF(int)
561 {
562  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
563  int val;
564 
565  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
566  return JPEG_REACHED_EOI;
567 
568  for (;;) { /* Loop to pass pseudo SOS marker */
569  val = (*cinfo->marker->read_markers) (cinfo);
570 
571  switch (val) {
572  case JPEG_REACHED_SOS: /* Found SOS */
573  if (inputctl->inheaders) { /* 1st SOS */
574  if (inputctl->inheaders == 1)
575  initial_setup(cinfo);
576  if (cinfo->comps_in_scan == 0) { /* pseudo SOS marker */
577  inputctl->inheaders = 2;
578  break;
579  }
580  inputctl->inheaders = 0;
581  /* Note: start_input_pass must be called by jdmaster.c
582  * before any more input can be consumed. jdapimin.c is
583  * responsible for enforcing this sequencing.
584  */
585  } else { /* 2nd or later SOS marker */
586  if (! inputctl->pub.has_multiple_scans)
587  ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
588  if (cinfo->comps_in_scan == 0) /* unexpected pseudo SOS marker */
589  break;
590  start_input_pass(cinfo);
591  }
592  return val;
593  case JPEG_REACHED_EOI: /* Found EOI */
594  inputctl->pub.eoi_reached = TRUE;
595  if (inputctl->inheaders) { /* Tables-only datastream, apparently */
596  if (cinfo->marker->saw_SOF)
597  ERREXIT(cinfo, JERR_SOF_NO_SOS);
598  } else {
599  /* Prevent infinite loop in coef ctlr's decompress_data routine
600  * if user set output_scan_number larger than number of scans.
601  */
602  if (cinfo->output_scan_number > cinfo->input_scan_number)
603  cinfo->output_scan_number = cinfo->input_scan_number;
604  }
605  return val;
606  case JPEG_SUSPENDED:
607  return val;
608  default:
609  return val;
610  }
611  }
612 }
613 
614 
615 /*
616  * Reset state to begin a fresh datastream.
617  */
618 
619 METHODDEF(void)
621 {
622  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
623 
624  inputctl->pub.consume_input = consume_markers;
625  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
626  inputctl->pub.eoi_reached = FALSE;
627  inputctl->inheaders = 1;
628  /* Reset other modules */
629  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
630  (*cinfo->marker->reset_marker_reader) (cinfo);
631  /* Reset progression state -- would be cleaner if entropy decoder did this */
632  cinfo->coef_bits = NULL;
633 }
634 
635 
636 /*
637  * Initialize the input controller module.
638  * This is called only once, when the decompression object is created.
639  */
640 
641 GLOBAL(void)
643 {
644  my_inputctl_ptr inputctl;
645 
646  /* Create subobject in permanent pool */
647  inputctl = (my_inputctl_ptr)
648  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
650  cinfo->inputctl = &inputctl->pub;
651  /* Initialize method pointers */
652  inputctl->pub.consume_input = consume_markers;
653  inputctl->pub.reset_input_controller = reset_input_controller;
654  inputctl->pub.start_input_pass = start_input_pass;
655  inputctl->pub.finish_input_pass = finish_input_pass;
656  /* Initialize state: can't use reset_input_controller since we don't
657  * want to try to reset other modules yet.
658  */
659  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
660  inputctl->pub.eoi_reached = FALSE;
661  inputctl->inheaders = 1;
662 }
#define TRUE
Definition: types.h:120
JDIMENSION output_height
Definition: jpeglib.h:508
JDIMENSION downsampled_width
Definition: jpeglib.h:164
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
jinit_input_controller(j_decompress_ptr cinfo)
Definition: jdinput.c:642
#define JPEG_REACHED_SOS
Definition: jpeglib.h:1073
#define JPEG_REACHED_EOI
Definition: jpeglib.h:1074
jpeg_component_info * comp_info
Definition: jpeglib.h:583
my_input_controller * my_inputctl_ptr
Definition: jdinput.c:28
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define MAX_COMPONENTS
Definition: jmorecfg.h:45
JDIMENSION image_width
Definition: jpeglib.h:468
JDIMENSION output_width
Definition: jpeglib.h:507
JDIMENSION image_height
Definition: jpeglib.h:469
boolean component_needed
Definition: jpeglib.h:174
const int jpeg_natural_order2[2 *2+16]
Definition: jutils.c:112
jpeg_component_info * compptr
Definition: jdct.h:238
JDIMENSION width_in_blocks
Definition: jpeglib.h:148
const int jpeg_natural_order7[7 *7+16]
Definition: jutils.c:67
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define ERREXIT4(cinfo, code, p1, p2, p3, p4)
Definition: jerror.h:227
smooth NULL
Definition: ftsmooth.c:416
#define MEMCOPY(dest, src, size)
Definition: jinclude.h:69
JDIMENSION height_in_blocks
Definition: jpeglib.h:149
#define JPEG_MAX_DIMENSION
Definition: jmorecfg.h:231
#define DCTSIZE2
Definition: jpeglib.h:51
const int jpeg_natural_order4[4 *4+16]
Definition: jutils.c:98
#define LOCAL(type)
Definition: jmorecfg.h:289
GLuint GLfloat * val
Definition: glext.h:7180
consume_markers(j_decompress_ptr cinfo)
Definition: jdinput.c:560
latch_quant_tables(j_decompress_ptr cinfo)
Definition: jdinput.c:487
if(!(yy_init))
Definition: macro.lex.yy.c:714
reset_input_controller(j_decompress_ptr cinfo)
Definition: jdinput.c:620
const int jpeg_natural_order3[3 *3+16]
Definition: jutils.c:105
struct jpeg_input_controller pub
Definition: jdinput.c:23
jdiv_round_up(long a, long b)
Definition: jutils.c:124
unsigned int scale_denom
Definition: jpeglib.h:480
const int jpeg_natural_order5[5 *5+16]
Definition: jutils.c:89
#define JPP(arglist)
Definition: jpeglib.h:877
#define MAX_SAMP_FACTOR
Definition: jpeglib.h:56
JQUANT_TBL * quant_table
Definition: jpeglib.h:189
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
start_input_pass(j_decompress_ptr cinfo)
Definition: jdinput.c:521
finish_input_pass(j_decompress_ptr cinfo)
Definition: jdinput.c:538
T MAX(T a, T b)
Definition: polytest.cpp:85
const int jpeg_natural_order[DCTSIZE2+16]
Definition: jutils.c:54
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define D_MAX_BLOCKS_IN_MCU
Definition: jpeglib.h:66
per_scan_setup(j_decompress_ptr cinfo)
Definition: jdinput.c:388
#define long
Definition: qsort.c:33
#define JPEG_SUSPENDED
Definition: jpeglib.h:1042
#define DCTSIZE
Definition: jpeglib.h:50
initial_setup(j_decompress_ptr cinfo)
Definition: jdinput.c:208
#define JPOOL_PERMANENT
Definition: jpeglib.h:807
unsigned int JDIMENSION
Definition: jmorecfg.h:229
unsigned int scale_num
Definition: jpeglib.h:480
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
const int jpeg_natural_order6[6 *6+16]
Definition: jutils.c:79
JDIMENSION downsampled_height
Definition: jpeglib.h:165
METHODDEF(int)
Definition: jdinput.c:32
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31