Coverage Report

Created: 2024-06-18 06:05

/src/libjpeg-turbo/jdmaster.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * jdmaster.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1991-1997, Thomas G. Lane.
6
 * Modified 2002-2009 by Guido Vollbeding.
7
 * Lossless JPEG Modifications:
8
 * Copyright (C) 1999, Ken Murchison.
9
 * libjpeg-turbo Modifications:
10
 * Copyright (C) 2009-2011, 2016, 2019, 2022-2023, D. R. Commander.
11
 * Copyright (C) 2013, Linaro Limited.
12
 * Copyright (C) 2015, Google, Inc.
13
 * For conditions of distribution and use, see the accompanying README.ijg
14
 * file.
15
 *
16
 * This file contains master control logic for the JPEG decompressor.
17
 * These routines are concerned with selecting the modules to be executed
18
 * and with determining the number of passes and the work to be done in each
19
 * pass.
20
 */
21
22
#define JPEG_INTERNALS
23
#include "jinclude.h"
24
#include "jpeglib.h"
25
#include "jpegapicomp.h"
26
#include "jdmaster.h"
27
28
29
/*
30
 * Determine whether merged upsample/color conversion should be used.
31
 * CRUCIAL: this must match the actual capabilities of jdmerge.c!
32
 */
33
34
LOCAL(boolean)
35
use_merged_upsample(j_decompress_ptr cinfo)
36
0
{
37
0
#ifdef UPSAMPLE_MERGING_SUPPORTED
38
  /* Colorspace conversion is not supported with lossless JPEG images */
39
0
  if (cinfo->master->lossless)
40
0
    return FALSE;
41
  /* Merging is the equivalent of plain box-filter upsampling */
42
0
  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
43
0
    return FALSE;
44
  /* jdmerge.c only supports YCC=>RGB and YCC=>RGB565 color conversion */
45
0
  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
46
0
      (cinfo->out_color_space != JCS_RGB &&
47
0
       cinfo->out_color_space != JCS_RGB565 &&
48
0
       cinfo->out_color_space != JCS_EXT_RGB &&
49
0
       cinfo->out_color_space != JCS_EXT_RGBX &&
50
0
       cinfo->out_color_space != JCS_EXT_BGR &&
51
0
       cinfo->out_color_space != JCS_EXT_BGRX &&
52
0
       cinfo->out_color_space != JCS_EXT_XBGR &&
53
0
       cinfo->out_color_space != JCS_EXT_XRGB &&
54
0
       cinfo->out_color_space != JCS_EXT_RGBA &&
55
0
       cinfo->out_color_space != JCS_EXT_BGRA &&
56
0
       cinfo->out_color_space != JCS_EXT_ABGR &&
57
0
       cinfo->out_color_space != JCS_EXT_ARGB))
58
0
    return FALSE;
59
0
  if ((cinfo->out_color_space == JCS_RGB565 &&
60
0
       cinfo->out_color_components != 3) ||
61
0
      (cinfo->out_color_space != JCS_RGB565 &&
62
0
       cinfo->out_color_components != rgb_pixelsize[cinfo->out_color_space]))
63
0
    return FALSE;
64
  /* and it only handles 2h1v or 2h2v sampling ratios */
65
0
  if (cinfo->comp_info[0].h_samp_factor != 2 ||
66
0
      cinfo->comp_info[1].h_samp_factor != 1 ||
67
0
      cinfo->comp_info[2].h_samp_factor != 1 ||
68
0
      cinfo->comp_info[0].v_samp_factor >  2 ||
69
0
      cinfo->comp_info[1].v_samp_factor != 1 ||
70
0
      cinfo->comp_info[2].v_samp_factor != 1)
71
0
    return FALSE;
72
  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
73
0
  if (cinfo->comp_info[0]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
74
0
      cinfo->comp_info[1]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
75
0
      cinfo->comp_info[2]._DCT_scaled_size != cinfo->_min_DCT_scaled_size)
76
0
    return FALSE;
77
  /* ??? also need to test for upsample-time rescaling, when & if supported */
78
0
  return TRUE;                  /* by golly, it'll work... */
79
#else
80
  return FALSE;
81
#endif
82
0
}
83
84
85
/*
86
 * Compute output image dimensions and related values.
87
 * NOTE: this is exported for possible use by application.
88
 * Hence it mustn't do anything that can't be done twice.
89
 */
90
91
#if JPEG_LIB_VERSION >= 80
92
GLOBAL(void)
93
#else
94
LOCAL(void)
95
#endif
96
jpeg_core_output_dimensions(j_decompress_ptr cinfo)
97
/* Do computations that are needed before master selection phase.
98
 * This function is used for transcoding and full decompression.
99
 */
