Coverage Report

Created: 2024-06-18 06:05

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