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