diff options
Diffstat (limited to 'src/3rdparty/libjpeg/src/jquant2.c')
| -rw-r--r-- | src/3rdparty/libjpeg/src/jquant2.c | 357 |
1 files changed, 180 insertions, 177 deletions
diff --git a/src/3rdparty/libjpeg/src/jquant2.c b/src/3rdparty/libjpeg/src/jquant2.c index cfbd0f1526..0ce0ca5472 100644 --- a/src/3rdparty/libjpeg/src/jquant2.c +++ b/src/3rdparty/libjpeg/src/jquant2.c @@ -73,14 +73,14 @@ * probably need to change these scale factors. */ -#define R_SCALE 2 /* scale R distances by this much */ -#define G_SCALE 3 /* scale G distances by this much */ -#define B_SCALE 1 /* and B by this much */ +#define R_SCALE 2 /* scale R distances by this much */ +#define G_SCALE 3 /* scale G distances by this much */ +#define B_SCALE 1 /* and B by this much */ -static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE}; -#define C0_SCALE c_scales[rgb_red[cinfo->out_color_space]] -#define C1_SCALE c_scales[rgb_green[cinfo->out_color_space]] -#define C2_SCALE c_scales[rgb_blue[cinfo->out_color_space]] +static const int c_scales[3] = { R_SCALE, G_SCALE, B_SCALE }; +#define C0_SCALE c_scales[rgb_red[cinfo->out_color_space]] +#define C1_SCALE c_scales[rgb_green[cinfo->out_color_space]] +#define C2_SCALE c_scales[rgb_blue[cinfo->out_color_space]] /* * First we have the histogram data structure and routines for creating it. @@ -106,7 +106,7 @@ static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE}; * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. */ -#define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */ +#define MAXNUMCOLORS (MAXJSAMPLE + 1) /* maximum size of colormap */ /* These will do the right thing for either R,G,B or B,G,R color order, * but you may not like the results for other color orders. @@ -116,19 +116,19 @@ static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE}; #define HIST_C2_BITS 5 /* bits of precision in B/R histogram */ /* Number of elements along histogram axes. */ -#define HIST_C0_ELEMS (1<<HIST_C0_BITS) -#define HIST_C1_ELEMS (1<<HIST_C1_BITS) -#define HIST_C2_ELEMS (1<<HIST_C2_BITS) +#define HIST_C0_ELEMS (1 << HIST_C0_BITS) +#define HIST_C1_ELEMS (1 << HIST_C1_BITS) +#define HIST_C2_ELEMS (1 << HIST_C2_BITS) /* These are the amounts to shift an input value to get a histogram index. */ -#define C0_SHIFT (BITS_IN_JSAMPLE-HIST_C0_BITS) -#define C1_SHIFT (BITS_IN_JSAMPLE-HIST_C1_BITS) -#define C2_SHIFT (BITS_IN_JSAMPLE-HIST_C2_BITS) +#define C0_SHIFT (BITS_IN_JSAMPLE - HIST_C0_BITS) +#define C1_SHIFT (BITS_IN_JSAMPLE - HIST_C1_BITS) +#define C2_SHIFT (BITS_IN_JSAMPLE - HIST_C2_BITS) typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */ -typedef histcell *histptr; /* for pointers to histogram cells */ +typedef histcell *histptr; /* for pointers to histogram cells */ typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */ typedef hist1d *hist2d; /* type for the 2nd-level pointers */ @@ -200,10 +200,10 @@ typedef my_cquantizer *my_cquantize_ptr; */ METHODDEF(void) -prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf, - JSAMPARRAY output_buf, int num_rows) +prescan_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; register JSAMPROW ptr; register histptr histp; register hist3d histogram = cquantize->histogram; @@ -215,9 +215,9 @@ prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf, ptr = input_buf[row]; for (col = width; col > 0; col--) { /* get pixel value and index into the histogram */ - histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT] - [GETJSAMPLE(ptr[1]) >> C1_SHIFT] - [GETJSAMPLE(ptr[2]) >> C2_SHIFT]; + histp = &histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT] + [GETJSAMPLE(ptr[1]) >> C1_SHIFT] + [GETJSAMPLE(ptr[2]) >> C2_SHIFT]; /* increment, check for overflow and undo increment if so. */ if (++(*histp) <= 0) (*histp)--; @@ -249,7 +249,7 @@ typedef box *boxptr; LOCAL(boxptr) -find_biggest_color_pop (boxptr boxlist, int numboxes) +find_biggest_color_pop(boxptr boxlist, int numboxes) /* Find the splittable box with the largest color population */ /* Returns NULL if no splittable boxes remain */ { @@ -269,7 +269,7 @@ find_biggest_color_pop (boxptr boxlist, int numboxes) LOCAL(boxptr) -find_biggest_volume (boxptr boxlist, int numboxes) +find_biggest_volume(boxptr boxlist, int numboxes) /* Find the splittable box with the largest (scaled) volume */ /* Returns NULL if no splittable boxes remain */ { @@ -289,16 +289,16 @@ find_biggest_volume (boxptr boxlist, int numboxes) LOCAL(void) -update_box (j_decompress_ptr cinfo, boxptr boxp) +update_box(j_decompress_ptr cinfo, boxptr boxp) /* Shrink the min/max bounds of a box to enclose only nonzero elements, */ /* and recompute its volume and population */ { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; histptr histp; - int c0,c1,c2; - int c0min,c0max,c1min,c1max,c2min,c2max; - JLONG dist0,dist1,dist2; + int c0, c1, c2; + int c0min, c0max, c1min, c1max, c2min, c2max; + JLONG dist0, dist1, dist2; long ccount; c0min = boxp->c0min; c0max = boxp->c0max; @@ -308,69 +308,69 @@ update_box (j_decompress_ptr cinfo, boxptr boxp) if (c0max > c0min) for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c0min = c0min = c0; goto have_c0min; } } - have_c0min: +have_c0min: if (c0max > c0min) for (c0 = c0max; c0 >= c0min; c0--) for (c1 = c1min; c1 <= c1max; c1++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c0max = c0max = c0; goto have_c0max; } } - have_c0max: +have_c0max: if (c1max > c1min) for (c1 = c1min; c1 <= c1max; c1++) for (c0 = c0min; c0 <= c0max; c0++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c1min = c1min = c1; goto have_c1min; } } - have_c1min: +have_c1min: if (c1max > c1min) for (c1 = c1max; c1 >= c1min; c1--) for (c0 = c0min; c0 <= c0max; c0++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c1max = c1max = c1; goto have_c1max; } } - have_c1max: +have_c1max: if (c2max > c2min) for (c2 = c2min; c2 <= c2max; c2++) for (c0 = c0min; c0 <= c0max; c0++) { - histp = & histogram[c0][c1min][c2]; + histp = &histogram[c0][c1min][c2]; for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) if (*histp != 0) { boxp->c2min = c2min = c2; goto have_c2min; } } - have_c2min: +have_c2min: if (c2max > c2min) for (c2 = c2max; c2 >= c2min; c2--) for (c0 = c0min; c0 <= c0max; c0++) { - histp = & histogram[c0][c1min][c2]; + histp = &histogram[c0][c1min][c2]; for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) if (*histp != 0) { boxp->c2max = c2max = c2; goto have_c2max; } } - have_c2max: +have_c2max: /* Update box volume. * We use 2-norm rather than real volume here; this biases the method @@ -383,13 +383,13 @@ update_box (j_decompress_ptr cinfo, boxptr boxp) dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE; dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE; dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE; - boxp->volume = dist0*dist0 + dist1*dist1 + dist2*dist2; + boxp->volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2; /* Now scan remaining volume of box and compute population */ ccount = 0; for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++, histp++) if (*histp != 0) { ccount++; @@ -400,19 +400,19 @@ update_box (j_decompress_ptr cinfo, boxptr boxp) LOCAL(int) -median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, - int desired_colors) +median_cut(j_decompress_ptr cinfo, boxptr boxlist, int numboxes, + int desired_colors) /* Repeatedly select and split the largest box until we have enough boxes */ { - int n,lb; - int c0,c1,c2,cmax; - register boxptr b1,b2; + int n, lb; + int c0, c1, c2, cmax; + register boxptr b1, b2; while (numboxes < desired_colors) { /* Select box to split. * Current algorithm: by population for first half, then by volume. */ - if (numboxes*2 <= desired_colors) { + if (numboxes * 2 <= desired_colors) { b1 = find_biggest_color_pop(boxlist, numboxes); } else { b1 = find_biggest_volume(boxlist, numboxes); @@ -421,8 +421,8 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, break; b2 = &boxlist[numboxes]; /* where new box will go */ /* Copy the color bounds to the new box. */ - b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max; - b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min; + b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max; + b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min; /* Choose which axis to split the box on. * Current algorithm: longest scaled axis. * See notes in update_box about scaling distances. @@ -434,13 +434,12 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, * This code does the right thing for R,G,B or B,G,R color orders only. */ if (rgb_red[cinfo->out_color_space] == 0) { - cmax = c1; n = 1; - if (c0 > cmax) { cmax = c0; n = 0; } + cmax = c1; n = 1; + if (c0 > cmax) { cmax = c0; n = 0; } if (c2 > cmax) { n = 2; } - } - else { - cmax = c1; n = 1; - if (c2 > cmax) { cmax = c2; n = 2; } + } else { + cmax = c1; n = 1; + if (c2 > cmax) { cmax = c2; n = 2; } if (c0 > cmax) { n = 0; } } /* Choose split point along selected axis, and update box bounds. @@ -453,17 +452,17 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, case 0: lb = (b1->c0max + b1->c0min) / 2; b1->c0max = lb; - b2->c0min = lb+1; + b2->c0min = lb + 1; break; case 1: lb = (b1->c1max + b1->c1min) / 2; b1->c1max = lb; - b2->c1min = lb+1; + b2->c1min = lb + 1; break; case 2: lb = (b1->c2max + b1->c2min) / 2; b1->c2max = lb; - b2->c2min = lb+1; + b2->c2min = lb + 1; break; } /* Update stats for boxes */ @@ -476,16 +475,16 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, LOCAL(void) -compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor) +compute_color(j_decompress_ptr cinfo, boxptr boxp, int icolor) /* Compute representative color for a box, put it in colormap[icolor] */ { /* Current algorithm: mean weighted by pixels (not colors) */ /* Note it is important to get the rounding correct! */ - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; histptr histp; - int c0,c1,c2; - int c0min,c0max,c1min,c1max,c2min,c2max; + int c0, c1, c2; + int c0min, c0max, c1min, c1max, c2min, c2max; long count; long total = 0; long c0total = 0; @@ -498,25 +497,25 @@ compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor) for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { - histp = & histogram[c0][c1][c2min]; + histp = &histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) { if ((count = *histp++) != 0) { total += count; - c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count; - c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count; - c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count; + c0total += ((c0 << C0_SHIFT) + ((1 << C0_SHIFT) >> 1)) * count; + c1total += ((c1 << C1_SHIFT) + ((1 << C1_SHIFT) >> 1)) * count; + c2total += ((c2 << C2_SHIFT) + ((1 << C2_SHIFT) >> 1)) * count; } } } - cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total); - cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total); - cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total); + cinfo->colormap[0][icolor] = (JSAMPLE)((c0total + (total >> 1)) / total); + cinfo->colormap[1][icolor] = (JSAMPLE)((c1total + (total >> 1)) / total); + cinfo->colormap[2][icolor] = (JSAMPLE)((c2total + (total >> 1)) / total); } LOCAL(void) -select_colors (j_decompress_ptr cinfo, int desired_colors) +select_colors(j_decompress_ptr cinfo, int desired_colors) /* Master routine for color selection */ { boxptr boxlist; @@ -524,8 +523,8 @@ select_colors (j_decompress_ptr cinfo, int desired_colors) int i; /* Allocate workspace for box list */ - boxlist = (boxptr) (*cinfo->mem->alloc_small) - ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * sizeof(box)); + boxlist = (boxptr)(*cinfo->mem->alloc_small) + ((j_common_ptr)cinfo, JPOOL_IMAGE, desired_colors * sizeof(box)); /* Initialize one box containing whole space */ numboxes = 1; boxlist[0].c0min = 0; @@ -535,12 +534,12 @@ select_colors (j_decompress_ptr cinfo, int desired_colors) boxlist[0].c2min = 0; boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT; /* Shrink it to actually-used volume and set its statistics */ - update_box(cinfo, & boxlist[0]); + update_box(cinfo, &boxlist[0]); /* Perform median-cut to produce final box list */ numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors); /* Compute the representative color for each box, fill colormap */ for (i = 0; i < numboxes; i++) - compute_color(cinfo, & boxlist[i], i); + compute_color(cinfo, &boxlist[i], i); cinfo->actual_number_of_colors = numboxes; TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes); } @@ -601,13 +600,13 @@ select_colors (j_decompress_ptr cinfo, int desired_colors) /* log2(histogram cells in update box) for each axis; this can be adjusted */ -#define BOX_C0_LOG (HIST_C0_BITS-3) -#define BOX_C1_LOG (HIST_C1_BITS-3) -#define BOX_C2_LOG (HIST_C2_BITS-3) +#define BOX_C0_LOG (HIST_C0_BITS - 3) +#define BOX_C1_LOG (HIST_C1_BITS - 3) +#define BOX_C2_LOG (HIST_C2_BITS - 3) -#define BOX_C0_ELEMS (1<<BOX_C0_LOG) /* # of hist cells in update box */ -#define BOX_C1_ELEMS (1<<BOX_C1_LOG) -#define BOX_C2_ELEMS (1<<BOX_C2_LOG) +#define BOX_C0_ELEMS (1 << BOX_C0_LOG) /* # of hist cells in update box */ +#define BOX_C1_ELEMS (1 << BOX_C1_LOG) +#define BOX_C2_ELEMS (1 << BOX_C2_LOG) #define BOX_C0_SHIFT (C0_SHIFT + BOX_C0_LOG) #define BOX_C1_SHIFT (C1_SHIFT + BOX_C1_LOG) @@ -623,8 +622,8 @@ select_colors (j_decompress_ptr cinfo, int desired_colors) */ LOCAL(int) -find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, - JSAMPLE colorlist[]) +find_nearby_colors(j_decompress_ptr cinfo, int minc0, int minc1, int minc2, + JSAMPLE colorlist[]) /* Locate the colormap entries close enough to an update box to be candidates * for the nearest entry to some cell(s) in the update box. The update box * is specified by the center coordinates of its first cell. The number of @@ -669,67 +668,67 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, x = GETJSAMPLE(cinfo->colormap[0][i]); if (x < minc0) { tdist = (x - minc0) * C0_SCALE; - min_dist = tdist*tdist; + min_dist = tdist * tdist; tdist = (x - maxc0) * C0_SCALE; - max_dist = tdist*tdist; + max_dist = tdist * tdist; } else if (x > maxc0) { tdist = (x - maxc0) * C0_SCALE; - min_dist = tdist*tdist; + min_dist = tdist * tdist; tdist = (x - minc0) * C0_SCALE; - max_dist = tdist*tdist; + max_dist = tdist * tdist; } else { /* within cell range so no contribution to min_dist */ min_dist = 0; if (x <= centerc0) { tdist = (x - maxc0) * C0_SCALE; - max_dist = tdist*tdist; + max_dist = tdist * tdist; } else { tdist = (x - minc0) * C0_SCALE; - max_dist = tdist*tdist; + max_dist = tdist * tdist; } } x = GETJSAMPLE(cinfo->colormap[1][i]); if (x < minc1) { tdist = (x - minc1) * C1_SCALE; - min_dist += tdist*tdist; + min_dist += tdist * tdist; tdist = (x - maxc1) * C1_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else if (x > maxc1) { tdist = (x - maxc1) * C1_SCALE; - min_dist += tdist*tdist; + min_dist += tdist * tdist; tdist = (x - minc1) * C1_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else { /* within cell range so no contribution to min_dist */ if (x <= centerc1) { tdist = (x - maxc1) * C1_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else { tdist = (x - minc1) * C1_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } } x = GETJSAMPLE(cinfo->colormap[2][i]); if (x < minc2) { tdist = (x - minc2) * C2_SCALE; - min_dist += tdist*tdist; + min_dist += tdist * tdist; tdist = (x - maxc2) * C2_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else if (x > maxc2) { tdist = (x - maxc2) * C2_SCALE; - min_dist += tdist*tdist; + min_dist += tdist * tdist; tdist = (x - minc2) * C2_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else { /* within cell range so no contribution to min_dist */ if (x <= centerc2) { tdist = (x - maxc2) * C2_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } else { tdist = (x - minc2) * C2_SCALE; - max_dist += tdist*tdist; + max_dist += tdist * tdist; } } @@ -745,15 +744,15 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, ncolors = 0; for (i = 0; i < numcolors; i++) { if (mindist[i] <= minmaxdist) - colorlist[ncolors++] = (JSAMPLE) i; + colorlist[ncolors++] = (JSAMPLE)i; } return ncolors; } LOCAL(void) -find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, - int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[]) +find_best_colors(j_decompress_ptr cinfo, int minc0, int minc1, int minc2, + int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[]) /* Find the closest colormap entry for each cell in the update box, * given the list of candidate colors prepared by find_nearby_colors. * Return the indexes of the closest entries in the bestcolor[] array. @@ -775,7 +774,7 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, /* Initialize best-distance for each cell of the update box */ bptr = bestdist; - for (i = BOX_C0_ELEMS*BOX_C1_ELEMS*BOX_C2_ELEMS-1; i >= 0; i--) + for (i = BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS - 1; i >= 0; i--) *bptr++ = 0x7FFFFFFFL; /* For each color selected by find_nearby_colors, @@ -792,11 +791,11 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, icolor = GETJSAMPLE(colorlist[i]); /* Compute (square of) distance from minc0/c1/c2 to this color */ inc0 = (minc0 - GETJSAMPLE(cinfo->colormap[0][icolor])) * C0_SCALE; - dist0 = inc0*inc0; + dist0 = inc0 * inc0; inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE; - dist0 += inc1*inc1; + dist0 += inc1 * inc1; inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE; - dist0 += inc2*inc2; + dist0 += inc2 * inc2; /* Form the initial difference increments */ inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0; inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1; @@ -805,16 +804,16 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, bptr = bestdist; cptr = bestcolor; xx0 = inc0; - for (ic0 = BOX_C0_ELEMS-1; ic0 >= 0; ic0--) { + for (ic0 = BOX_C0_ELEMS - 1; ic0 >= 0; ic0--) { dist1 = dist0; xx1 = inc1; - for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) { + for (ic1 = BOX_C1_ELEMS - 1; ic1 >= 0; ic1--) { dist2 = dist1; xx2 = inc2; - for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) { + for (ic2 = BOX_C2_ELEMS - 1; ic2 >= 0; ic2--) { if (dist2 < *bptr) { *bptr = dist2; - *cptr = (JSAMPLE) icolor; + *cptr = (JSAMPLE)icolor; } dist2 += xx2; xx2 += 2 * STEP_C2 * STEP_C2; @@ -832,12 +831,12 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, LOCAL(void) -fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2) +fill_inverse_cmap(j_decompress_ptr cinfo, int c0, int c1, int c2) /* Fill the inverse-colormap entries in the update box that contains */ /* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */ /* we can fill as many others as we wish.) */ { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; int minc0, minc1, minc2; /* lower left corner of update box */ int ic0, ic1, ic2; @@ -878,9 +877,9 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2) cptr = bestcolor; for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) { for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) { - cachep = & histogram[c0+ic0][c1+ic1][c2]; + cachep = &histogram[c0 + ic0][c1 + ic1][c2]; for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) { - *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1); + *cachep++ = (histcell)(GETJSAMPLE(*cptr++) + 1); } } } @@ -892,11 +891,11 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2) */ METHODDEF(void) -pass2_no_dither (j_decompress_ptr cinfo, - JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) +pass2_no_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) /* This version performs no dithering */ { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; register JSAMPROW inptr, outptr; register histptr cachep; @@ -913,24 +912,24 @@ pass2_no_dither (j_decompress_ptr cinfo, c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT; c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT; c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT; - cachep = & histogram[c0][c1][c2]; + cachep = &histogram[c0][c1][c2]; /* If we have not seen this color before, find nearest colormap entry */ /* and update the cache */ if (*cachep == 0) - fill_inverse_cmap(cinfo, c0,c1,c2); + fill_inverse_cmap(cinfo, c0, c1, c2); /* Now emit the colormap index for this cell */ - *outptr++ = (JSAMPLE) (*cachep - 1); + *outptr++ = (JSAMPLE)(*cachep - 1); } } } METHODDEF(void) -pass2_fs_dither (j_decompress_ptr cinfo, - JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) +pass2_fs_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) /* This version performs Floyd-Steinberg dithering */ { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */ LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */ @@ -956,11 +955,11 @@ pass2_fs_dither (j_decompress_ptr cinfo, outptr = output_buf[row]; if (cquantize->on_odd_row) { /* work right to left in this row */ - inptr += (width-1) * 3; /* so point to rightmost pixel */ - outptr += width-1; + inptr += (width - 1) * 3; /* so point to rightmost pixel */ + outptr += width - 1; dir = -1; dir3 = -3; - errorptr = cquantize->fserrors + (width+1)*3; /* => entry after last column */ + errorptr = cquantize->fserrors + (width + 1) * 3; /* => entry after last column */ cquantize->on_odd_row = FALSE; /* flip for next time */ } else { /* work left to right in this row */ @@ -984,9 +983,9 @@ pass2_fs_dither (j_decompress_ptr cinfo, * 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); + 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. */ @@ -1004,14 +1003,17 @@ pass2_fs_dither (j_decompress_ptr cinfo, 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]; + 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); + 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; + { + register int pixcode = *cachep - 1; + *outptr = (JSAMPLE)pixcode; /* Compute representation error for this pixel */ cur0 -= GETJSAMPLE(colormap0[pixcode]); cur1 -= GETJSAMPLE(colormap1[pixcode]); @@ -1021,20 +1023,21 @@ pass2_fs_dither (j_decompress_ptr cinfo, * Add these into the running sums, and simultaneously shift the * next-line error sums left by 1 column. */ - { register LOCFSERROR bnexterr; + { + register LOCFSERROR bnexterr; bnexterr = cur0; /* Process component 0 */ - errorptr[0] = (FSERROR) (bpreverr0 + cur0 * 3); + errorptr[0] = (FSERROR)(bpreverr0 + cur0 * 3); bpreverr0 = belowerr0 + cur0 * 5; belowerr0 = bnexterr; cur0 *= 7; bnexterr = cur1; /* Process component 1 */ - errorptr[1] = (FSERROR) (bpreverr1 + cur1 * 3); + errorptr[1] = (FSERROR)(bpreverr1 + cur1 * 3); bpreverr1 = belowerr1 + cur1 * 5; belowerr1 = bnexterr; cur1 *= 7; bnexterr = cur2; /* Process component 2 */ - errorptr[2] = (FSERROR) (bpreverr2 + cur2 * 3); + errorptr[2] = (FSERROR)(bpreverr2 + cur2 * 3); bpreverr2 = belowerr2 + cur2 * 5; belowerr2 = bnexterr; cur2 *= 7; @@ -1051,9 +1054,9 @@ pass2_fs_dither (j_decompress_ptr cinfo, * 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; + errorptr[0] = (FSERROR)bpreverr0; /* unload prev errs into array */ + errorptr[1] = (FSERROR)bpreverr1; + errorptr[2] = (FSERROR)bpreverr2; } } @@ -1076,31 +1079,31 @@ pass2_fs_dither (j_decompress_ptr cinfo, */ LOCAL(void) -init_error_limit (j_decompress_ptr cinfo) +init_error_limit(j_decompress_ptr cinfo) /* Allocate and fill in the error_limiter table */ { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + 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 = (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) +#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; + 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; + 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; + table[in] = out; table[-in] = -out; } #undef STEPSIZE } @@ -1111,9 +1114,9 @@ init_error_limit (j_decompress_ptr cinfo) */ METHODDEF(void) -finish_pass1 (j_decompress_ptr cinfo) +finish_pass1(j_decompress_ptr cinfo) { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; /* Select the representative colors and fill in cinfo->colormap */ cinfo->colormap = cquantize->sv_colormap; @@ -1124,7 +1127,7 @@ finish_pass1 (j_decompress_ptr cinfo) METHODDEF(void) -finish_pass2 (j_decompress_ptr cinfo) +finish_pass2(j_decompress_ptr cinfo) { /* no work */ } @@ -1135,9 +1138,9 @@ finish_pass2 (j_decompress_ptr cinfo) */ METHODDEF(void) -start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) +start_pass_2_quant(j_decompress_ptr cinfo, boolean is_pre_scan) { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; hist3d histogram = cquantize->histogram; int i; @@ -1167,14 +1170,14 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) 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))); + 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); + cquantize->fserrors = (FSERRPTR)(*cinfo->mem->alloc_large) + ((j_common_ptr)cinfo, JPOOL_IMAGE, arraysize); /* Initialize the propagated errors to zero. */ - jzero_far((void *) cquantize->fserrors, arraysize); + jzero_far((void *)cquantize->fserrors, arraysize); /* Make the error-limit table if we didn't already. */ if (cquantize->error_limiter == NULL) init_error_limit(cinfo); @@ -1185,8 +1188,8 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) /* Zero the histogram or inverse color map, if necessary */ if (cquantize->needs_zeroed) { for (i = 0; i < HIST_C0_ELEMS; i++) { - jzero_far((void *) histogram[i], - HIST_C1_ELEMS*HIST_C2_ELEMS * sizeof(histcell)); + jzero_far((void *)histogram[i], + HIST_C1_ELEMS * HIST_C2_ELEMS * sizeof(histcell)); } cquantize->needs_zeroed = FALSE; } @@ -1198,9 +1201,9 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) */ METHODDEF(void) -new_color_map_2_quant (j_decompress_ptr cinfo) +new_color_map_2_quant(j_decompress_ptr cinfo) { - my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize; /* Reset the inverse color map */ cquantize->needs_zeroed = TRUE; @@ -1212,15 +1215,15 @@ new_color_map_2_quant (j_decompress_ptr cinfo) */ GLOBAL(void) -jinit_2pass_quantizer (j_decompress_ptr cinfo) +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, + (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, sizeof(my_cquantizer)); - cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize; + 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 */ @@ -1231,12 +1234,12 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo) 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)); + 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->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 */ @@ -1254,7 +1257,7 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo) 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); + ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)desired, (JDIMENSION)3); cquantize->desired = desired; } else cquantize->sv_colormap = NULL; @@ -1271,9 +1274,9 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo) * 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)))); + 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); } |