jdmaster.c

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