100
0
{
101
0
#ifdef IDCT_SCALING_SUPPORTED
102
0
  int ci;
103
0
  jpeg_component_info *compptr;
104
105
0
  if (!cinfo->master->lossless) {
106
    /* Compute actual output image dimensions and DCT scaling choices. */
107
0
    if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom) {
108
      /* Provide 1/block_size scaling */
109
0
      cinfo->output_width = (JDIMENSION)
110
0
        jdiv_round_up((long)cinfo->image_width, (long)DCTSIZE);
111
0
      cinfo->output_height = (JDIMENSION)
112
0
        jdiv_round_up((long)cinfo->image_height, (long)DCTSIZE);
113
0
      cinfo->_min_DCT_h_scaled_size = 1;
114
0
      cinfo->_min_DCT_v_scaled_size = 1;
115
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 2) {
116
      /* Provide 2/block_size scaling */
117
0
      cinfo->output_width = (JDIMENSION)
118
0
        jdiv_round_up((long)cinfo->image_width * 2L, (long)DCTSIZE);
119
0
      cinfo->output_height = (JDIMENSION)
120
0
        jdiv_round_up((long)cinfo->image_height * 2L, (long)DCTSIZE);
121
0
      cinfo->_min_DCT_h_scaled_size = 2;
122
0
      cinfo->_min_DCT_v_scaled_size = 2;
123
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 3) {
124
      /* Provide 3/block_size scaling */
125
0
      cinfo->output_width = (JDIMENSION)
126
0
        jdiv_round_up((long)cinfo->image_width * 3L, (long)DCTSIZE);
127
0
      cinfo->output_height = (JDIMENSION)
128
0
        jdiv_round_up((long)cinfo->image_height * 3L, (long)DCTSIZE);
129
0
      cinfo->_min_DCT_h_scaled_size = 3;
130
0
      cinfo->_min_DCT_v_scaled_size = 3;
131
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 4) {
132
      /* Provide 4/block_size scaling */
133
0
      cinfo->output_width = (JDIMENSION)
134
0
        jdiv_round_up((long)cinfo->image_width * 4L, (long)DCTSIZE);
135
0
      cinfo->output_height = (JDIMENSION)
136
0
        jdiv_round_up((long)cinfo->image_height * 4L, (long)DCTSIZE);
137
0
      cinfo->_min_DCT_h_scaled_size = 4;
138
0
      cinfo->_min_DCT_v_scaled_size = 4;
139
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 5) {
140
      /* Provide 5/block_size scaling */
141
0
      cinfo->output_width = (JDIMENSION)
142
0
        jdiv_round_up((long)cinfo->image_width * 5L, (long)DCTSIZE);
143
0
      cinfo->output_height = (JDIMENSION)
144
0
        jdiv_round_up((long)cinfo->image_height * 5L, (long)DCTSIZE);
145
0
      cinfo->_min_DCT_h_scaled_size = 5;
146
0
      cinfo->_min_DCT_v_scaled_size = 5;
147
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 6) {
148
      /* Provide 6/block_size scaling */
149
0
      cinfo->output_width = (JDIMENSION)
150
0
        jdiv_round_up((long)cinfo->image_width * 6L, (long)DCTSIZE);
151
0
      cinfo->output_height = (JDIMENSION)
152
0
        jdiv_round_up((long)cinfo->image_height * 6L, (long)DCTSIZE);
153
0
      cinfo->_min_DCT_h_scaled_size = 6;
154
0
      cinfo->_min_DCT_v_scaled_size = 6;
155
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 7) {
156
      /* Provide 7/block_size scaling */
157
0
      cinfo->output_width = (JDIMENSION)
158
0
        jdiv_round_up((long)cinfo->image_width * 7L, (long)DCTSIZE);
159
0
      cinfo->output_height = (JDIMENSION)
160
0
        jdiv_round_up((long)cinfo->image_height * 7L, (long)DCTSIZE);
161
0
      cinfo->_min_DCT_h_scaled_size = 7;
162
0
      cinfo->_min_DCT_v_scaled_size = 7;
163
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 8) {
164
      /* Provide 8/block_size scaling */
165
0
      cinfo->output_width = (JDIMENSION)
166
0
        jdiv_round_up((long)cinfo->image_width * 8L, (long)DCTSIZE);
167
0
      cinfo->output_height = (JDIMENSION)
168
0
        jdiv_round_up((long)cinfo->image_height * 8L, (long)DCTSIZE);
169
0
      cinfo->_min_DCT_h_scaled_size = 8;
170
0
      cinfo->_min_DCT_v_scaled_size = 8;
171
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 9) {
172
      /* Provide 9/block_size scaling */
173
0
      cinfo->output_width = (JDIMENSION)
174
0
        jdiv_round_up((long)cinfo->image_width * 9L, (long)DCTSIZE);
175
0
      cinfo->output_height = (JDIMENSION)
176
0
        jdiv_round_up((long)cinfo->image_height * 9L, (long)DCTSIZE);
177
0
      cinfo->_min_DCT_h_scaled_size = 9;
178
0
      cinfo->_min_DCT_v_scaled_size = 9;
179
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 10) {
180
      /* Provide 10/block_size scaling */
181
0
      cinfo->output_width = (JDIMENSION)
182
0
        jdiv_round_up((long)cinfo->image_width * 10L, (long)DCTSIZE);
183
0
      cinfo->output_height = (JDIMENSION)
184
0
        jdiv_round_up((long)cinfo->image_height * 10L, (long)DCTSIZE);
185
0
      cinfo->_min_DCT_h_scaled_size = 10;
186
0
      cinfo->_min_DCT_v_scaled_size = 10;
187
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 11) {
188
      /* Provide 11/block_size scaling */
189
0
      cinfo->output_width = (JDIMENSION)
190
0
        jdiv_round_up((long)cinfo->image_width * 11L, (long)DCTSIZE);
191
0
      cinfo->output_height = (JDIMENSION)
192
0
        jdiv_round_up((long)cinfo->image_height * 11L, (long)DCTSIZE);
193
0
      cinfo->_min_DCT_h_scaled_size = 11;
194
0
      cinfo->_min_DCT_v_scaled_size = 11;
195
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 12) {
196
      /* Provide 12/block_size scaling */
197
0
      cinfo->output_width = (JDIMENSION)
198
0
        jdiv_round_up((long)cinfo->image_width * 12L, (long)DCTSIZE);
199
0
      cinfo->output_height = (JDIMENSION)
200
0
        jdiv_round_up((long)cinfo->image_height * 12L, (long)DCTSIZE);
201
0
      cinfo->_min_DCT_h_scaled_size = 12;
202
0
      cinfo->_min_DCT_v_scaled_size = 12;
203
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 13) {
204
      /* Provide 13/block_size scaling */
205
0
      cinfo->output_width = (JDIMENSION)
206
0
        jdiv_round_up((long)cinfo->image_width * 13L, (long)DCTSIZE);
207
0
      cinfo->output_height = (JDIMENSION)
208
0
        jdiv_round_up((long)cinfo->image_height * 13L, (long)DCTSIZE);
209
0
      cinfo->_min_DCT_h_scaled_size = 13;
210
0
      cinfo->_min_DCT_v_scaled_size = 13;
211
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 14) {
212
      /* Provide 14/block_size scaling */
213
0
      cinfo->output_width = (JDIMENSION)
214
0
        jdiv_round_up((long)cinfo->image_width * 14L, (long)DCTSIZE);
215
0
      cinfo->output_height = (JDIMENSION)
216
0
        jdiv_round_up((long)cinfo->image_height * 14L, (long)DCTSIZE);
217
0
      cinfo->_min_DCT_h_scaled_size = 14;
218
0
      cinfo->_min_DCT_v_scaled_size = 14;
219
0
    } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 15) {
220
      /* Provide 15/block_size scaling */
221
0
      cinfo->output_width = (JDIMENSION)
222
0
        jdiv_round_up((long)cinfo->image_width * 15L, (long)DCTSIZE);
223
0
      cinfo->output_height = (JDIMENSION)
224
0
        jdiv_round_up((long)cinfo->image_height * 15L, (long)DCTSIZE);
225
0
      cinfo->_min_DCT_h_scaled_size = 15;
226
0
      cinfo->_min_DCT_v_scaled_size = 15;
227
0
    } else {
228
      /* Provide 16/block_size scaling */
229
0
      cinfo->output_width = (JDIMENSION)
230
0
        jdiv_round_up((long)cinfo->image_width * 16L, (long)DCTSIZE);
231
0
      cinfo->output_height = (JDIMENSION)
232
0
        jdiv_round_up((long)cinfo->image_height * 16L, (long)DCTSIZE);
233
0
      cinfo->_min_DCT_h_scaled_size = 16;
234
0
      cinfo->_min_DCT_v_scaled_size = 16;
235
0
    }
