mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-29 11:57:32 +09:00
Issue #1933 - Part 2: Update libjpeg-turbo source.
This commit is contained in:
Job Bautista
roytam1
parent
75e223e3bf
commit
fc2133f4d1
321 changed files with 73829 additions and 50995 deletions
|
|
@ -4,7 +4,7 @@
|
|||
* This file was part of the Independent JPEG Group's software:
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* libjpeg-turbo Modifications:
|
||||
* Copyright (C) 2009, 2014-2015, D. R. Commander.
|
||||
* Copyright (C) 2009, 2014-2015, 2020, D. R. Commander.
|
||||
* For conditions of distribution and use, see the accompanying README.ijg
|
||||
* file.
|
||||
*
|
||||
|
|
@ -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[ptr[0] >> C0_SHIFT]
|
||||
[ptr[1] >> C1_SHIFT]
|
||||
[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
|
||||
|
|
@ -666,70 +665,70 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
|
|||
|
||||
for (i = 0; i < numcolors; i++) {
|
||||
/* We compute the squared-c0-distance term, then add in the other two. */
|
||||
x = GETJSAMPLE(cinfo->colormap[0][i]);
|
||||
x = 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]);
|
||||
x = 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]);
|
||||
x = 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,
|
||||
|
|
@ -789,14 +788,14 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
|
|||
#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE)
|
||||
|
||||
for (i = 0; i < numcolors; i++) {
|
||||
icolor = GETJSAMPLE(colorlist[i]);
|
||||
icolor = 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;
|
||||
inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE;
|
||||
dist0 += inc1*inc1;
|
||||
inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE;
|
||||
dist0 += inc2*inc2;
|
||||
inc0 = (minc0 - cinfo->colormap[0][icolor]) * C0_SCALE;
|
||||
dist0 = inc0 * inc0;
|
||||
inc1 = (minc1 - cinfo->colormap[1][icolor]) * C1_SCALE;
|
||||
dist0 += inc1 * inc1;
|
||||
inc2 = (minc2 - cinfo->colormap[2][icolor]) * C2_SCALE;
|
||||
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)((*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;
|
||||
|
|
@ -910,27 +909,27 @@ pass2_no_dither (j_decompress_ptr cinfo,
|
|||
outptr = output_buf[row];
|
||||
for (col = width; col > 0; col--) {
|
||||
/* get pixel value and index into the cache */
|
||||
c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT;
|
||||
c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT;
|
||||
c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT;
|
||||
cachep = & histogram[c0][c1][c2];
|
||||
c0 = (*inptr++) >> C0_SHIFT;
|
||||
c1 = (*inptr++) >> C1_SHIFT;
|
||||
c2 = (*inptr++) >> C2_SHIFT;
|
||||
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.
|
||||
*/
|
||||
|
|
@ -997,44 +996,48 @@ pass2_fs_dither (j_decompress_ptr cinfo,
|
|||
* 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]);
|
||||
cur0 += inptr[0];
|
||||
cur1 += inptr[1];
|
||||
cur2 += inptr[2];
|
||||
cur0 = range_limit[cur0];
|
||||
cur1 = range_limit[cur1];
|
||||
cur2 = 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]);
|
||||
cur2 -= GETJSAMPLE(colormap2[pixcode]);
|
||||
cur0 -= colormap0[pixcode];
|
||||
cur1 -= colormap1[pixcode];
|
||||
cur2 -= 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;
|
||||
{
|
||||
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,14 +1138,14 @@ 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;
|
||||
|
||||
/* Only F-S dithering or no dithering is supported. */
|
||||
/* If user asks for ordered dither, give him F-S. */
|
||||
/* If user asks for ordered dither, give them F-S. */
|
||||
if (cinfo->dither_mode != JDITHER_NONE)
|
||||
cinfo->dither_mode = JDITHER_FS;
|
||||
|
||||
|
|
@ -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,13 +1257,13 @@ 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;
|
||||
|
||||
/* Only F-S dithering or no dithering is supported. */
|
||||
/* If user asks for ordered dither, give him F-S. */
|
||||
/* If user asks for ordered dither, give them F-S. */
|
||||
if (cinfo->dither_mode != JDITHER_NONE)
|
||||
cinfo->dither_mode = JDITHER_FS;
|
||||
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue