home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / jpeg / jdmaster.c < prev    next >
C/C++ Source or Header  |  2002-10-16  |  20KB  |  558 lines
  1. /*
  2.  * jdmaster.c
  3.  *
  4.  * Copyright (C) 1991-1997, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file contains master control logic for the JPEG decompressor.
  9.  * These routines are concerned with selecting the modules to be executed
  10.  * and with determining the number of passes and the work to be done in each
  11.  * pass.
  12.  */
  13.  
  14. #define JPEG_INTERNALS
  15. #include "jinclude.h"
  16. #include "jpeglib.h"
  17.  
  18. /* Private state */
  19.  
  20. typedef struct {
  21.   struct jpeg_decomp_master pub; /* public fields */
  22.  
  23.   int pass_number;        /* # of passes completed */
  24.  
  25.   boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
  26.  
  27.   /* Saved references to initialized quantizer modules,
  28.    * in case we need to switch modes.
  29.    */
  30.   struct jpeg_color_quantizer * quantizer_1pass;
  31.   struct jpeg_color_quantizer * quantizer_2pass;
  32. } my_decomp_master;
  33.  
  34. typedef my_decomp_master * my_master_ptr;
  35.  
  36.  
  37. /*
  38.  * Determine whether merged upsample/color conversion should be used.
  39.  * CRUCIAL: this must match the actual capabilities of jdmerge.c!
  40.  */
  41.  
  42. LOCAL(boolean)
  43. use_merged_upsample (j_decompress_ptr cinfo)
  44. {
  45. #ifdef UPSAMPLE_MERGING_SUPPORTED
  46.   /* Merging is the equivalent of plain box-filter upsampling */
  47.   if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
  48.     return FALSE;
  49.   /* jdmerge.c only supports YCC=>RGB color conversion */
  50.   if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
  51.       cinfo->out_color_space != JCS_RGB ||
  52.       cinfo->out_color_components != RGB_PIXELSIZE)
  53.     return FALSE;
  54.   /* and it only handles 2h1v or 2h2v sampling ratios */
  55.   if (cinfo->comp_info[0].h_samp_factor != 2 ||
  56.       cinfo->comp_info[1].h_samp_factor != 1 ||
  57.       cinfo->comp_info[2].h_samp_factor != 1 ||
  58.       cinfo->comp_info[0].v_samp_factor >  2 ||
  59.       cinfo->comp_info[1].v_samp_factor != 1 ||
  60.       cinfo->comp_info[2].v_samp_factor != 1)
  61.     return FALSE;
  62.   /* furthermore, it doesn't work if we've scaled the IDCTs differently */
  63.   if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
  64.       cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
  65.       cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
  66.     return FALSE;
  67.   /* ??? also need to test for upsample-time rescaling, when & if supported */
  68.   return TRUE;            /* by golly, it'll work... */
  69. #else
  70.   return FALSE;
  71. #endif
  72. }
  73.  
  74.  
  75. /*
  76.  * Compute output image dimensions and related values.
  77.  * NOTE: this is exported for possible use by application.
  78.  * Hence it mustn't do anything that can't be done twice.
  79.  * Also note that it may be called before the master module is initialized!
  80.  */
  81.  
  82. GLOBAL(void)
  83. jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
  84. /* Do computations that are needed before master selection phase */
  85. {
  86. #ifdef IDCT_SCALING_SUPPORTED
  87.   int ci;
  88.   jpeg_component_info *compptr;
  89. #endif
  90.  
  91.   /* Prevent application from calling me at wrong times */
  92.   if (cinfo->global_state != DSTATE_READY)
  93.     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  94.  
  95. #ifdef IDCT_SCALING_SUPPORTED
  96.  
  97.   /* Compute actual output image dimensions and DCT scaling choices. */
  98.   if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
  99.     /* Provide 1/8 scaling */
  100.     cinfo->output_width = (JDIMENSION)
  101.       jdiv_round_up((long) cinfo->image_width, 8L);
  102.     cinfo->output_height = (JDIMENSION)
  103.       jdiv_round_up((long) cinfo->image_height, 8L);
  104.     cinfo->min_DCT_scaled_size = 1;
  105.   } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
  106.     /* Provide 1/4 scaling */
  107.     cinfo->output_width = (JDIMENSION)
  108.       jdiv_round_up((long) cinfo->image_width, 4L);
  109.     cinfo->output_height = (JDIMENSION)
  110.       jdiv_round_up((long) cinfo->image_height, 4L);
  111.     cinfo->min_DCT_scaled_size = 2;
  112.   } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
  113.     /* Provide 1/2 scaling */
  114.     cinfo->output_width = (JDIMENSION)
  115.       jdiv_round_up((long) cinfo->image_width, 2L);
  116.     cinfo->output_height = (JDIMENSION)
  117.       jdiv_round_up((long) cinfo->image_height, 2L);
  118.     cinfo->min_DCT_scaled_size = 4;
  119.   } else {
  120.     /* Provide 1/1 scaling */
  121.     cinfo->output_width = cinfo->image_width;
  122.     cinfo->output_height = cinfo->image_height;
  123.     cinfo->min_DCT_scaled_size = DCTSIZE;
  124.   }
  125.   /* In selecting the actual DCT scaling for each component, we try to
  126.    * scale up the chroma components via IDCT scaling rather than upsampling.
  127.    * This saves time if the upsampler gets to use 1:1 scaling.
  128.    * Note this code assumes that the supported DCT scalings are powers of 2.
  129.    */
  130.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  131.        ci++, compptr++) {
  132.     int ssize = cinfo->min_DCT_scaled_size;
  133.     while (ssize < DCTSIZE &&
  134.        (compptr->h_samp_factor * ssize * 2 <=
  135.         cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
  136.        (compptr->v_samp_factor * ssize * 2 <=
  137.         cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
  138.       ssize = ssize * 2;
  139.     }
  140.     compptr->DCT_scaled_size = ssize;
  141.   }
  142.  
  143.   /* Recompute downsampled dimensions of components;
  144.    * application needs to know these if using raw downsampled data.
  145.    */
  146.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  147.        ci++, compptr++) {
  148.     /* Size in samples, after IDCT scaling */
  149.     compptr->downsampled_width = (JDIMENSION)
  150.       jdiv_round_up((long) cinfo->image_width *
  151.             (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
  152.             (long) (cinfo->max_h_samp_factor * DCTSIZE));
  153.     compptr->downsampled_height = (JDIMENSION)
  154.       jdiv_round_up((long) cinfo->image_height *
  155.             (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
  156.             (long) (cinfo->max_v_samp_factor * DCTSIZE));
  157.   }
  158.  
  159. #else /* !IDCT_SCALING_SUPPORTED */
  160.  
  161.   /* Hardwire it to "no scaling" */
  162.   cinfo->output_width = cinfo->image_width;
  163.   cinfo->output_height = cinfo->image_height;
  164.   /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
  165.    * and has computed unscaled downsampled_width and downsampled_height.
  166.    */
  167.  
  168. #endif /* IDCT_SCALING_SUPPORTED */
  169.  
  170.   /* Report number of components in selected colorspace. */
  171.   /* Probably this should be in the color conversion module... */
  172.   switch (cinfo->out_color_space) {
  173.   case JCS_GRAYSCALE:
  174.     cinfo->out_color_components = 1;
  175.     break;
  176.   case JCS_RGB:
  177. #if RGB_PIXELSIZE != 3
  178.     cinfo->out_color_components = RGB_PIXELSIZE;
  179.     break;
  180. #endif /* else share code with YCbCr */
  181.   case JCS_YCbCr:
  182.     cinfo->out_color_components = 3;
  183.     break;
  184.   case JCS_CMYK:
  185.   case JCS_YCCK:
  186.     cinfo->out_color_components = 4;
  187.     break;
  188.   default:            /* else must be same colorspace as in file */
  189.     cinfo->out_color_components = cinfo->num_components;
  190.     break;
  191.   }
  192.   cinfo->output_components = (cinfo->quantize_colors ? 1 :
  193.                   cinfo->out_color_components);
  194.  
  195.   /* See if upsampler will want to emit more than one row at a time */
  196.   if (use_merged_upsample(cinfo))
  197.     cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
  198.   else
  199.     cinfo->rec_outbuf_height = 1;
  200. }
  201.  
  202.  
  203. /*
  204.  * Several decompression processes need to range-limit values to the range
  205.  * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
  206.  * due to noise introduced by quantization, roundoff error, etc.  These
  207.  * processes are inner loops and need to be as fast as possible.  On most
  208.  * machines, particularly CPUs with pipelines or instruction prefetch,
  209.  * a (subscript-check-less) C table lookup
  210.  *        x = sample_range_limit[x];
  211.  * is faster than explicit tests
  212.  *        if (x < 0)  x = 0;
  213.  *        else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
  214.  * These processes all use a common table prepared by the routine below.
  215.  *
  216.  * For most steps we can mathematically guarantee that the initial value
  217.  * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
  218.  * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
  219.  * limiting step (just after the IDCT), a wildly out-of-range value is
  220.  * possible if the input data is corrupt.  To avoid any chance of indexing
  221.  * off the end of memory and getting a bad-pointer trap, we perform the
  222.  * post-IDCT limiting thus:
  223.  *        x = range_limit[x & MASK];
  224.  * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
  225.  * samples.  Under normal circumstances this is more than enough range and
  226.  * a correct output will be generated; with bogus input data the mask will
  227.  * cause wraparound, and we will safely generate a bogus-but-in-range output.
  228.  * For the post-IDCT step, we want to convert the data from signed to unsigned
  229.  * representation by adding CENTERJSAMPLE at the same time that we limit it.
  230.  * So the post-IDCT limiting table ends up looking like this:
  231.  *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
  232.  *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
  233.  *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
  234.  *   0,1,...,CENTERJSAMPLE-1
  235.  * Negative inputs select values from the upper half of the table after
  236.  * masking.
  237.  *
  238.  * We can save some space by overlapping the start of the post-IDCT table
  239.  * with the simpler range limiting table.  The post-IDCT table begins at
  240.  * sample_range_limit + CENTERJSAMPLE.
  241.  *
  242.  * Note that the table is allocated in near data space on PCs; it's small
  243.  * enough and used often enough to justify this.
  244.  */
  245.  
  246. LOCAL(void)
  247. prepare_range_limit_table (j_decompress_ptr cinfo)
  248. /* Allocate and fill in the sample_range_limit table */
  249. {
  250.   JSAMPLE * table;
  251.   int i;
  252.  
  253.   table = (JSAMPLE *)
  254.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  255.         (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
  256.   table += (MAXJSAMPLE+1);    /* allow negative subscripts of simple table */
  257.   cinfo->sample_range_limit = table;
  258.   /* First segment of "simple" table: limit[x] = 0 for x < 0 */
  259.   MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
  260.   /* Main part of "simple" table: limit[x] = x */
  261.   for (i = 0; i <= MAXJSAMPLE; i++)
  262.     table[i] = (JSAMPLE) i;
  263.   table += CENTERJSAMPLE;    /* Point to where post-IDCT table starts */
  264.   /* End of simple table, rest of first half of post-IDCT table */
  265.   for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
  266.     table[i] = MAXJSAMPLE;
  267.   /* Second half of post-IDCT table */
  268.   MEMZERO(table + (2 * (MAXJSAMPLE+1)),
  269.       (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
  270.   MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
  271.       cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
  272. }
  273.  
  274.  
  275. /*
  276.  * Master selection of decompression modules.
  277.  * This is done once at jpeg_start_decompress time.  We determine
  278.  * which modules will be used and give them appropriate initialization calls.
  279.  * We also initialize the decompressor input side to begin consuming data.
  280.  *
  281.  * Since jpeg_read_header has finished, we know what is in the SOF
  282.  * and (first) SOS markers.  We also have all the application parameter
  283.  * settings.
  284.  */
  285.  
  286. LOCAL(void)
  287. master_selection (j_decompress_ptr cinfo)
  288. {
  289.   my_master_ptr master = (my_master_ptr) cinfo->master;
  290.   boolean use_c_buffer;
  291.   long samplesperrow;
  292.   JDIMENSION jd_samplesperrow;
  293.  
  294.   /* Initialize dimensions and other stuff */
  295.   jpeg_calc_output_dimensions(cinfo);
  296.   prepare_range_limit_table(cinfo);
  297.  
  298.   /* Width of an output scanline must be representable as JDIMENSION. */
  299.   samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
  300.   jd_samplesperrow = (JDIMENSION) samplesperrow;
  301.   if ((long) jd_samplesperrow != samplesperrow)
  302.     ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
  303.  
  304.   /* Initialize my private state */
  305.   master->pass_number = 0;
  306.   master->using_merged_upsample = use_merged_upsample(cinfo);
  307.  
  308.   /* Color quantizer selection */
  309.   master->quantizer_1pass = NULL;
  310.   master->quantizer_2pass = NULL;
  311.   /* No mode changes if not using buffered-image mode. */
  312.   if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
  313.     cinfo->enable_1pass_quant = FALSE;
  314.     cinfo->enable_external_quant = FALSE;
  315.     cinfo->enable_2pass_quant = FALSE;
  316.   }
  317.   if (cinfo->quantize_colors) {
  318.     if (cinfo->raw_data_out)
  319.       ERREXIT(cinfo, JERR_NOTIMPL);
  320.     /* 2-pass quantizer only works in 3-component color space. */
  321.     if (cinfo->out_color_components != 3) {
  322.       cinfo->enable_1pass_quant = TRUE;
  323.       cinfo->enable_external_quant = FALSE;
  324.       cinfo->enable_2pass_quant = FALSE;
  325.       cinfo->colormap = NULL;
  326.     } else if (cinfo->colormap != NULL) {
  327.       cinfo->enable_external_quant = TRUE;
  328.     } else if (cinfo->two_pass_quantize) {
  329.       cinfo->enable_2pass_quant = TRUE;
  330.     } else {
  331.       cinfo->enable_1pass_quant = TRUE;
  332.     }
  333.  
  334.     if (cinfo->enable_1pass_quant) {
  335. #ifdef QUANT_1PASS_SUPPORTED
  336.       jinit_1pass_quantizer(cinfo);
  337.       master->quantizer_1pass = cinfo->cquantize;
  338. #else
  339.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  340. #endif
  341.     }
  342.  
  343.     /* We use the 2-pass code to map to external colormaps. */
  344.     if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
  345. #ifdef QUANT_2PASS_SUPPORTED
  346.       jinit_2pass_quantizer(cinfo);
  347.       master->quantizer_2pass = cinfo->cquantize;
  348. #else
  349.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  350. #endif
  351.     }
  352.     /* If both quantizers are initialized, the 2-pass one is left active;
  353.      * this is necessary for starting with quantization to an external map.
  354.      */
  355.   }
  356.  
  357.   /* Post-processing: in particular, color conversion first */
  358.   if (! cinfo->raw_data_out) {
  359.     if (master->using_merged_upsample) {
  360. #ifdef UPSAMPLE_MERGING_SUPPORTED
  361.       jinit_merged_upsampler(cinfo); /* does color conversion too */
  362. #else
  363.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  364. #endif
  365.     } else {
  366.       jinit_color_deconverter(cinfo);
  367.       jinit_upsampler(cinfo);
  368.     }
  369.     jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
  370.   }
  371.   /* Inverse DCT */
  372.   jinit_inverse_dct(cinfo);
  373.   /* Entropy decoding: either Huffman or arithmetic coding. */
  374.   if (cinfo->arith_code) {
  375.     ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
  376.   } else {
  377.     if (cinfo->progressive_mode) {
  378. #ifdef D_PROGRESSIVE_SUPPORTED
  379.       jinit_phuff_decoder(cinfo);
  380. #else
  381.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  382. #endif
  383.     } else
  384.       jinit_huff_decoder(cinfo);
  385.   }
  386.  
  387.   /* Initialize principal buffer controllers. */
  388.   use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
  389.   jinit_d_coef_controller(cinfo, use_c_buffer);
  390.  
  391.   if (! cinfo->raw_data_out)
  392.     jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
  393.  
  394.   /* We can now tell the memory manager to allocate virtual arrays. */
  395.   (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
  396.  
  397.   /* Initialize input side of decompressor to consume first scan. */
  398.   (*cinfo->inputctl->start_input_pass) (cinfo);
  399.  
  400. #ifdef D_MULTISCAN_FILES_SUPPORTED
  401.   /* If jpeg_start_decompress will read the whole file, initialize
  402.    * progress monitoring appropriately.  The input step is counted
  403.    * as one pass.
  404.    */
  405.   if (cinfo->progress != NULL && ! cinfo->buffered_image &&
  406.       cinfo->inputctl->has_multiple_scans) {
  407.     int nscans;
  408.     /* Estimate number of scans to set pass_limit. */
  409.     if (cinfo->progressive_mode) {
  410.       /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
  411.       nscans = 2 + 3 * cinfo->num_components;
  412.     } else {
  413.       /* For a nonprogressive multiscan file, estimate 1 scan per component. */
  414.       nscans = cinfo->num_components;
  415.     }
  416.     cinfo->progress->pass_counter = 0L;
  417.     cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
  418.     cinfo->progress->completed_passes = 0;
  419.     cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
  420.     /* Count the input pass as done */
  421.     master->pass_number++;
  422.   }
  423. #endif /* D_MULTISCAN_FILES_SUPPORTED */
  424. }
  425.  
  426.  
  427. /*
  428.  * Per-pass setup.
  429.  * This is called at the beginning of each output pass.  We determine which
  430.  * modules will be active during this pass and give them appropriate
  431.  * start_pass calls.  We also set is_dummy_pass to indicate whether this
  432.  * is a "real" output pass or a dummy pass for color quantization.
  433.  * (In the latter case, jdapistd.c will crank the pass to completion.)
  434.  */
  435.  
  436. METHODDEF(void)
  437. prepare_for_output_pass (j_decompress_ptr cinfo)
  438. {
  439.   my_master_ptr master = (my_master_ptr) cinfo->master;
  440.  
  441.   if (master->pub.is_dummy_pass) {
  442. #ifdef QUANT_2PASS_SUPPORTED
  443.     /* Final pass of 2-pass quantization */
  444.     master->pub.is_dummy_pass = FALSE;
  445.     (*cinfo->cquantize->start_pass) (cinfo, FALSE);
  446.     (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
  447.     (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
  448. #else
  449.     ERREXIT(cinfo, JERR_NOT_COMPILED);
  450. #endif /* QUANT_2PASS_SUPPORTED */
  451.   } else {
  452.     if (cinfo->quantize_colors && cinfo->colormap == NULL) {
  453.       /* Select new quantization method */
  454.       if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
  455.     cinfo->cquantize = master->quantizer_2pass;
  456.     master->pub.is_dummy_pass = TRUE;
  457.       } else if (cinfo->enable_1pass_quant) {
  458.     cinfo->cquantize = master->quantizer_1pass;
  459.       } else {
  460.     ERREXIT(cinfo, JERR_MODE_CHANGE);
  461.       }
  462.     }
  463.     (*cinfo->idct->start_pass) (cinfo);
  464.     (*cinfo->coef->start_output_pass) (cinfo);
  465.     if (! cinfo->raw_data_out) {
  466.       if (! master->using_merged_upsample)
  467.     (*cinfo->cconvert->start_pass) (cinfo);
  468.       (*cinfo->upsample->start_pass) (cinfo);
  469.       if (cinfo->quantize_colors)
  470.     (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
  471.       (*cinfo->post->start_pass) (cinfo,
  472.         (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
  473.       (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
  474.     }
  475.   }
  476.  
  477.   /* Set up progress monitor's pass info if present */
  478.   if (cinfo->progress != NULL) {
  479.     cinfo->progress->completed_passes = master->pass_number;
  480.     cinfo->progress->total_passes = master->pass_number +
  481.                     (master->pub.is_dummy_pass ? 2 : 1);
  482.     /* In buffered-image mode, we assume one more output pass if EOI not
  483.      * yet reached, but no more passes if EOI has been reached.
  484.      */
  485.     if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
  486.       cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
  487.     }
  488.   }
  489. }
  490.  
  491.  
  492. /*
  493.  * Finish up at end of an output pass.
  494.  */
  495.  
  496. METHODDEF(void)
  497. finish_output_pass (j_decompress_ptr cinfo)
  498. {
  499.   my_master_ptr master = (my_master_ptr) cinfo->master;
  500.  
  501.   if (cinfo->quantize_colors)
  502.     (*cinfo->cquantize->finish_pass) (cinfo);
  503.   master->pass_number++;
  504. }
  505.  
  506.  
  507. #ifdef D_MULTISCAN_FILES_SUPPORTED
  508.  
  509. /*
  510.  * Switch to a new external colormap between output passes.
  511.  */
  512.  
  513. GLOBAL(void)
  514. jpeg_new_colormap (j_decompress_ptr cinfo)
  515. {
  516.   my_master_ptr master = (my_master_ptr) cinfo->master;
  517.  
  518.   /* Prevent application from calling me at wrong times */
  519.   if (cinfo->global_state != DSTATE_BUFIMAGE)
  520.     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  521.  
  522.   if (cinfo->quantize_colors && cinfo->enable_external_quant &&
  523.       cinfo->colormap != NULL) {
  524.     /* Select 2-pass quantizer for external colormap use */
  525.     cinfo->cquantize = master->quantizer_2pass;
  526.     /* Notify quantizer of colormap change */
  527.     (*cinfo->cquantize->new_color_map) (cinfo);
  528.     master->pub.is_dummy_pass = FALSE; /* just in case */
  529.   } else
  530.     ERREXIT(cinfo, JERR_MODE_CHANGE);
  531. }
  532.  
  533. #endif /* D_MULTISCAN_FILES_SUPPORTED */
  534.  
  535.  
  536. /*
  537.  * Initialize master decompression control and select active modules.
  538.  * This is performed at the start of jpeg_start_decompress.
  539.  */
  540.  
  541. GLOBAL(void)
  542. jinit_master_decompress (j_decompress_ptr cinfo)
  543. {
  544.   my_master_ptr master;
  545.  
  546.   master = (my_master_ptr)
  547.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  548.                   SIZEOF(my_decomp_master));
  549.   cinfo->master = (struct jpeg_decomp_master *) master;
  550.   master->pub.prepare_for_output_pass = prepare_for_output_pass;
  551.   master->pub.finish_output_pass = finish_output_pass;
  552.  
  553.   master->pub.is_dummy_pass = FALSE;
  554.  
  555.   master_selection(cinfo);
  556. }
  557.  
  558.