236
237
    /* Recompute dimensions of components */
238
0
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
239
0
         ci++, compptr++) {
240
0
      compptr->_DCT_h_scaled_size = cinfo->_min_DCT_h_scaled_size;
241
0
      compptr->_DCT_v_scaled_size = cinfo->_min_DCT_v_scaled_size;
242
0
    }
243
0
  } else
244
0
#endif /* !IDCT_SCALING_SUPPORTED */
245
0
  {
246
    /* Hardwire it to "no scaling" */
247
0
    cinfo->output_width = cinfo->image_width;
248
0
    cinfo->output_height = cinfo->image_height;
249
    /* jdinput.c has already initialized DCT_scaled_size,
250
     * and has computed unscaled downsampled_width and downsampled_height.
251
     */
252
0
  }
253
0
}
254
255
256
/*
257
 * Compute output image dimensions and related values.
258
 * NOTE: this is exported for possible use by application.
259
 * Hence it mustn't do anything that can't be done twice.
260
 * Also note that it may be called before the master module is initialized!
261
 */
262
263
GLOBAL(void)
264
jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
265
/* Do computations that are needed before master selection phase */
266
0
{
267
0
#ifdef IDCT_SCALING_SUPPORTED
268
0
  int ci;
269
0
  jpeg_component_info *compptr;
270
0
#endif
271
272
  /* Prevent application from calling me at wrong times */
273
0
  if (cinfo->global_state != DSTATE_READY)
274
0
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
275
276
  /* Compute core output image dimensions and DCT scaling choices. */
277
0
  jpeg_core_output_dimensions(cinfo);
278
279
0
#ifdef IDCT_SCALING_SUPPORTED
280
281
0
  if (!cinfo->master->lossless) {
282
    /* In selecting the actual DCT scaling for each component, we try to
283
     * scale up the chroma components via IDCT scaling rather than upsampling.
284
     * This saves time if the upsampler gets to use 1:1 scaling.
285
     * Note this code adapts subsampling ratios which are powers of 2.
286
     */
287
0
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
288
0
         ci++, compptr++) {
289
0
      int ssize = cinfo->_min_DCT_scaled_size;
290
0
      while (ssize < DCTSIZE &&
291
0
             ((cinfo->max_h_samp_factor * cinfo->_min_DCT_scaled_size) %
292
0
              (compptr->h_samp_factor * ssize * 2) == 0) &&
293
0
             ((cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size) %
294
0
              (compptr->v_samp_factor * ssize * 2) == 0)) {
295
0
        ssize = ssize * 2;
296
0
      }
297
#if JPEG_LIB_VERSION >= 70
298
      compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = ssize;
299
#else
300
0
      compptr->DCT_scaled_size = ssize;
301
0
#endif
302
0
    }
303
304
    /* Recompute downsampled dimensions of components;
305
     * application needs to know these if using raw downsampled data.
306
     */
307
0
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
308
0
         ci++, compptr++) {
309
      /* Size in samples, after IDCT scaling */
310
0
      compptr->downsampled_width = (JDIMENSION)
311
0
        jdiv_round_up((long)cinfo->image_width *
312
0
                      (long)(compptr->h_samp_factor *
313
0
                             compptr->_DCT_scaled_size),
314
0
                      (long)(cinfo->max_h_samp_factor * DCTSIZE));
315
0
      compptr->downsampled_height = (JDIMENSION)
316
0
        jdiv_round_up((long)cinfo->image_height *
317
0
                      (long)(compptr->v_samp_factor *
318
0
                             compptr->_DCT_scaled_size),
319
0
                      (long)(cinfo->max_v_samp_factor * DCTSIZE));
320
0
    }
