JSAMPROW colorindex0 = cquantize->colorindex[0];  JSAMPROW colorindex1 = cquantize->colorindex[1];  JSAMPROW colorindex2 = cquantize->colorindex[2];  int * dither0;		/* points to active row of dither matrix */  int * dither1;  int * dither2;  int row_index, col_index;	/* current indexes into dither matrix */  int row;  JDIMENSION col;  JDIMENSION width = cinfo->output_width;  for (row = 0; row < num_rows; row++) {    row_index = cquantize->row_index;    input_ptr = input_buf[row];    output_ptr = output_buf[row];    dither0 = cquantize->odither[0][row_index];    dither1 = cquantize->odither[1][row_index];    dither2 = cquantize->odither[2][row_index];    col_index = 0;    for (col = width; col > 0; col--) {      pixcode  = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) +					dither0[col_index]]);      pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) +					dither1[col_index]]);      pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) +					dither2[col_index]]);      *output_ptr++ = (JSAMPLE) pixcode;      col_index = (col_index + 1) & ODITHER_MASK;    }    row_index = (row_index + 1) & ODITHER_MASK;    cquantize->row_index = row_index;  }}METHODDEF(void)quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,		    JSAMPARRAY output_buf, int num_rows)/* General case, with Floyd-Steinberg dithering */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  register LOCFSERROR cur;	/* current error or pixel value */  LOCFSERROR belowerr;		/* error for pixel below cur */  LOCFSERROR bpreverr;		/* error for below/prev col */  LOCFSERROR bnexterr;		/* error for below/next col */  LOCFSERROR delta;  register FSERRPTR errorptr;	/* => fserrors[] at column before current */  register JSAMPROW input_ptr;  register JSAMPROW output_ptr;  JSAMPROW colorindex_ci;  JSAMPROW colormap_ci;  int pixcode;  int nc = cinfo->out_color_components;  int dir;			/* 1 for left-to-right, -1 for right-to-left */  int dirnc;			/* dir * nc */  int ci;  int row;  JDIMENSION col;  JDIMENSION width = cinfo->output_width;  JSAMPLE *range_limit = cinfo->sample_range_limit;  SHIFT_TEMPS  for (row = 0; row < num_rows; row++) {    /* Initialize output values to 0 so can process components separately */    jzero_far((void FAR *) output_buf[row],	      (size_t) (width * SIZEOF(JSAMPLE)));    for (ci = 0; ci < nc; ci++) {      input_ptr = input_buf[row] + ci;      output_ptr = output_buf[row];      if (cquantize->on_odd_row) {	/* work right to left in this row */	input_ptr += (width-1) * nc; /* so point to rightmost pixel */	output_ptr += width-1;	dir = -1;	dirnc = -nc;	errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */      } else {	/* work left to right in this row */	dir = 1;	dirnc = nc;	errorptr = cquantize->fserrors[ci]; /* => entry before first column */      }      colorindex_ci = cquantize->colorindex[ci];      colormap_ci = cquantize->sv_colormap[ci];      /* Preset error values: no error propagated to first pixel from left */      cur = 0;      /* and no error propagated to row below yet */      belowerr = bpreverr = 0;      for (col = width; col > 0; col--) {	/* cur 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.	 */	cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);	/* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.	 * The maximum error is +- MAXJSAMPLE; this sets the required size	 * of the range_limit array.	 */	cur += GETJSAMPLE(*input_ptr);	cur = GETJSAMPLE(range_limit[cur]);	/* Select output value, accumulate into output code for this pixel */	pixcode = GETJSAMPLE(colorindex_ci[cur]);	*output_ptr += (JSAMPLE) pixcode;	/* Compute actual representation error at this pixel */	/* Note: we can do this even though we don't have the final */	/* pixel code, because the colormap is orthogonal. */	cur -= GETJSAMPLE(colormap_ci[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.	 */	bnexterr = cur;	delta = cur * 2;	cur += delta;		/* form error * 3 */	errorptr[0] = (FSERROR) (bpreverr + cur);	cur += delta;		/* form error * 5 */	bpreverr = belowerr + cur;	belowerr = bnexterr;	cur += delta;		/* form error * 7 */	/* At this point cur 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.	 */	input_ptr += dirnc;	/* advance input ptr to next column */	output_ptr += dir;	/* advance output ptr to next column */	errorptr += dir;	/* advance errorptr to current column */      }      /* Post-loop cleanup: we must unload the final error value into the       * final fserrors[] entry.  Note we need not unload belowerr because       * it is for the dummy column before or after the actual array.       */      errorptr[0] = (FSERROR) bpreverr; /* unload prev err into array */    }    cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE);  }}/* * Allocate workspace for Floyd-Steinberg errors. */LOCAL(void)alloc_fs_workspace (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  size_t arraysize;  int i;  arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));  for (i = 0; i < cinfo->out_color_components; i++) {    cquantize->fserrors[i] = (FSERRPTR)      (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);  }}/* * Initialize for one-pass color quantization. */METHODDEF(void)start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  size_t arraysize;  int i;  /* Install my colormap. */  cinfo->colormap = cquantize->sv_colormap;  cinfo->actual_number_of_colors = cquantize->sv_actual;  /* Initialize for desired dithering mode. */  switch (cinfo->dither_mode) {  case JDITHER_NONE:    if (cinfo->out_color_components == 3)      cquantize->pub.color_quantize = color_quantize3;    else      cquantize->pub.color_quantize = color_quantize;    break;  case JDITHER_ORDERED:    if (cinfo->out_color_components == 3)      cquantize->pub.color_quantize = quantize3_ord_dither;    else      cquantize->pub.color_quantize = quantize_ord_dither;    cquantize->row_index = 0;	/* initialize state for ordered dither */    /* If user changed to ordered dither from another mode,     * we must recreate the color index table with padding.     * This will cost extra space, but probably isn't very likely.     */    if (! cquantize->is_padded)      create_colorindex(cinfo);    /* Create ordered-dither tables if we didn't already. */    if (cquantize->odither[0] == NULL)      create_odither_tables(cinfo);    break;  case JDITHER_FS:    cquantize->pub.color_quantize = quantize_fs_dither;    cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */    /* Allocate Floyd-Steinberg workspace if didn't already. */    if (cquantize->fserrors[0] == NULL)      alloc_fs_workspace(cinfo);    /* Initialize the propagated errors to zero. */    arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));    for (i = 0; i < cinfo->out_color_components; i++)      jzero_far((void FAR *) cquantize->fserrors[i], arraysize);    break;  default:    ERREXIT(cinfo, JERR_NOT_COMPILED);    break;  }}/* * Finish up at the end of the pass. */METHODDEF(void)finish_pass_1_quant (j_decompress_ptr cinfo){  /* no work in 1-pass case */}/* * Switch to a new external colormap between output passes. * Shouldn't get to this module! */METHODDEF(void)new_color_map_1_quant (j_decompress_ptr cinfo){  ERREXIT(cinfo, JERR_MODE_CHANGE);}/* * Module initialization routine for 1-pass color quantization. */GLOBAL(void)jinit_1pass_quantizer (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize;  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_1_quant;  cquantize->pub.finish_pass = finish_pass_1_quant;  cquantize->pub.new_color_map = new_color_map_1_quant;  cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */  cquantize->odither[0] = NULL;	/* Also flag odither arrays not allocated */  /* Make sure my internal arrays won't overflow */  if (cinfo->out_color_components > MAX_Q_COMPS)    ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS);  /* Make sure colormap indexes can be represented by JSAMPLEs */  if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1))    ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1);  /* Create the colormap and color index table. */  create_colormap(cinfo);  create_colorindex(cinfo);  /* Allocate Floyd-Steinberg workspace now if requested.   * We do this now since it is FAR storage and may affect the memory   * manager's space calculations.  If the user changes to FS dither   * mode in a later pass, we will allocate the space then, and will   * possibly overrun the max_memory_to_use setting.   */  if (cinfo->dither_mode == JDITHER_FS)    alloc_fs_workspace(cinfo);}#endif /* QUANT_1PASS_SUPPORTED */