jquant2.c - Issue 1934113002: Update libjpeg_turbo to 1.4.90 from https://github.com/libjpeg-turbo/

Unified Diff: jquant2.c

Issue 1934113002: Update libjpeg_turbo to 1.4.90 from https://github.com/libjpeg-turbo/ (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/libjpeg_turbo.git@master

Patch Set: Created 4 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: jquant2.c

diff --git a/jquant2.c b/jquant2.c

index 9b060e574cd108c2b3c7fe6d4cdaa8800fb5864c..cfbd0f1526a5d14a3c10fbd554b03cbac3fc5a2e 100644

--- a/jquant2.c

+++ b/jquant2.c

@@ -4,8 +4,9 @@

* This file was part of the Independent JPEG Group's software:

* libjpeg-turbo Modifications:

- * For conditions of distribution and use, see the accompanying README file.

+ * For conditions of distribution and use, see the accompanying README.ijg

+ * file.

* This file contains 2-pass color quantization (color mapping) routines.

* These routines provide selection of a custom color map for an image,

@@ -43,7 +44,7 @@

* color space, and repeatedly splits the "largest" remaining box until we

* have as many boxes as desired colors. Then the mean color in each

* remaining box becomes one of the possible output colors.

- *

+ *

* The second pass over the image maps each input pixel to the closest output

* color (optionally after applying a Floyd-Steinberg dithering correction).

* This mapping is logically trivial, but making it go fast enough requires

@@ -72,9 +73,9 @@

* 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]]

@@ -102,9 +103,7 @@ static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE};

* machines, we can't just allocate the histogram in one chunk. Instead

* of a true 3-D array, we use a row of pointers to 2-D arrays. Each

* pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and

- * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that

- * on 80x86 machines, the pointer row is in near memory but the actual

- * arrays are in far memory (same arrangement as we use for image arrays).

+ * 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 */

@@ -112,9 +111,9 @@ static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE};

/* 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.

-#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */

-#define HIST_C1_BITS 6 /* bits of precision in G histogram */

-#define HIST_C2_BITS 5 /* bits of precision in B/R histogram */

+#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */

+#define HIST_C1_BITS 6 /* bits of precision in G histogram */

+#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)

@@ -127,13 +126,13 @@ static const int c_scales[3]={R_SCALE, G_SCALE, B_SCALE};

#define C2_SHIFT (BITS_IN_JSAMPLE-HIST_C2_BITS)

-typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */

+typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */

-typedef histcell FAR * 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 FAR * hist2d; /* type for the 2nd-level pointers */

-typedef hist2d * hist3d; /* type for top-level pointer */

+typedef hist1d *hist2d; /* type for the 2nd-level pointers */

+typedef hist2d *hist3d; /* type for top-level pointer */

/* Declarations for Floyd-Steinberg dithering.

@@ -141,8 +140,8 @@ typedef hist2d * hist3d; /* type for top-level pointer */

* Errors are accumulated into the array fserrors[], at a resolution of

* 1/16th of a pixel count. The error at a given pixel is propagated

* to its not-yet-processed neighbors using the standard F-S fractions,

- * ... (here) 7/16

- * 3/16 5/16 1/16

+ * ... (here) 7/16

+ * 3/16 5/16 1/16

* We work left-to-right on even rows, right-to-left on odd rows.

* We can get away with a single array (holding one row's worth of errors)

@@ -155,20 +154,17 @@ typedef hist2d * hist3d; /* type for top-level pointer */

* The fserrors[] array has (#columns + 2) entries; the extra entry at

* each end saves us from special-casing the first and last pixels.

* Each entry is three values long, one value for each color component.

- *

- * Note: on a wide image, we might not have enough room in a PC's near data

- * segment to hold the error array; so it is allocated with alloc_large.

#if BITS_IN_JSAMPLE == 8

-typedef INT16 FSERROR; /* 16 bits should be enough */

-typedef int LOCFSERROR; /* use 'int' for calculation temps */

+typedef INT16 FSERROR; /* 16 bits should be enough */

+typedef int LOCFSERROR; /* use 'int' for calculation temps */

#else

-typedef INT32 FSERROR; /* may need more than 16 bits */

-typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */

+typedef JLONG FSERROR; /* may need more than 16 bits */

+typedef JLONG LOCFSERROR; /* be sure calculation temps are big enough */

#endif

-typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */

+typedef FSERROR *FSERRPTR; /* pointer to error array */

/* Private subobject */

@@ -177,21 +173,21 @@ typedef struct {

struct jpeg_color_quantizer pub; /* public fields */

/* Space for the eventually created colormap is stashed here */

- JSAMPARRAY sv_colormap; /* colormap allocated at init time */

- int desired; /* desired # of colors = size of colormap */

+ JSAMPARRAY sv_colormap; /* colormap allocated at init time */

+ int desired; /* desired # of colors = size of colormap */

/* Variables for accumulating image statistics */

- hist3d histogram; /* pointer to the histogram */

+ hist3d histogram; /* pointer to the histogram */

- boolean needs_zeroed; /* TRUE if next pass must zero histogram */

+ boolean needs_zeroed; /* TRUE if next pass must zero histogram */

/* Variables for Floyd-Steinberg dithering */

- FSERRPTR fserrors; /* accumulated errors */

- boolean on_odd_row; /* flag to remember which row we are on */

- int * error_limiter; /* table for clamping the applied error */

+ FSERRPTR fserrors; /* accumulated errors */

+ boolean on_odd_row; /* flag to remember which row we are on */

+ int *error_limiter; /* table for clamping the applied error */

} my_cquantizer;

-typedef my_cquantizer * my_cquantize_ptr;

+typedef my_cquantizer *my_cquantize_ptr;

@@ -205,7 +201,7 @@ typedef my_cquantizer * my_cquantize_ptr;

METHODDEF(void)

prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,

- JSAMPARRAY output_buf, int num_rows)

+ JSAMPARRAY output_buf, int num_rows)

{

my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;

@@ -220,11 +216,11 @@ prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,

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];

+ [GETJSAMPLE(ptr[1]) >> C1_SHIFT]

+ [GETJSAMPLE(ptr[2]) >> C2_SHIFT];

/* increment, check for overflow and undo increment if so. */

if (++(*histp) <= 0)

- (*histp)--;

+ (*histp)--;

ptr += 3;

}

@@ -244,12 +240,12 @@ typedef struct {

int c1min, c1max;

int c2min, c2max;

/* The volume (actually 2-norm) of the box */

- INT32 volume;

+ JLONG volume;

/* The number of nonzero histogram cells within this box */

long colorcount;

} box;

-typedef box * boxptr;

+typedef box *boxptr;

LOCAL(boxptr)

@@ -261,7 +257,7 @@ find_biggest_color_pop (boxptr boxlist, int numboxes)

boxptr which = NULL;

for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {

if (boxp->colorcount > maxc && boxp->volume > 0) {

which = boxp;

@@ -279,9 +275,9 @@ find_biggest_volume (boxptr boxlist, int numboxes)

{

- register INT32 maxv = 0;

+ register JLONG maxv = 0;

boxptr which = NULL;

for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {

if (boxp->volume > maxv) {

which = boxp;

@@ -302,77 +298,77 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)

histptr histp;

int c0,c1,c2;

int c0min,c0max,c1min,c1max,c2min,c2max;

- INT32 dist0,dist1,dist2;

+ JLONG dist0,dist1,dist2;

long ccount;

c0min = boxp->c0min; c0max = boxp->c0max;

c1min = boxp->c1min; c1max = boxp->c1max;

c2min = boxp->c2min; c2max = boxp->c2max;

if (c0max > c0min)

for (c0 = c0min; c0 <= c0max; c0++)

for (c1 = c1min; c1 <= c1max; c1++) {

- histp = & histogram[c0][c1][c2min];

- for (c2 = c2min; c2 <= c2max; c2++)

- if (*histp++ != 0) {

- boxp->c0min = c0min = c0;

- goto have_c0min;

- }

+ histp = & histogram[c0][c1][c2min];

+ for (c2 = c2min; c2 <= c2max; c2++)

+ if (*histp++ != 0) {

+ boxp->c0min = c0min = c0;

+ goto have_c0min;

+ }

}

have_c0min:

if (c0max > c0min)

for (c0 = c0max; c0 >= c0min; c0--)

for (c1 = c1min; c1 <= c1max; c1++) {

- histp = & histogram[c0][c1][c2min];

- for (c2 = c2min; c2 <= c2max; c2++)

- if (*histp++ != 0) {

- boxp->c0max = c0max = c0;

- goto have_c0max;

- }

+ histp = & histogram[c0][c1][c2min];

+ for (c2 = c2min; c2 <= c2max; c2++)

+ if (*histp++ != 0) {

+ boxp->c0max = c0max = c0;

+ goto have_c0max;

+ }

}

have_c0max:

if (c1max > c1min)

for (c1 = c1min; c1 <= c1max; c1++)

for (c0 = c0min; c0 <= c0max; c0++) {

- histp = & histogram[c0][c1][c2min];

- for (c2 = c2min; c2 <= c2max; c2++)

- if (*histp++ != 0) {

- boxp->c1min = c1min = c1;

- goto have_c1min;

- }

+ histp = & histogram[c0][c1][c2min];

+ for (c2 = c2min; c2 <= c2max; c2++)

+ if (*histp++ != 0) {

+ boxp->c1min = c1min = c1;

+ goto have_c1min;

+ }

}

have_c1min:

if (c1max > c1min)

for (c1 = c1max; c1 >= c1min; c1--)

for (c0 = c0min; c0 <= c0max; c0++) {

- histp = & histogram[c0][c1][c2min];

- for (c2 = c2min; c2 <= c2max; c2++)

- if (*histp++ != 0) {

- boxp->c1max = c1max = c1;

- goto have_c1max;

- }

+ histp = & histogram[c0][c1][c2min];

+ for (c2 = c2min; c2 <= c2max; c2++)

+ if (*histp++ != 0) {

+ boxp->c1max = c1max = c1;

+ goto have_c1max;

+ }

}

have_c1max:

if (c2max > c2min)

for (c2 = c2min; c2 <= c2max; c2++)

for (c0 = c0min; c0 <= c0max; c0++) {

- 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;

- }

+ 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:

if (c2max > c2min)

for (c2 = c2max; c2 >= c2min; c2--)

for (c0 = c0min; c0 <= c0max; c0++) {

- 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;

- }

+ 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:

@@ -388,16 +384,16 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)

dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;

dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;

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];

for (c2 = c2min; c2 <= c2max; c2++, histp++)

- if (*histp != 0) {

- ccount++;

- }

+ if (*histp != 0) {

+ ccount++;

+ }

}

boxp->colorcount = ccount;

}

@@ -405,7 +401,7 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)

LOCAL(int)

median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,

- int desired_colors)

+ int desired_colors)

/* Repeatedly select and split the largest box until we have enough boxes */

{

int n,lb;

@@ -421,9 +417,9 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,

} else {

b1 = find_biggest_volume(boxlist, numboxes);

}

- if (b1 == NULL) /* no splittable boxes left! */

+ if (b1 == NULL) /* no splittable boxes left! */

break;

- b2 = &boxlist[numboxes]; /* where new box will go */

+ 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;

@@ -495,24 +491,24 @@ compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)

long c0total = 0;

long c1total = 0;

long c2total = 0;

c0min = boxp->c0min; c0max = boxp->c0max;

c1min = boxp->c1min; c1max = boxp->c1max;

c2min = boxp->c2min; c2max = boxp->c2max;

for (c0 = c0min; c0 <= c0max; c0++)

for (c1 = c1min; c1 <= c1max; c1++) {

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;

- }

+ 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;

+ }

}

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);

@@ -529,7 +525,7 @@ select_colors (j_decompress_ptr cinfo, int desired_colors)

/* Allocate workspace for box list */

boxlist = (boxptr) (*cinfo->mem->alloc_small)

- ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * SIZEOF(box));

+ ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * sizeof(box));

/* Initialize one box containing whole space */

numboxes = 1;

boxlist[0].c0min = 0;

@@ -576,7 +572,7 @@ select_colors (j_decompress_ptr cinfo, int desired_colors)

* distance from every colormap entry to every histogram cell. Unfortunately,

* it needs a work array to hold the best-distance-so-far for each histogram

* cell (because the inner loop has to be over cells, not colormap entries).

- * The work array elements have to be INT32s, so the work array would need

+ * The work array elements have to be JLONGs, so the work array would need

* 256Kb at our recommended precision. This is not feasible in DOS machines.

* To get around these problems, we apply Thomas' method to compute the

@@ -628,7 +624,7 @@ 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[])

+ 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

@@ -642,8 +638,8 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

int maxc0, maxc1, maxc2;

int centerc0, centerc1, centerc2;

int i, x, ncolors;

- INT32 minmaxdist, min_dist, max_dist, tdist;

- INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */

+ JLONG minmaxdist, min_dist, max_dist, tdist;

+ JLONG mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */

/* Compute true coordinates of update box's upper corner and center.

* Actually we compute the coordinates of the center of the upper-corner

@@ -685,11 +681,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

/* within cell range so no contribution to min_dist */

min_dist = 0;

if (x <= centerc0) {

- tdist = (x - maxc0) * C0_SCALE;

- max_dist = tdist*tdist;

+ tdist = (x - maxc0) * C0_SCALE;

+ max_dist = tdist*tdist;

} else {

- tdist = (x - minc0) * C0_SCALE;

- max_dist = tdist*tdist;

+ tdist = (x - minc0) * C0_SCALE;

+ max_dist = tdist*tdist;

}

@@ -707,11 +703,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

} else {

/* within cell range so no contribution to min_dist */

if (x <= centerc1) {

- tdist = (x - maxc1) * C1_SCALE;

- max_dist += tdist*tdist;

+ tdist = (x - maxc1) * C1_SCALE;

+ max_dist += tdist*tdist;

} else {

- tdist = (x - minc1) * C1_SCALE;

- max_dist += tdist*tdist;

+ tdist = (x - minc1) * C1_SCALE;

+ max_dist += tdist*tdist;

}

@@ -729,15 +725,15 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

} else {

/* within cell range so no contribution to min_dist */

if (x <= centerc2) {

- tdist = (x - maxc2) * C2_SCALE;

- max_dist += tdist*tdist;

+ tdist = (x - maxc2) * C2_SCALE;

+ max_dist += tdist*tdist;

} else {

- tdist = (x - minc2) * C2_SCALE;

- max_dist += tdist*tdist;

+ tdist = (x - minc2) * C2_SCALE;

+ max_dist += tdist*tdist;

}

- mindist[i] = min_dist; /* save away the results */

+ mindist[i] = min_dist; /* save away the results */

if (max_dist < minmaxdist)

minmaxdist = max_dist;

}

@@ -757,7 +753,7 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

LOCAL(void)

find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

- int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])

+ 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.

@@ -767,31 +763,31 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

{

int ic0, ic1, ic2;

int i, icolor;

- register INT32 * bptr; /* pointer into bestdist[] array */

- JSAMPLE * cptr; /* pointer into bestcolor[] array */

- INT32 dist0, dist1; /* initial distance values */

- register INT32 dist2; /* current distance in inner loop */

- INT32 xx0, xx1; /* distance increments */

- register INT32 xx2;

- INT32 inc0, inc1, inc2; /* initial values for increments */

+ register JLONG *bptr; /* pointer into bestdist[] array */

+ JSAMPLE *cptr; /* pointer into bestcolor[] array */

+ JLONG dist0, dist1; /* initial distance values */

+ register JLONG dist2; /* current distance in inner loop */

+ JLONG xx0, xx1; /* distance increments */

+ register JLONG xx2;

+ JLONG inc0, inc1, inc2; /* initial values for increments */

/* This array holds the distance to the nearest-so-far color for each cell */

- INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];

+ JLONG bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];

/* 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--)

*bptr++ = 0x7FFFFFFFL;

/* For each color selected by find_nearby_colors,

* compute its distance to the center of each cell in the box.

* If that's less than best-so-far, update best distance and color number.

/* Nominal steps between cell centers ("x" in Thomas article) */

#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE)

#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE)

#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE)

for (i = 0; i < numcolors; i++) {

icolor = GETJSAMPLE(colorlist[i]);

/* Compute (square of) distance from minc0/c1/c2 to this color */

@@ -813,20 +809,20 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,

dist1 = dist0;

xx1 = inc1;

for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) {

- dist2 = dist1;

- xx2 = inc2;

- for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {

- if (dist2 < *bptr) {

- *bptr = dist2;

- *cptr = (JSAMPLE) icolor;

- }

- dist2 += xx2;

- xx2 += 2 * STEP_C2 * STEP_C2;

- bptr++;

- cptr++;

- }

- dist1 += xx1;

- xx1 += 2 * STEP_C1 * STEP_C1;

+ dist2 = dist1;

+ xx2 = inc2;

+ for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {

+ if (dist2 < *bptr) {

+ *bptr = dist2;

+ *cptr = (JSAMPLE) icolor;

+ }

+ dist2 += xx2;

+ xx2 += 2 * STEP_C2 * STEP_C2;

+ bptr++;

+ cptr++;

+ }

+ dist1 += xx1;

+ xx1 += 2 * STEP_C1 * STEP_C1;

}

dist0 += xx0;

xx0 += 2 * STEP_C0 * STEP_C0;

@@ -843,13 +839,13 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)

{

my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;

hist3d histogram = cquantize->histogram;

- int minc0, minc1, minc2; /* lower left corner of update box */

+ int minc0, minc1, minc2; /* lower left corner of update box */

int ic0, ic1, ic2;

- register JSAMPLE * cptr; /* pointer into bestcolor[] array */

- register histptr cachep; /* pointer into main cache array */

+ register JSAMPLE *cptr; /* pointer into bestcolor[] array */

+ register histptr cachep; /* pointer into main cache array */

/* This array lists the candidate colormap indexes. */

JSAMPLE colorlist[MAXNUMCOLORS];

- int numcolors; /* number of candidate colors */

+ int numcolors; /* number of candidate colors */

/* This array holds the actually closest colormap index for each cell. */

JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];

@@ -865,7 +861,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)

minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);

minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);

minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);

/* Determine which colormap entries are close enough to be candidates

* for the nearest entry to some cell in the update box.

@@ -873,10 +869,10 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)

/* Determine the actually nearest colors. */

find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,

- bestcolor);

+ bestcolor);

/* Save the best color numbers (plus 1) in the main cache array */

- c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */

+ c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */

c1 <<= BOX_C1_LOG;

c2 <<= BOX_C2_LOG;

cptr = bestcolor;

@@ -884,7 +880,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)

for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {

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);

}

@@ -897,7 +893,7 @@ 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)

+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)

/* This version performs no dithering */

{

my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;

@@ -921,7 +917,7 @@ pass2_no_dither (j_decompress_ptr cinfo,

/* 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);

}

@@ -931,20 +927,20 @@ pass2_no_dither (j_decompress_ptr cinfo,

METHODDEF(void)

pass2_fs_dither (j_decompress_ptr cinfo,

- JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)

+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)

/* This version performs Floyd-Steinberg dithering */

{

my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;

hist3d histogram = cquantize->histogram;

- register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */

+ register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */

LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */

LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */

- register FSERRPTR errorptr; /* => fserrors[] at column before current */

- JSAMPROW inptr; /* => current input pixel */

- JSAMPROW outptr; /* => current output pixel */

+ register FSERRPTR errorptr; /* => fserrors[] at column before current */

+ JSAMPROW inptr; /* => current input pixel */

+ JSAMPROW outptr; /* => current output pixel */

histptr cachep;

- int dir; /* +1 or -1 depending on direction */

- int dir3; /* 3*dir, for advancing inptr & errorptr */

+ int dir; /* +1 or -1 depending on direction */

+ int dir3; /* 3*dir, for advancing inptr & errorptr */

int row;

JDIMENSION col;

JDIMENSION width = cinfo->output_width;

@@ -960,7 +956,7 @@ 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 */

+ inptr += (width-1) * 3; /* so point to rightmost pixel */

outptr += width-1;

dir = -1;

dir3 = -3;

@@ -1012,53 +1008,44 @@ pass2_fs_dither (j_decompress_ptr cinfo,

/* 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;

- /* Compute representation error for this pixel */

- cur0 -= GETJSAMPLE(colormap0[pixcode]);

- cur1 -= GETJSAMPLE(colormap1[pixcode]);

- cur2 -= GETJSAMPLE(colormap2[pixcode]);

+ *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 */

+ { register LOCFSERROR bnexterr;

+ bnexterr = cur0; /* Process component 0 */

+ 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);

+ bpreverr1 = belowerr1 + cur1 * 5;

+ belowerr1 = bnexterr;

+ cur1 *= 7;

+ bnexterr = cur2; /* Process component 2 */

+ errorptr[2] = (FSERROR) (bpreverr2 + cur2 * 3);

+ bpreverr2 = belowerr2 + cur2 * 5;

+ belowerr2 = bnexterr;

+ cur2 *= 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 */

+ inptr += dir3; /* Advance pixel pointers to next column */

outptr += dir;

- errorptr += dir3; /* advance errorptr to current column */

+ 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

@@ -1093,12 +1080,12 @@ 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 *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 */

+ ((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)

@@ -1181,16 +1168,16 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)

if (cinfo->dither_mode == JDITHER_FS) {

size_t arraysize = (size_t) ((cinfo->output_width + 2) *

- (3 * SIZEOF(FSERROR)));

+ (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 FAR *) 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);

+ init_error_limit(cinfo);

cquantize->on_odd_row = FALSE;

}

@@ -1198,8 +1185,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 FAR *) 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;

}

@@ -1232,11 +1219,11 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)

cquantize = (my_cquantize_ptr)

(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,

- SIZEOF(my_cquantizer));

+ 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->fserrors = NULL; /* flag optional arrays not allocated */

cquantize->error_limiter = NULL;

/* Make sure jdmaster didn't give me a case I can't handle */

@@ -1245,17 +1232,17 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)

/* Allocate the histogram/inverse colormap storage */

cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small)

- ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d));

+ ((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));

+ 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.

+ * We do this now since it may affect the memory manager's space

+ * calculations.

if (cinfo->enable_2pass_quant) {

/* Make sure color count is acceptable */

@@ -1278,14 +1265,15 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)

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.

+ * This isn't really needed until pass 2, but again it may affect the memory

+ * manager's space calculations. 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))));

+ (size_t) ((cinfo->output_width + 2) * (3 * sizeof(FSERROR))));

/* Might as well create the error-limiting table too. */

init_error_limit(cinfo);

}

« jconfigint.h ('K') | « jquant1.c ('k') | jsimd.h » ('j') | simd/jccolext-sse2-64.asm » ('J')