321
0
  } else
322
0
#endif /* IDCT_SCALING_SUPPORTED */
323
0
  {
324
    /* Hardwire it to "no scaling" */
325
0
    cinfo->output_width = cinfo->image_width;
326
0
    cinfo->output_height = cinfo->image_height;
327
    /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
328
     * and has computed unscaled downsampled_width and downsampled_height.
329
     */
330
0
  }
331
332
  /* Report number of components in selected colorspace. */
333
  /* Probably this should be in the color conversion module... */
334
0
  switch (cinfo->out_color_space) {
335
0
  case JCS_GRAYSCALE:
336
0
    cinfo->out_color_components = 1;
337
0
    break;
338
0
  case JCS_RGB:
339
0
  case JCS_EXT_RGB:
340
0
  case JCS_EXT_RGBX:
341
0
  case JCS_EXT_BGR:
342
0
  case JCS_EXT_BGRX:
343
0
  case JCS_EXT_XBGR:
344
0
  case JCS_EXT_XRGB:
345
0
  case JCS_EXT_RGBA:
346
0
  case JCS_EXT_BGRA:
347
0
  case JCS_EXT_ABGR:
348
0
  case JCS_EXT_ARGB:
349
0
    cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
350
0
    break;
351
0
  case JCS_YCbCr:
352
0
  case JCS_RGB565:
353
0
    cinfo->out_color_components = 3;
354
0
    break;
355
0
  case JCS_CMYK:
356
0
  case JCS_YCCK:
357
0
    cinfo->out_color_components = 4;
358
0
    break;
359
0
  default:                      /* else must be same colorspace as in file */
360
0
    cinfo->out_color_components = cinfo->num_components;
361
0
    break;
362
0
  }
363
0
  cinfo->output_components = (cinfo->quantize_colors ? 1 :
364
0
                              cinfo->out_color_components);
365
366
  /* See if upsampler will want to emit more than one row at a time */
367
0
  if (use_merged_upsample(cinfo))
368
0
    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
369
0
  else
370
0
    cinfo->rec_outbuf_height = 1;
371
0
}
372
373
374
/*
375
 * Several decompression processes need to range-limit values to the range
376
 * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
377
 * due to noise introduced by quantization, roundoff error, etc.  These
378
 * processes are inner loops and need to be as fast as possible.  On most
379
 * machines, particularly CPUs with pipelines or instruction prefetch,
380
 * a (subscript-check-less) C table lookup
381
 *              x = sample_range_limit[x];
382
 * is faster than explicit tests
383
 *              if (x < 0)  x = 0;
384
 *              else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
385
 * These processes all use a common table prepared by the routine below.
386
 *
387
 * For most steps we can mathematically guarantee that the initial value
388
 * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
389
 * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
390
 * limiting step (just after the IDCT), a wildly out-of-range value is
391
 * possible if the input data is corrupt.  To avoid any chance of indexing
392
 * off the end of memory and getting a bad-pointer trap, we perform the
393
 * post-IDCT limiting thus:
394
 *              x = range_limit[x & MASK];
395
 * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
396
 * samples.  Under normal circumstances this is more than enough range and
397
 * a correct output will be generated; with bogus input data the mask will
398
 * cause wraparound, and we will safely generate a bogus-but-in-range output.
399
 * For the post-IDCT step, we want to convert the data from signed to unsigned
400
 * representation by adding CENTERJSAMPLE at the same time that we limit it.
401
 * So the post-IDCT limiting table ends up looking like this:
402
 *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
403
 *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
404
 *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
405
 *   0,1,...,CENTERJSAMPLE-1
406
 * Negative inputs select values from the upper half of the table after
407
 * masking.
408
 *
409
 * We can save some space by overlapping the start of the post-IDCT table
410
 * with the simpler range limiting table.  The post-IDCT table begins at
411
 * sample_range_limit + CENTERJSAMPLE.
412
 */
