#define JPEG_INTERNALS#include "jpeglib.h"/* Private state */typedef struct {  struct jpeg_decomp_master pub; /* public fields */  int pass_number;		/* # of passes completed */  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */  /* Saved references to initialized quantizer modules,   * in case we need to switch modes.   */  struct jpeg_color_quantizer * quantizer_1pass;  struct jpeg_color_quantizer * quantizer_2pass;} my_decomp_master;typedef my_decomp_master * my_master_ptr;/* * Determine whether merged upsample/color conversion should be used. * CRUCIAL: this must match the actual capabilities of jdmerge.c! */LOCAL(boolean)use_merged_upsample (j_decompress_ptr cinfo){#ifdef UPSAMPLE_MERGING_SUPPORTED  /* Merging is the equivalent of plain box-filter upsampling */  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)    return FALSE;  /* jdmerge.c only supports YCC=>RGB color conversion */  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||      cinfo->out_color_space != JCS_RGB ||      cinfo->out_color_components != RGB_PIXELSIZE)    return FALSE;  /* and it only handles 2h1v or 2h2v sampling ratios */  if (cinfo->comp_info[0].h_samp_factor != 2 ||      cinfo->comp_info[1].h_samp_factor != 1 ||      cinfo->comp_info[2].h_samp_factor != 1 ||      cinfo->comp_info[0].v_samp_factor >  2 ||      cinfo->comp_info[1].v_samp_factor != 1 ||      cinfo->comp_info[2].v_samp_factor != 1)    return FALSE;  /* furthermore, it doesn't work if we've scaled the IDCTs differently */  if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||      cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||      cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)    return FALSE;  /* ??? also need to test for upsample-time rescaling, when & if supported */  return TRUE;			/* by golly, it'll work... */#else  return FALSE;#endif}/* * Compute output image dimensions and related values. * NOTE: this is exported for possible use by application. * Hence it mustn't do anything that can't be done twice. * Also note that it may be called before the master module is initialized! */GLOBAL(void)jpeg_calc_output_dimensions (j_decompress_ptr cinfo)/* Do computations that are needed before master selection phase */{  int ci;  jpeg_component_info *compptr;  /* Prevent application from calling me at wrong times */  if (cinfo->global_state != DSTATE_READY)    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);#ifdef IDCT_SCALING_SUPPORTED  /* Compute actual output image dimensions and DCT scaling choices. */  if (cinfo->scale_num * 8 <= cinfo->scale_denom) {    /* Provide 1/8 scaling */    cinfo->output_width = (JDIMENSION)      jdiv_round_up((long) cinfo->image_width, 8L);    cinfo->output_height = (JDIMENSION)      jdiv_round_up((long) cinfo->image_height, 8L);    cinfo->min_DCT_scaled_size = 1;  } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {    /* Provide 1/4 scaling */    cinfo->output_width = (JDIMENSION)      jdiv_round_up((long) cinfo->image_width, 4L);    cinfo->output_height = (JDIMENSION)      jdiv_round_up((long) cinfo->image_height, 4L);    cinfo->min_DCT_scaled_size = 2;  } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {    /* Provide 1/2 scaling */    cinfo->output_width = (JDIMENSION)      jdiv_round_up((long) cinfo->image_width, 2L);    cinfo->output_height = (JDIMENSION)      jdiv_round_up((long) cinfo->image_height, 2L);    cinfo->min_DCT_scaled_size = 4;  } else {    /* Provide 1/1 scaling */    cinfo->output_width = cinfo->image_width;    cinfo->output_height = cinfo->image_height;    cinfo->min_DCT_scaled_size = DCTSIZE;  }  /* In selecting the actual DCT scaling for each component, we try to   * scale up the chroma components via IDCT scaling rather than upsampling.   * This saves time if the upsampler gets to use 1:1 scaling.   * Note this code assumes that the supported DCT scalings are powers of 2.   */  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;       ci++, compptr++) {    int ssize = cinfo->min_DCT_scaled_size;    while (ssize < DCTSIZE &&	   (compptr->h_samp_factor * ssize * 2 <=	    cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&	   (compptr->v_samp_factor * ssize * 2 <=	    cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {      ssize = ssize * 2;    }    compptr->DCT_scaled_size = ssize;  }  /* Recompute downsampled dimensions of components;   * application needs to know these if using raw downsampled data.   */  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;       ci++, compptr++) {    /* Size in samples, after IDCT scaling */    compptr->downsampled_width = (JDIMENSION)      jdiv_round_up((long) cinfo->image_width *		    (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),		    (long) (cinfo->max_h_samp_factor * DCTSIZE));    compptr->downsampled_height = (JDIMENSION)      jdiv_round_up((long) cinfo->image_height *		    (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),		    (long) (cinfo->max_v_samp_factor * DCTSIZE));  }#else /* !IDCT_SCALING_SUPPORTED */  /* Hardwire it to "no scaling" */  cinfo->output_width = cinfo->image_width;  cinfo->output_height = cinfo->image_height;  /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,   * and has computed unscaled downsampled_width and downsampled_height.   */#endif /* IDCT_SCALING_SUPPORTED */  /* Report number of components in selected colorspace. */  /* Probably this should be in the color conversion module... */  switch (cinfo->out_color_space) {  case JCS_GRAYSCALE:    cinfo->out_color_components = 1;    break;  case JCS_RGB:#if RGB_PIXELSIZE != 3    cinfo->out_color_components = RGB_PIXELSIZE;    break;#endif /* else share code with YCbCr */  case JCS_YCbCr:    cinfo->out_color_components = 3;    break;  case JCS_CMYK:  case JCS_YCCK:    cinfo->out_color_components = 4;    break;  default:			/* else must be same colorspace as in file */    cinfo->out_color_components = cinfo->num_components;    break;  }  cinfo->output_components = (cinfo->quantize_colors ? 1 :			      cinfo->out_color_components);  /* See if upsampler will want to emit more than one row at a time */  if (use_merged_upsample(cinfo))    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;  else    cinfo->rec_outbuf_height = 1;}/* * Several decompression processes need to range-limit values to the range * 0..MAXJSAMPLE; the input value may fall somewhat outside this range * due to noise introduced by quantization, roundoff error, etc.  These * processes are inner loops and need to be as fast as possible.  On most * machines, particularly CPUs with pipelines or instruction prefetch, * a (subscript-check-less) C table lookup *		x = sample_range_limit[x]; * is faster than explicit tests *		if (x < 0)  x = 0; *		else if (x > MAXJSAMPLE)  x = MAXJSAMPLE; * These processes all use a common table prepared by the routine below. * * For most steps we can mathematically guarantee that the initial value * of x is within MAXJSAMPLE+1 of the legal range, so a table running from * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial * limiting step (just after the IDCT), a wildly out-of-range value is  * possible if the input data is corrupt.  To avoid any chance of indexing * off the end of memory and getting a bad-pointer trap, we perform the * post-IDCT limiting thus: *		x = range_limit[x & MASK]; * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit * samples.  Under normal circumstances this is more than enough range and * a correct output will be generated; with bogus input data the mask will * cause wraparound, and we will safely generate a bogus-but-in-range output. * For the post-IDCT step, we want to convert the data from signed to unsigned * representation by adding CENTERJSAMPLE at the same time that we limit it. * So the post-IDCT limiting table ends up looking like this: *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE, *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), *   0,1,...,CENTERJSAMPLE-1 * Negative inputs select values from the upper half of the table after * masking. * * We can save some space by overlapping the start of the post-IDCT table * with the simpler range limiting table.  The post-IDCT table begins at * sample_range_limit + CENTERJSAMPLE. * * Note that the table is allocated in near data space on PCs; it's small * enough and used often enough to justify this. */LOCAL(void)prepare_range_limit_table (j_decompress_ptr cinfo)/* Allocate and fill in the sample_range_limit table */{  JSAMPLE * table;  int i;  table = (JSAMPLE *)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,		(5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));  table += (MAXJSAMPLE+1);	/* allow negative subscripts of simple table */  cinfo->sample_range_limit = table;  /* First segment of "simple" table: limit[x] = 0 for x < 0 */  MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));  /* Main part of "simple" table: limit[x] = x */  for (i = 0; i <= MAXJSAMPLE; i++)    table[i] = (JSAMPLE) i;  table += CENTERJSAMPLE;	/* Point to where post-IDCT table starts */  /* End of simple table, rest of first half of post-IDCT table */  for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)    table[i] = (char)MAXJSAMPLE;  /* Second half of post-IDCT table */  MEMZERO(table + (2 * (MAXJSAMPLE+1)),	  (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));  MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),	  cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));}/*