} else {      /* work left to right in this row */      dir = 1;      dir3 = 3;      errorptr = cquantize->fserrors; /* => entry before first real column */      cquantize->on_odd_row = TRUE; /* flip for next time */    }    /* Preset error values: no error propagated to first pixel from left */    cur0 = cur1 = cur2 = 0;    /* and no error propagated to row below yet */    belowerr0 = belowerr1 = belowerr2 = 0;    bpreverr0 = bpreverr1 = bpreverr2 = 0;    for (col = width; col > 0; col--) {      /* curN holds the error propagated from the previous pixel on the       * current line.  Add the error propagated from the previous line       * to form the complete error correction term for this pixel, and       * round the error term (which is expressed * 16) to an integer.       * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct       * for either sign of the error value.       * Note: errorptr points to *previous* column's array entry.       */      cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3+0] + 8, 4);      cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3+1] + 8, 4);      cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3+2] + 8, 4);      /* Limit the error using transfer function set by init_error_limit.       * See comments with init_error_limit for rationale.       */      cur0 = error_limit[cur0];      cur1 = error_limit[cur1];      cur2 = error_limit[cur2];      /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.       * The maximum error is +- MAXJSAMPLE (or less with error limiting);       * this sets the required size of the range_limit array.       */      cur0 += GETJSAMPLE(inptr[0]);      cur1 += GETJSAMPLE(inptr[1]);      cur2 += GETJSAMPLE(inptr[2]);      cur0 = GETJSAMPLE(range_limit[cur0]);      cur1 = GETJSAMPLE(range_limit[cur1]);      cur2 = GETJSAMPLE(range_limit[cur2]);      /* Index into the cache with adjusted pixel value */      cachep = & histogram[cur0>>C0_SHIFT][cur1>>C1_SHIFT][cur2>>C2_SHIFT];      /* If we have not seen this color before, find nearest colormap */      /* entry and update the cache */      if (*cachep == 0)	fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);      /* Now emit the colormap index for this cell */      { register int pixcode = *cachep - 1;	*outptr = (JSAMPLE) pixcode;	/* Compute representation error for this pixel */	cur0 -= GETJSAMPLE(colormap0[pixcode]);	cur1 -= GETJSAMPLE(colormap1[pixcode]);	cur2 -= GETJSAMPLE(colormap2[pixcode]);      }      /* Compute error fractions to be propagated to adjacent pixels.       * Add these into the running sums, and simultaneously shift the       * next-line error sums left by 1 column.       */      { register LOCFSERROR bnexterr, delta;	bnexterr = cur0;	/* Process component 0 */	delta = cur0 * 2;	cur0 += delta;		/* form error * 3 */	errorptr[0] = (FSERROR) (bpreverr0 + cur0);	cur0 += delta;		/* form error * 5 */	bpreverr0 = belowerr0 + cur0;	belowerr0 = bnexterr;	cur0 += delta;		/* form error * 7 */	bnexterr = cur1;	/* Process component 1 */	delta = cur1 * 2;	cur1 += delta;		/* form error * 3 */	errorptr[1] = (FSERROR) (bpreverr1 + cur1);	cur1 += delta;		/* form error * 5 */	bpreverr1 = belowerr1 + cur1;	belowerr1 = bnexterr;	cur1 += delta;		/* form error * 7 */	bnexterr = cur2;	/* Process component 2 */	delta = cur2 * 2;	cur2 += delta;		/* form error * 3 */	errorptr[2] = (FSERROR) (bpreverr2 + cur2);	cur2 += delta;		/* form error * 5 */	bpreverr2 = belowerr2 + cur2;	belowerr2 = bnexterr;	cur2 += delta;		/* form error * 7 */      }      /* At this point curN contains the 7/16 error value to be propagated       * to the next pixel on the current line, and all the errors for the       * next line have been shifted over.  We are therefore ready to move on.       */      inptr += dir3;		/* Advance pixel pointers to next column */      outptr += dir;      errorptr += dir3;		/* advance errorptr to current column */    }    /* Post-loop cleanup: we must unload the final error values into the     * final fserrors[] entry.  Note we need not unload belowerrN because     * it is for the dummy column before or after the actual array.     */    errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */    errorptr[1] = (FSERROR) bpreverr1;    errorptr[2] = (FSERROR) bpreverr2;  }}/* * Initialize the error-limiting transfer function (lookup table). * The raw F-S error computation can potentially compute error values of up to * +- MAXJSAMPLE.  But we want the maximum correction applied to a pixel to be * much less, otherwise obviously wrong pixels will be created.  (Typical * effects include weird fringes at color-area boundaries, isolated bright * pixels in a dark area, etc.)  The standard advice for avoiding this problem * is to ensure that the "corners" of the color cube are allocated as output * colors; then repeated errors in the same direction cannot cause cascading * error buildup.  However, that only prevents the error from getting * completely out of hand; Aaron Giles reports that error limiting improves * the results even with corner colors allocated. * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty * well, but the smoother transfer function used below is even better.  Thanks * to Aaron Giles for this idea. */LOCAL(void)init_error_limit (j_decompress_ptr cinfo)/* Allocate and fill in the error_limiter table */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  int * table;  int in, out;  table = (int *) (*cinfo->mem->alloc_small)    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int));  table += MAXJSAMPLE;		/* so can index -MAXJSAMPLE .. +MAXJSAMPLE */  cquantize->error_limiter = table;#define STEPSIZE ((MAXJSAMPLE+1)/16)  /* Map errors 1:1 up to +- MAXJSAMPLE/16 */  out = 0;  for (in = 0; in < STEPSIZE; in++, out++) {    table[in] = out; table[-in] = -out;  }  /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */  for (; in < STEPSIZE*3; in++, out += (in&1) ? 0 : 1) {    table[in] = out; table[-in] = -out;  }  /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */  for (; in <= MAXJSAMPLE; in++) {    table[in] = out; table[-in] = -out;  }#undef STEPSIZE}/* * Finish up at the end of each pass. */METHODDEF(void)finish_pass1 (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  /* Select the representative colors and fill in cinfo->colormap */  cinfo->colormap = cquantize->sv_colormap;  select_colors(cinfo, cquantize->desired);  /* Force next pass to zero the color index table */  cquantize->needs_zeroed = TRUE;}METHODDEF(void)finish_pass2 (j_decompress_ptr cinfo){  /* no work */}/* * Initialize for each processing pass. */METHODDEF(void)start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  hist3d histogram = cquantize->histogram;  int i;  /* Only F-S dithering or no dithering is supported. */  /* If user asks for ordered dither, give him F-S. */  if (cinfo->dither_mode != JDITHER_NONE)    cinfo->dither_mode = JDITHER_FS;  if (is_pre_scan) {    /* Set up method pointers */    cquantize->pub.color_quantize = prescan_quantize;    cquantize->pub.finish_pass = finish_pass1;    cquantize->needs_zeroed = TRUE; /* Always zero histogram */  } else {    /* Set up method pointers */    if (cinfo->dither_mode == JDITHER_FS)      cquantize->pub.color_quantize = pass2_fs_dither;    else      cquantize->pub.color_quantize = pass2_no_dither;    cquantize->pub.finish_pass = finish_pass2;    /* Make sure color count is acceptable */    i = cinfo->actual_number_of_colors;    if (i < 1)      ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1);    if (i > MAXNUMCOLORS)      ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);    if (cinfo->dither_mode == JDITHER_FS) {      size_t arraysize = (size_t) ((cinfo->output_width + 2) *				   (3 * SIZEOF(FSERROR)));      /* Allocate Floyd-Steinberg workspace if we didn't already. */      if (cquantize->fserrors == NULL)	cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)	  ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);      /* Initialize the propagated errors to zero. */      jzero_far((void FAR *) cquantize->fserrors, arraysize);      /* Make the error-limit table if we didn't already. */      if (cquantize->error_limiter == NULL)	init_error_limit(cinfo);      cquantize->on_odd_row = FALSE;    }  }  /* Zero the histogram or inverse color map, if necessary */  if (cquantize->needs_zeroed) {    for (i = 0; i < HIST_C0_ELEMS; i++) {      jzero_far((void FAR *) histogram[i],		HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));    }    cquantize->needs_zeroed = FALSE;  }}/* * Switch to a new external colormap between output passes. */METHODDEF(void)new_color_map_2_quant (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  /* Reset the inverse color map */  cquantize->needs_zeroed = TRUE;}/* * Module initialization routine for 2-pass color quantization. */GLOBAL(void)jinit_2pass_quantizer (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize;  int i;  cquantize = (my_cquantize_ptr)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,				SIZEOF(my_cquantizer));  cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;  cquantize->pub.start_pass = start_pass_2_quant;  cquantize->pub.new_color_map = new_color_map_2_quant;  cquantize->fserrors = NULL;	/* flag optional arrays not allocated */  cquantize->error_limiter = NULL;  /* Make sure jdmaster didn't give me a case I can't handle */  if (cinfo->out_color_components != 3)    ERREXIT(cinfo, JERR_NOTIMPL);  /* Allocate the histogram/inverse colormap storage */  cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small)    ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d));  for (i = 0; i < HIST_C0_ELEMS; i++) {    cquantize->histogram[i] = (hist2d) (*cinfo->mem->alloc_large)      ((j_common_ptr) cinfo, JPOOL_IMAGE,       HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));  }  cquantize->needs_zeroed = TRUE; /* histogram is garbage now */  /* Allocate storage for the completed colormap, if required.   * We do this now since it is FAR storage and may affect   * the memory manager's space calculations.   */  if (cinfo->enable_2pass_quant) {    /* Make sure color count is acceptable */    int desired = cinfo->desired_number_of_colors;    /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */    if (desired < 8)      ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8);    /* Make sure colormap indexes can be represented by JSAMPLEs */    if (desired > MAXNUMCOLORS)      ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);    cquantize->sv_colormap = (*cinfo->mem->alloc_sarray)      ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3);    cquantize->desired = desired;  } else    cquantize->sv_colormap = NULL;  /* Only F-S dithering or no dithering is supported. */  /* If user asks for ordered dither, give him F-S. */  if (cinfo->dither_mode != JDITHER_NONE)    cinfo->dither_mode = JDITHER_FS;  /* Allocate Floyd-Steinberg workspace if necessary.   * This isn't really needed until pass 2, but again it is FAR storage.   * Although we will cope with a later change in dither_mode,   * we do not promise to honor max_memory_to_use if dither_mode changes.   */  if (cinfo->dither_mode == JDITHER_FS) {    cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)      ((j_common_ptr) cinfo, JPOOL_IMAGE,       (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR))));    /* Might as well create the error-limiting table too. */    init_error_limit(cinfo);  }}#endif /* QUANT_2PASS_SUPPORTED */