413
414
LOCAL(void)
415
prepare_range_limit_table(j_decompress_ptr cinfo)
416
/* Allocate and fill in the sample_range_limit table */
417
0
{
418
0
  JSAMPLE *table;
419
0
  J12SAMPLE *table12;
420
0
#ifdef D_LOSSLESS_SUPPORTED
421
0
  J16SAMPLE *table16;
422
0
#endif
423
0
  int i;
424
425
0
  if (cinfo->data_precision == 16) {
426
0
#ifdef D_LOSSLESS_SUPPORTED
427
0
    table16 = (J16SAMPLE *)
428
0
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
429
0
                  (5 * (MAXJ16SAMPLE + 1) + CENTERJ16SAMPLE) *
430
0
                  sizeof(J16SAMPLE));
431
0
    table16 += (MAXJ16SAMPLE + 1);  /* allow negative subscripts of simple
432
                                       table */
433
0
    cinfo->sample_range_limit = (JSAMPLE *)table16;
434
    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
435
0
    memset(table16 - (MAXJ16SAMPLE + 1), 0,
436
0
           (MAXJ16SAMPLE + 1) * sizeof(J16SAMPLE));
437
    /* Main part of "simple" table: limit[x] = x */
438
0
    for (i = 0; i <= MAXJ16SAMPLE; i++)
439
0
      table16[i] = (J16SAMPLE)i;
440
0
    table16 += CENTERJ16SAMPLE; /* Point to where post-IDCT table starts */
441
    /* End of simple table, rest of first half of post-IDCT table */
442
0
    for (i = CENTERJ16SAMPLE; i < 2 * (MAXJ16SAMPLE + 1); i++)
443
0
      table16[i] = MAXJ16SAMPLE;
444
    /* Second half of post-IDCT table */
445
0
    memset(table16 + (2 * (MAXJ16SAMPLE + 1)), 0,
446
0
           (2 * (MAXJ16SAMPLE + 1) - CENTERJ16SAMPLE) * sizeof(J16SAMPLE));
447
0
    memcpy(table16 + (4 * (MAXJ16SAMPLE + 1) - CENTERJ16SAMPLE),
448
0
           cinfo->sample_range_limit, CENTERJ16SAMPLE * sizeof(J16SAMPLE));
449
#else
450
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
451
#endif
452
0
  } else if (cinfo->data_precision == 12) {
453
0
    table12 = (J12SAMPLE *)
454
0
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
455
0
                  (5 * (MAXJ12SAMPLE + 1) + CENTERJ12SAMPLE) *
456
0
                  sizeof(J12SAMPLE));
457
0
    table12 += (MAXJ12SAMPLE + 1);  /* allow negative subscripts of simple
458
                                       table */
459
0
    cinfo->sample_range_limit = (JSAMPLE *)table12;
460
    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
461
0
    memset(table12 - (MAXJ12SAMPLE + 1), 0,
462
0
           (MAXJ12SAMPLE + 1) * sizeof(J12SAMPLE));
463
    /* Main part of "simple" table: limit[x] = x */
464
0
    for (i = 0; i <= MAXJ12SAMPLE; i++)
465
0
      table12[i] = (J12SAMPLE)i;
466
0
    table12 += CENTERJ12SAMPLE; /* Point to where post-IDCT table starts */
467
    /* End of simple table, rest of first half of post-IDCT table */
468
0
    for (i = CENTERJ12SAMPLE; i < 2 * (MAXJ12SAMPLE + 1); i++)
469
0
      table12[i] = MAXJ12SAMPLE;
470
    /* Second half of post-IDCT table */
471
0
    memset(table12 + (2 * (MAXJ12SAMPLE + 1)), 0,
472
0
           (2 * (MAXJ12SAMPLE + 1) - CENTERJ12SAMPLE) * sizeof(J12SAMPLE));
473
0
    memcpy(table12 + (4 * (MAXJ12SAMPLE + 1) - CENTERJ12SAMPLE),
474
0
           cinfo->sample_range_limit, CENTERJ12SAMPLE * sizeof(J12SAMPLE));
475
0
  } else {
476
0
    table = (JSAMPLE *)
477
0
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
478
0
                  (5 * (MAXJSAMPLE + 1) + CENTERJSAMPLE) * sizeof(JSAMPLE));
479
0
    table += (MAXJSAMPLE + 1);  /* allow negative subscripts of simple table */
480
0
    cinfo->sample_range_limit = table;
481
    /* First segment of "simple" table: limit[x] = 0 for x < 0 */
482
0
    memset(table - (MAXJSAMPLE + 1), 0, (MAXJSAMPLE + 1) * sizeof(JSAMPLE));
483
    /* Main part of "simple" table: limit[x] = x */
484
0
    for (i = 0; i <= MAXJSAMPLE; i++)
485
0
      table[i] = (JSAMPLE)i;
486
0
    table += CENTERJSAMPLE;     /* Point to where post-IDCT table starts */
487
    /* End of simple table, rest of first half of post-IDCT table */
488
0
    for (i = CENTERJSAMPLE; i < 2 * (MAXJSAMPLE + 1); i++)
489
0
      table[i] = MAXJSAMPLE;
490
    /* Second half of post-IDCT table */
491
0
    memset(table + (2 * (MAXJSAMPLE + 1)), 0,
492
0
           (2 * (MAXJSAMPLE + 1) - CENTERJSAMPLE) * sizeof(JSAMPLE));
493
0
    memcpy(table + (4 * (MAXJSAMPLE + 1) - CENTERJSAMPLE),
494
0
           cinfo->sample_range_limit, CENTERJSAMPLE * sizeof(JSAMPLE));
495
0
  }
496
0
}
497
498
499
/*
500
 * Master selection of decompression modules.
501
 * This is done once at jpeg_start_decompress time.  We determine
502
 * which modules will be used and give them appropriate initialization calls.
503
 * We also initialize the decompressor input side to begin consuming data.
504
 *
505
 * Since jpeg_read_header has finished, we know what is in the SOF
506
 * and (first) SOS markers.  We also have all the application parameter
507
 * settings.
508
 */
