cquantize->Ncolors[1], cquantize->Ncolors[2]);  else    TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);  /* Allocate and fill in the colormap. */  /* The colors are ordered in the map in standard row-major order, */  /* i.e. rightmost (highest-indexed) color changes most rapidly. */  colormap = (*cinfo->mem->alloc_sarray)    ((j_common_ptr) cinfo, JPOOL_IMAGE,     (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components);  /* blksize is number of adjacent repeated entries for a component */  /* blkdist is distance between groups of identical entries for a component */  blkdist = total_colors;  for (i = 0; i < cinfo->out_color_components; i++) {    /* fill in colormap entries for i'th color component */    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */    blksize = blkdist / nci;    for (j = 0; j < nci; j++) {      /* Compute j'th output value (out of nci) for component */      val = output_value(cinfo, i, j, nci-1);      /* Fill in all colormap entries that have this value of this component */      for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {	/* fill in blksize entries beginning at ptr */	for (k = 0; k < blksize; k++)	  colormap[i][ptr+k] = (JSAMPLE) val;      }    }    blkdist = blksize;		/* blksize of this color is blkdist of next */  }  /* Save the colormap in private storage,   * where it will survive color quantization mode changes.   */  cquantize->sv_colormap = colormap;  cquantize->sv_actual = total_colors;}/* * Create the color index table. */LOCAL(void)create_colorindex (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  JSAMPROW indexptr;  int i,j,k, nci, blksize, val, pad;  /* For ordered dither, we pad the color index tables by MAXJSAMPLE in   * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE).   * This is not necessary in the other dithering modes.  However, we   * flag whether it was done in case user changes dithering mode.   */  if (cinfo->dither_mode == JDITHER_ORDERED) {    pad = MAXJSAMPLE*2;    cquantize->is_padded = TRUE;  } else {    pad = 0;    cquantize->is_padded = FALSE;  }  cquantize->colorindex = (*cinfo->mem->alloc_sarray)    ((j_common_ptr) cinfo, JPOOL_IMAGE,     (JDIMENSION) (MAXJSAMPLE+1 + pad),     (JDIMENSION) cinfo->out_color_components);  /* blksize is number of adjacent repeated entries for a component */  blksize = cquantize->sv_actual;  for (i = 0; i < cinfo->out_color_components; i++) {    /* fill in colorindex entries for i'th color component */    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */    blksize = blksize / nci;    /* adjust colorindex pointers to provide padding at negative indexes. */    if (pad)      cquantize->colorindex[i] += MAXJSAMPLE;    /* in loop, val = index of current output value, */    /* and k = largest j that maps to current val */    indexptr = cquantize->colorindex[i];    val = 0;    k = largest_input_value(cinfo, i, 0, nci-1);    for (j = 0; j <= MAXJSAMPLE; j++) {      while (j > k)		/* advance val if past boundary */	k = largest_input_value(cinfo, i, ++val, nci-1);      /* premultiply so that no multiplication needed in main processing */      indexptr[j] = (JSAMPLE) (val * blksize);    }    /* Pad at both ends if necessary */    if (pad)      for (j = 1; j <= MAXJSAMPLE; j++) {	indexptr[-j] = indexptr[0];	indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];      }  }}/* * Create an ordered-dither array for a component having ncolors * distinct output values. */LOCAL(ODITHER_MATRIX_PTR)make_odither_array (j_decompress_ptr cinfo, int ncolors){  ODITHER_MATRIX_PTR odither;  int j,k;  INT32 num,den;  odither = (ODITHER_MATRIX_PTR)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,				SIZEOF(ODITHER_MATRIX));  /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).   * Hence the dither value for the matrix cell with fill order f   * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).   * On 16-bit-int machine, be careful to avoid overflow.   */  den = 2 * ODITHER_CELLS * ((INT32) (ncolors - 1));  for (j = 0; j < ODITHER_SIZE; j++) {    for (k = 0; k < ODITHER_SIZE; k++) {      num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k])))	    * MAXJSAMPLE;      /* Ensure round towards zero despite C's lack of consistency       * about rounding negative values in integer division...       */      odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den);    }  }  return odither;}/* * Create the ordered-dither tables. * Components having the same number of representative colors may  * share a dither table. */LOCAL(void)create_odither_tables (j_decompress_ptr cinfo){  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  ODITHER_MATRIX_PTR odither;  int i, j, nci;  for (i = 0; i < cinfo->out_color_components; i++) {    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */    odither = NULL;		/* search for matching prior component */    for (j = 0; j < i; j++) {      if (nci == cquantize->Ncolors[j]) {	odither = cquantize->odither[j];	break;      }    }    if (odither == NULL)	/* need a new table? */      odither = make_odither_array(cinfo, nci);    cquantize->odither[i] = odither;  }}/* * Map some rows of pixels to the output colormapped representation. */METHODDEF(void)color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,		JSAMPARRAY output_buf, int num_rows)/* General case, no dithering */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  JSAMPARRAY colorindex = cquantize->colorindex;  register int pixcode, ci;  register JSAMPROW ptrin, ptrout;  int row;  JDIMENSION col;  JDIMENSION width = cinfo->output_width;  register int nc = cinfo->out_color_components;  for (row = 0; row < num_rows; row++) {    ptrin = input_buf[row];    ptrout = output_buf[row];    for (col = width; col > 0; col--) {      pixcode = 0;      for (ci = 0; ci < nc; ci++) {	pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);      }      *ptrout++ = (JSAMPLE) pixcode;    }  }}METHODDEF(void)color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,		 JSAMPARRAY output_buf, int num_rows)/* Fast path for out_color_components==3, no dithering */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  register int pixcode;  register JSAMPROW ptrin, ptrout;  JSAMPROW colorindex0 = cquantize->colorindex[0];  JSAMPROW colorindex1 = cquantize->colorindex[1];  JSAMPROW colorindex2 = cquantize->colorindex[2];  int row;  JDIMENSION col;  JDIMENSION width = cinfo->output_width;  for (row = 0; row < num_rows; row++) {    ptrin = input_buf[row];    ptrout = output_buf[row];    for (col = width; col > 0; col--) {      pixcode  = GETJSAMPLE(colorindex0[GETJSAMPLE(*ptrin++)]);      pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*ptrin++)]);      pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*ptrin++)]);      *ptrout++ = (JSAMPLE) pixcode;    }  }}METHODDEF(void)quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,		     JSAMPARRAY output_buf, int num_rows)/* General case, with ordered dithering */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  register JSAMPROW input_ptr;  register JSAMPROW output_ptr;  JSAMPROW colorindex_ci;  int * dither;			/* points to active row of dither matrix */  int row_index, col_index;	/* current indexes into dither matrix */  int nc = cinfo->out_color_components;  int ci;  int row;  JDIMENSION col;  JDIMENSION width = cinfo->output_width;  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)));    row_index = cquantize->row_index;    for (ci = 0; ci < nc; ci++) {      input_ptr = input_buf[row] + ci;      output_ptr = output_buf[row];      colorindex_ci = cquantize->colorindex[ci];      dither = cquantize->odither[ci][row_index];      col_index = 0;      for (col = width; col > 0; col--) {	/* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,	 * select output value, accumulate into output code for this pixel.	 * Range-limiting need not be done explicitly, as we have extended	 * the colorindex table to produce the right answers for out-of-range	 * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the	 * required amount of padding.	 */	*output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];	input_ptr += nc;	output_ptr++;	col_index = (col_index + 1) & ODITHER_MASK;      }    }    /* Advance row index for next row */    row_index = (row_index + 1) & ODITHER_MASK;    cquantize->row_index = row_index;  }}METHODDEF(void)quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,		      JSAMPARRAY output_buf, int num_rows)/* Fast path for out_color_components==3, with ordered dithering */{  my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;  register int pixcode;  register JSAMPROW input_ptr;  register JSAMPROW output_ptr;