509
510
LOCAL(void)
511
master_selection(j_decompress_ptr cinfo)
512
0
{
513
0
  my_master_ptr master = (my_master_ptr)cinfo->master;
514
0
  boolean use_c_buffer;
515
0
  long samplesperrow;
516
0
  JDIMENSION jd_samplesperrow;
517
518
  /* Disable IDCT scaling and raw (downsampled) data output in lossless mode.
519
   * IDCT scaling is not useful in lossless mode, and it must be disabled in
520
   * order to properly calculate the output dimensions.  Raw data output isn't
521
   * particularly useful without subsampling and has not been tested in
522
   * lossless mode.
523
   */
524
0
  if (cinfo->master->lossless) {
525
0
    cinfo->raw_data_out = FALSE;
526
0
    cinfo->scale_num = cinfo->scale_denom = 1;
527
0
  }
528
529
  /* Initialize dimensions and other stuff */
530
0
  jpeg_calc_output_dimensions(cinfo);
531
0
  prepare_range_limit_table(cinfo);
532
533
  /* Width of an output scanline must be representable as JDIMENSION. */
534
0
  samplesperrow = (long)cinfo->output_width *
535
0
                  (long)cinfo->out_color_components;
536
0
  jd_samplesperrow = (JDIMENSION)samplesperrow;
537
0
  if ((long)jd_samplesperrow != samplesperrow)
538
0
    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
539
540
  /* Initialize my private state */
541
0
  master->pass_number = 0;
542
0
  master->using_merged_upsample = use_merged_upsample(cinfo);
543
544
  /* Color quantizer selection */
545
0
  master->quantizer_1pass = NULL;
546
0
  master->quantizer_2pass = NULL;
547
  /* No mode changes if not using buffered-image mode. */
548
0
  if (!cinfo->quantize_colors || !cinfo->buffered_image) {
549
0
    cinfo->enable_1pass_quant = FALSE;
550
0
    cinfo->enable_external_quant = FALSE;
551
0
    cinfo->enable_2pass_quant = FALSE;
552
0
  }
553
0
  if (cinfo->quantize_colors) {
554
0
    if (cinfo->raw_data_out)
555
0
      ERREXIT(cinfo, JERR_NOTIMPL);
556
    /* 2-pass quantizer only works in 3-component color space. */
557
0
    if (cinfo->out_color_components != 3 ||
558
0
        cinfo->out_color_space == JCS_RGB565) {
559
0
      cinfo->enable_1pass_quant = TRUE;
560
0
      cinfo->enable_external_quant = FALSE;
561
0
      cinfo->enable_2pass_quant = FALSE;
562
0
      cinfo->colormap = NULL;
563
0
    } else if (cinfo->colormap != NULL) {
564
0
      cinfo->enable_external_quant = TRUE;
565
0
    } else if (cinfo->two_pass_quantize) {
566
0
      cinfo->enable_2pass_quant = TRUE;
567
0
    } else {
568
0
      cinfo->enable_1pass_quant = TRUE;
569
0
    }
570
571
0
    if (cinfo->enable_1pass_quant) {
572
0
#ifdef QUANT_1PASS_SUPPORTED
573
0
      if (cinfo->data_precision == 16)
574
0
        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
575
0
      else if (cinfo->data_precision == 12)
576
0
        j12init_1pass_quantizer(cinfo);
577
0
      else
578
0
        jinit_1pass_quantizer(cinfo);
579
0
      master->quantizer_1pass = cinfo->cquantize;
580
#else
581
      ERREXIT(cinfo, JERR_NOT_COMPILED);
582
#endif
583
0
    }
584
585
    /* We use the 2-pass code to map to external colormaps. */
586
0
    if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
587
0
#ifdef QUANT_2PASS_SUPPORTED
588
0
      if (cinfo->data_precision == 16)
589
0
        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
590
0
      else if (cinfo->data_precision == 12)
591
0
        j12init_2pass_quantizer(cinfo);
592
0
      else
593
0
        jinit_2pass_quantizer(cinfo);
594
0
      master->quantizer_2pass = cinfo->cquantize;
595
#else
596
      ERREXIT(cinfo, JERR_NOT_COMPILED);
597
#endif
598
0
    }
599
    /* If both quantizers are initialized, the 2-pass one is left active;
600
     * this is necessary for starting with quantization to an external map.
601
     */
602
0
  }
603
604
  /* Post-processing: in particular, color conversion first */
605
0
  if (!cinfo->raw_data_out) {
606
0
    if (master->using_merged_upsample) {
607
0
#ifdef UPSAMPLE_MERGING_SUPPORTED
608
0
      if (cinfo->data_precision == 16)
609
0
        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
610
0
      else if (cinfo->data_precision == 12)
611
0
        j12init_merged_upsampler(cinfo); /* does color conversion too */
612
0
      else
613
0
        jinit_merged_upsampler(cinfo); /* does color conversion too */
614
#else
615
      ERREXIT(cinfo, JERR_NOT_COMPILED);
616
#endif
617
0
    } else {
618
0
      if (cinfo->data_precision == 16) {
619
0
#ifdef D_LOSSLESS_SUPPORTED
620
0
        j16init_color_deconverter(cinfo);
621
0
        j16init_upsampler(cinfo);
622
#else
623
        ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
624
#endif
625
0
      } else if (cinfo->data_precision == 12) {
626
0
        j12init_color_deconverter(cinfo);
627
0
        j12init_upsampler(cinfo);
628
0
      } else {
629
0
        jinit_color_deconverter(cinfo);
630
0
        jinit_upsampler(cinfo);
631
0
      }
632
0
    }
633
0
    if (cinfo->data_precision == 16)
634
0
#ifdef D_LOSSLESS_SUPPORTED
635
0
      j16init_d_post_controller(cinfo, cinfo->enable_2pass_quant);
636
#else
637
      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
638
#endif
639
0
    else if (cinfo->data_precision == 12)
640
0
      j12init_d_post_controller(cinfo, cinfo->enable_2pass_quant);
641
0
    else
642
0
      jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
643
0
  }
644
645
0
  if (cinfo->master->lossless) {
646
0
#ifdef D_LOSSLESS_SUPPORTED
647
    /* Prediction, sample undifferencing, point transform, and sample size
648
     * scaling
649
     */
650
0
    if (cinfo->data_precision == 16)
651
0
      j16init_lossless_decompressor(cinfo);
652
0
    else if (cinfo->data_precision == 12)
653
0
      j12init_lossless_decompressor(cinfo);
654
0
    else
655
0
      jinit_lossless_decompressor(cinfo);
656
    /* Entropy decoding: either Huffman or arithmetic coding. */
657
0
    if (cinfo->arith_code) {
658
0
      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
659
0
    } else {
660
0
      jinit_lhuff_decoder(cinfo);
661
0
    }
662
663
    /* Initialize principal buffer controllers. */
664
0
    use_c_buffer = cinfo->inputctl->has_multiple_scans ||
665
0
                   cinfo->buffered_image;
666
0
    if (cinfo->data_precision == 16)
667
0
      j16init_d_diff_controller(cinfo, use_c_buffer);
668
0
    else if (cinfo->data_precision == 12)
669
0
      j12init_d_diff_controller(cinfo, use_c_buffer);
670
0
    else
671
0
      jinit_d_diff_controller(cinfo, use_c_buffer);
672
#else
673
    ERREXIT(cinfo, JERR_NOT_COMPILED);
674
#endif
675
0
  } else {
676
0
    if (cinfo->data_precision == 16)
677
0
      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
678
    /* Inverse DCT */
679
0
    if (cinfo->data_precision == 12)
680
0
      j12init_inverse_dct(cinfo);
681
0
    else
682
0
      jinit_inverse_dct(cinfo);
683
    /* Entropy decoding: either Huffman or arithmetic coding. */
684
0
    if (cinfo->arith_code) {
685
0
#ifdef D_ARITH_CODING_SUPPORTED
686
0
      jinit_arith_decoder(cinfo);
687
#else
688
      ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
689
#endif
690
0
    } else {
691
0
      if (cinfo->progressive_mode) {
692
0
#ifdef D_PROGRESSIVE_SUPPORTED
693
0
        jinit_phuff_decoder(cinfo);
694
#else
695
        ERREXIT(cinfo, JERR_NOT_COMPILED);
696
#endif
697
0
      } else
698
0
        jinit_huff_decoder(cinfo);
699
0
    }
700
701
    /* Initialize principal buffer controllers. */
702
0
    use_c_buffer = cinfo->inputctl->has_multiple_scans ||
703
0
                   cinfo->buffered_image;
704
0
    if (cinfo->data_precision == 12)
705
0
      j12init_d_coef_controller(cinfo, use_c_buffer);
706
0
    else
707
0
      jinit_d_coef_controller(cinfo, use_c_buffer);
708
0
  }
709
710
0
  if (!cinfo->raw_data_out) {
711
0
    if (cinfo->data_precision == 16)
712
0
#ifdef D_LOSSLESS_SUPPORTED
713
0
      j16init_d_main_controller(cinfo,
714
0
                                FALSE /* never need full buffer here */);
715
#else
716
      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
717
#endif
718
0
    else if (cinfo->data_precision == 12)
719
0
      j12init_d_main_controller(cinfo,
720
0
                                FALSE /* never need full buffer here */);
721
0
    else
722
0
      jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
723
0
  }
724
725
  /* We can now tell the memory manager to allocate virtual arrays. */
726
0
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
727
728
  /* Initialize input side of decompressor to consume first scan. */
729
0
  (*cinfo->inputctl->start_input_pass) (cinfo);
730
731
  /* Set the first and last iMCU columns to decompress from single-scan images.
732
   * By default, decompress all of the iMCU columns.
733
   */
734
0
  cinfo->master->first_iMCU_col = 0;
735
0
  cinfo->master->last_iMCU_col = cinfo->MCUs_per_row - 1;
736
0
  cinfo->master->last_good_iMCU_row = 0;
737
738
0
#ifdef D_MULTISCAN_FILES_SUPPORTED
739
  /* If jpeg_start_decompress will read the whole file, initialize
740
   * progress monitoring appropriately.  The input step is counted
741
   * as one pass.
742
   */
743
0
  if (cinfo->progress != NULL && !cinfo->buffered_image &&
744
0
      cinfo->inputctl->has_multiple_scans) {
745
0
    int nscans;
746
    /* Estimate number of scans to set pass_limit. */
747
0
    if (cinfo->progressive_mode) {
748
      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
749
0
      nscans = 2 + 3 * cinfo->num_components;
750
0
    } else {
751
      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
752
0
      nscans = cinfo->num_components;
753
0
    }
754
0
    cinfo->progress->pass_counter = 0L;
755
0
    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
756
0
    cinfo->progress->completed_passes = 0;
757
0
    cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
758
    /* Count the input pass as done */
759
0
    master->pass_number++;
760
0
  }
761
0
#endif /* D_MULTISCAN_FILES_SUPPORTED */
762
0
}
763
764
765
/*
766
 * Per-pass setup.
767
 * This is called at the beginning of each output pass.  We determine which
768
 * modules will be active during this pass and give them appropriate
769
 * start_pass calls.  We also set is_dummy_pass to indicate whether this
770
 * is a "real" output pass or a dummy pass for color quantization.
771
 * (In the latter case, jdapistd.c will crank the pass to completion.)
772
 */
773
774
METHODDEF(void)
775
prepare_for_output_pass(j_decompress_ptr cinfo)
776
0
{
777
0
  my_master_ptr master = (my_master_ptr)cinfo->master;
778
779
0
  if (master->pub.is_dummy_pass) {
780
0
#ifdef QUANT_2PASS_SUPPORTED
781
    /* Final pass of 2-pass quantization */
782
0
    master->pub.is_dummy_pass = FALSE;
783
0
    (*cinfo->cquantize->start_pass) (cinfo, FALSE);
784
0
    (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
785
0
    (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
786
#else
787
    ERREXIT(cinfo, JERR_NOT_COMPILED);
788
#endif /* QUANT_2PASS_SUPPORTED */
789
0
  } else {
790
0
    if (cinfo->quantize_colors && cinfo->colormap == NULL) {
791
      /* Select new quantization method */
792
0
      if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
793
0
        cinfo->cquantize = master->quantizer_2pass;
794
0
        master->pub.is_dummy_pass = TRUE;
795
0
      } else if (cinfo->enable_1pass_quant) {
796
0
        cinfo->cquantize = master->quantizer_1pass;
797
0
      } else {
798
0
        ERREXIT(cinfo, JERR_MODE_CHANGE);
799
0
      }
800
0
    }
801
0
    (*cinfo->idct->start_pass) (cinfo);
802
0
    (*cinfo->coef->start_output_pass) (cinfo);
803
0
    if (!cinfo->raw_data_out) {
804
0
      if (!master->using_merged_upsample)
805
0
        (*cinfo->cconvert->start_pass) (cinfo);
806
0
      (*cinfo->upsample->start_pass) (cinfo);
807
0
      if (cinfo->quantize_colors)
808
0
        (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
809
0
      (*cinfo->post->start_pass) (cinfo,
810
0
            (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
811
0
      (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
812
0
    }
813
0
  }
814
815
  /* Set up progress monitor's pass info if present */
816
0
  if (cinfo->progress != NULL) {
817
0
    cinfo->progress->completed_passes = master->pass_number;
818
0
    cinfo->progress->total_passes = master->pass_number +
819
0
                                    (master->pub.is_dummy_pass ? 2 : 1);
820
    /* In buffered-image mode, we assume one more output pass if EOI not
821
     * yet reached, but no more passes if EOI has been reached.
822
     */
823
0
    if (cinfo->buffered_image && !cinfo->inputctl->eoi_reached) {
824
0
      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
825
0
    }
826
0
  }
827
0
}
828
829
830
/*
831
 * Finish up at end of an output pass.
832
 */
833
834
METHODDEF(void)
835
finish_output_pass(j_decompress_ptr cinfo)
836
0
{
837
0
  my_master_ptr master = (my_master_ptr)cinfo->master;
838
839
0
  if (cinfo->quantize_colors)
840
0
    (*cinfo->cquantize->finish_pass) (cinfo);
841
0
  master->pass_number++;
842
0
}
843
844
845
#ifdef D_MULTISCAN_FILES_SUPPORTED
846
847
/*
848
 * Switch to a new external colormap between output passes.
849
 */
850
851
GLOBAL(void)
852
jpeg_new_colormap(j_decompress_ptr cinfo)
853
0
{
854
0
  my_master_ptr master = (my_master_ptr)cinfo->master;
855
856
  /* Prevent application from calling me at wrong times */
857
0
  if (cinfo->global_state != DSTATE_BUFIMAGE)
858
0
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
859
860
0
  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
861
0
      cinfo->colormap != NULL) {
862
    /* Select 2-pass quantizer for external colormap use */
863
0
    cinfo->cquantize = master->quantizer_2pass;
864
    /* Notify quantizer of colormap change */
865
0
    (*cinfo->cquantize->new_color_map) (cinfo);
866
0
    master->pub.is_dummy_pass = FALSE; /* just in case */
867
0
  } else
868
0
    ERREXIT(cinfo, JERR_MODE_CHANGE);
869
0
}
870
871
#endif /* D_MULTISCAN_FILES_SUPPORTED */
872
873
874
/*
875
 * Initialize master decompression control and select active modules.
876
 * This is performed at the start of jpeg_start_decompress.
877
 */
878
879
GLOBAL(void)
880
jinit_master_decompress(j_decompress_ptr cinfo)
881
0
{
882
0
  my_master_ptr master = (my_master_ptr)cinfo->master;
883
884
0
  master->pub.prepare_for_output_pass = prepare_for_output_pass;
885
0
  master->pub.finish_output_pass = finish_output_pass;
886
887
0
  master->pub.is_dummy_pass = FALSE;
888
0
  master->pub.jinit_upsampler_no_alloc = FALSE;
889
890
0
  master_selection(cinfo);
891
0
}