aksdb
/
CentrED
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
CentrED/Imaging/JpegLib/imjquant1.pas

1010 lines
35 KiB
Plaintext
Raw Normal View History

- Added hgeol - Fixed repository side eol to be LF
2010-07-25 00:18:54 +02:00
unit imjquant1;
{ This file contains 1-pass color quantization (color mapping) routines.
These routines provide mapping to a fixed color map using equally spaced
color values. Optional Floyd-Steinberg or ordered dithering is available. }
{ Original: jquant1.c; Copyright (C) 1991-1996, Thomas G. Lane. }
interface
{$I imjconfig.inc}
uses
imjpeglib;
{GLOBAL}
procedure jinit_1pass_quantizer (cinfo : j_decompress_ptr);
implementation
uses
imjmorecfg,
imjdeferr,
imjerror,
imjutils;
{ The main purpose of 1-pass quantization is to provide a fast, if not very
high quality, colormapped output capability. A 2-pass quantizer usually
gives better visual quality; however, for quantized grayscale output this
quantizer is perfectly adequate. Dithering is highly recommended with this
quantizer, though you can turn it off if you really want to.
In 1-pass quantization the colormap must be chosen in advance of seeing the
image. We use a map consisting of all combinations of Ncolors[i] color
values for the i'th component. The Ncolors[] values are chosen so that
their product, the total number of colors, is no more than that requested.
(In most cases, the product will be somewhat less.)
Since the colormap is orthogonal, the representative value for each color
component can be determined without considering the other components;
then these indexes can be combined into a colormap index by a standard
N-dimensional-array-subscript calculation. Most of the arithmetic involved
can be precalculated and stored in the lookup table colorindex[].
colorindex[i][j] maps pixel value j in component i to the nearest
representative value (grid plane) for that component; this index is
multiplied by the array stride for component i, so that the
index of the colormap entry closest to a given pixel value is just
sum( colorindex[component-number][pixel-component-value] )
Aside from being fast, this scheme allows for variable spacing between
representative values with no additional lookup cost.
If gamma correction has been applied in color conversion, it might be wise
to adjust the color grid spacing so that the representative colors are
equidistant in linear space. At this writing, gamma correction is not
implemented by jdcolor, so nothing is done here. }
{ Declarations for ordered dithering.
We use a standard 16x16 ordered dither array. The basic concept of ordered
dithering is described in many references, for instance Dale Schumacher's
chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991).
In place of Schumacher's comparisons against a "threshold" value, we add a
"dither" value to the input pixel and then round the result to the nearest
output value. The dither value is equivalent to (0.5 - threshold) times
the distance between output values. For ordered dithering, we assume that
the output colors are equally spaced; if not, results will probably be
worse, since the dither may be too much or too little at a given point.
The normal calculation would be to form pixel value + dither, range-limit
this to 0..MAXJSAMPLE, and then index into the colorindex table as usual.
We can skip the separate range-limiting step by extending the colorindex
table in both directions. }
const
ODITHER_SIZE = 16; { dimension of dither matrix }
{ NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break }
ODITHER_CELLS = (ODITHER_SIZE*ODITHER_SIZE); { # cells in matrix }
ODITHER_MASK = (ODITHER_SIZE-1); { mask for wrapping around counters }
type
ODITHER_vector = Array[0..ODITHER_SIZE-1] of int;
ODITHER_MATRIX = Array[0..ODITHER_SIZE-1] of ODITHER_vector;
{ODITHER_MATRIX_PTR = ^array[0..ODITHER_SIZE-1] of int;}
ODITHER_MATRIX_PTR = ^ODITHER_MATRIX;
const
base_dither_matrix : Array[0..ODITHER_SIZE-1,0..ODITHER_SIZE-1] of UINT8
= (
{ Bayer's order-4 dither array. Generated by the code given in
Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
The values in this array must range from 0 to ODITHER_CELLS-1. }
( 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 ),
( 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 ),
( 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 ),
( 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 ),
( 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 ),
( 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 ),
( 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 ),
( 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 ),
( 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 ),
( 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 ),
( 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 ),
( 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 ),
( 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 ),
( 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 ),
( 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 ),
( 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 )
);
{ Declarations for Floyd-Steinberg dithering.
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
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)
by using it to store the current row's errors at pixel columns not yet
processed, but the next row's errors at columns already processed. We
need only a few extra variables to hold the errors immediately around the
current column. (If we are lucky, those variables are in registers, but
even if not, they're probably cheaper to access than array elements are.)
The fserrors[] array is indexed [component#][position].
We provide (#columns + 2) entries per component; the extra entry at each
end saves us from special-casing the first and last pixels.
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. }
{$ifdef BITS_IN_JSAMPLE_IS_8}
type
FSERROR = INT16; { 16 bits should be enough }
LOCFSERROR = int; { use 'int' for calculation temps }
{$else}
type
FSERROR = INT32; { may need more than 16 bits }
LOCFSERROR = INT32; { be sure calculation temps are big enough }
{$endif}
type
jFSError = 0..(MaxInt div SIZEOF(FSERROR))-1;
FS_ERROR_FIELD = array[jFSError] of FSERROR;
FS_ERROR_FIELD_PTR = ^FS_ERROR_FIELD;{far}
{ pointer to error array (in FAR storage!) }
FSERRORPTR = ^FSERROR;
{ Private subobject }
const
MAX_Q_COMPS = 4; { max components I can handle }
type
my_cquantize_ptr = ^my_cquantizer;
my_cquantizer = record
pub : jpeg_color_quantizer; { public fields }
{ Initially allocated colormap is saved here }
sv_colormap : JSAMPARRAY; { The color map as a 2-D pixel array }
sv_actual : int; { number of entries in use }
colorindex : JSAMPARRAY; { Precomputed mapping for speed }
{ colorindex[i][j] = index of color closest to pixel value j in component i,
premultiplied as described above. Since colormap indexes must fit into
JSAMPLEs, the entries of this array will too. }
is_padded : boolean; { is the colorindex padded for odither? }
Ncolors : array[0..MAX_Q_COMPS-1] of int;
{ # of values alloced to each component }
{ Variables for ordered dithering }
row_index : int; { cur row's vertical index in dither matrix }
odither : array[0..MAX_Q_COMPS-1] of ODITHER_MATRIX_PTR;
{ one dither array per component }
{ Variables for Floyd-Steinberg dithering }
fserrors : array[0..MAX_Q_COMPS-1] of FS_ERROR_FIELD_PTR;
{ accumulated errors }
on_odd_row : boolean; { flag to remember which row we are on }
end;
{ Policy-making subroutines for create_colormap and create_colorindex.
These routines determine the colormap to be used. The rest of the module
only assumes that the colormap is orthogonal.
* select_ncolors decides how to divvy up the available colors
among the components.
* output_value defines the set of representative values for a component.
* largest_input_value defines the mapping from input values to
representative values for a component.
Note that the latter two routines may impose different policies for
different components, though this is not currently done. }
{LOCAL}
function select_ncolors (cinfo : j_decompress_ptr;
var Ncolors : array of int) : int;
{ Determine allocation of desired colors to components, }
{ and fill in Ncolors[] array to indicate choice. }
{ Return value is total number of colors (product of Ncolors[] values). }
var
nc : int;
max_colors : int;
total_colors, iroot, i, j : int;
changed : boolean;
temp : long;
const
RGB_order:array[0..2] of int = (RGB_GREEN, RGB_RED, RGB_BLUE);
begin
nc := cinfo^.out_color_components; { number of color components }
max_colors := cinfo^.desired_number_of_colors;
{ We can allocate at least the nc'th root of max_colors per component. }
{ Compute floor(nc'th root of max_colors). }
iroot := 1;
repeat
Inc(iroot);
temp := iroot; { set temp = iroot ** nc }
for i := 1 to pred(nc) do
temp := temp * iroot;
until (temp > long(max_colors)); { repeat till iroot exceeds root }
Dec(iroot); { now iroot = floor(root) }
{ Must have at least 2 color values per component }
if (iroot < 2) then
ERREXIT1(j_common_ptr(cinfo), JERR_QUANT_FEW_COLORS, int(temp));
{ Initialize to iroot color values for each component }
total_colors := 1;
for i := 0 to pred(nc) do
begin
Ncolors[i] := iroot;
total_colors := total_colors * iroot;
end;
{ We may be able to increment the count for one or more components without
exceeding max_colors, though we know not all can be incremented.
Sometimes, the first component can be incremented more than once!
(Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.)
In RGB colorspace, try to increment G first, then R, then B. }
repeat
changed := FALSE;
for i := 0 to pred(nc) do
begin
if cinfo^.out_color_space = JCS_RGB then
j := RGB_order[i]
else
j := i;
{ calculate new total_colors if Ncolors[j] is incremented }
temp := total_colors div Ncolors[j];
temp := temp * (Ncolors[j]+1); { done in long arith to avoid oflo }
if (temp > long(max_colors)) then
break; { won't fit, done with this pass }
Inc(Ncolors[j]); { OK, apply the increment }
total_colors := int(temp);
changed := TRUE;
end;
until not changed;
select_ncolors := total_colors;
end;
{LOCAL}
function output_value (cinfo : j_decompress_ptr;
ci : int; j : int; maxj : int) : int;
{ Return j'th output value, where j will range from 0 to maxj }
{ The output values must fall in 0..MAXJSAMPLE in increasing order }
begin
{ We always provide values 0 and MAXJSAMPLE for each component;
any additional values are equally spaced between these limits.
(Forcing the upper and lower values to the limits ensures that
dithering can't produce a color outside the selected gamut.) }
output_value := int (( INT32(j) * MAXJSAMPLE + maxj div 2) div maxj);
end;
{LOCAL}
function largest_input_value (cinfo : j_decompress_ptr;
ci : int; j : int; maxj : int) : int;
{ Return largest input value that should map to j'th output value }
{ Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE }
begin
{ Breakpoints are halfway between values returned by output_value }
largest_input_value := int (( INT32(2*j + 1) * MAXJSAMPLE +
maxj) div (2*maxj));
end;
{ Create the colormap. }
{LOCAL}
procedure create_colormap (cinfo : j_decompress_ptr);
var
cquantize : my_cquantize_ptr;
colormap : JSAMPARRAY; { Created colormap }
total_colors : int; { Number of distinct output colors }
i,j,k, nci, blksize, blkdist, ptr, val : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
{ Select number of colors for each component }
total_colors := select_ncolors(cinfo, cquantize^.Ncolors);
{ Report selected color counts }
{$IFDEF DEBUG}
if (cinfo^.out_color_components = 3) then
TRACEMS4(j_common_ptr(cinfo), 1, JTRC_QUANT_3_NCOLORS,
total_colors, cquantize^.Ncolors[0],
cquantize^.Ncolors[1], cquantize^.Ncolors[2])
else
TRACEMS1(j_common_ptr(cinfo), 1, JTRC_QUANT_NCOLORS, total_colors);
{$ENDIF}
{ Allocate and fill in the colormap. }
{ The colors are ordered in the map in standard row-major order, }
{ i.e. rightmost (highest-indexed) color changes most rapidly. }
colormap := cinfo^.mem^.alloc_sarray(
j_common_ptr(cinfo), JPOOL_IMAGE,
JDIMENSION(total_colors), JDIMENSION(cinfo^.out_color_components));
{ blksize is number of adjacent repeated entries for a component }
{ blkdist is distance between groups of identical entries for a component }
blkdist := total_colors;
for i := 0 to pred(cinfo^.out_color_components) do
begin
{ fill in colormap entries for i'th color component }
nci := cquantize^.Ncolors[i]; { # of distinct values for this color }
blksize := blkdist div nci;
for j := 0 to pred(nci) do
begin
{ Compute j'th output value (out of nci) for component }
val := output_value(cinfo, i, j, nci-1);
{ Fill in all colormap entries that have this value of this component }
ptr := j * blksize;
while (ptr < total_colors) do
begin
{ fill in blksize entries beginning at ptr }
for k := 0 to pred(blksize) do
colormap^[i]^[ptr+k] := JSAMPLE(val);
Inc(ptr, blkdist);
end;
end;
blkdist := blksize; { blksize of this color is blkdist of next }
end;
{ Save the colormap in private storage,
where it will survive color quantization mode changes. }
cquantize^.sv_colormap := colormap;
cquantize^.sv_actual := total_colors;
end;
{ Create the color index table. }
{LOCAL}
procedure create_colorindex (cinfo : j_decompress_ptr);
var
cquantize : my_cquantize_ptr;
indexptr,
help_indexptr : JSAMPROW; { for negative offsets }
i,j,k, nci, blksize, val, pad : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
{ For ordered dither, we pad the color index tables by MAXJSAMPLE in
each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE).
This is not necessary in the other dithering modes. However, we
flag whether it was done in case user changes dithering mode. }
if (cinfo^.dither_mode = JDITHER_ORDERED) then
begin
pad := MAXJSAMPLE*2;
cquantize^.is_padded := TRUE;
end
else
begin
pad := 0;
cquantize^.is_padded := FALSE;
end;
cquantize^.colorindex := cinfo^.mem^.alloc_sarray
(j_common_ptr(cinfo), JPOOL_IMAGE,
JDIMENSION(MAXJSAMPLE+1 + pad),
JDIMENSION(cinfo^.out_color_components));
{ blksize is number of adjacent repeated entries for a component }
blksize := cquantize^.sv_actual;
for i := 0 to pred(cinfo^.out_color_components) do
begin
{ fill in colorindex entries for i'th color component }
nci := cquantize^.Ncolors[i]; { # of distinct values for this color }
blksize := blksize div nci;
{ adjust colorindex pointers to provide padding at negative indexes. }
if (pad <> 0) then
Inc(JSAMPLE_PTR(cquantize^.colorindex^[i]), MAXJSAMPLE);
{ in loop, val = index of current output value, }
{ and k = largest j that maps to current val }
indexptr := cquantize^.colorindex^[i];
val := 0;
k := largest_input_value(cinfo, i, 0, nci-1);
for j := 0 to MAXJSAMPLE do
begin
while (j > k) do { advance val if past boundary }
begin
Inc(val);
k := largest_input_value(cinfo, i, val, nci-1);
end;
{ premultiply so that no multiplication needed in main processing }
indexptr^[j] := JSAMPLE (val * blksize);
end;
{ Pad at both ends if necessary }
if (pad <> 0) then
begin
help_indexptr := indexptr;
{ adjust the help pointer to avoid negative offsets }
Dec(JSAMPLE_PTR(help_indexptr), MAXJSAMPLE);
for j := 1 to MAXJSAMPLE do
begin
{indexptr^[-j] := indexptr^[0];}
help_indexptr^[MAXJSAMPLE-j] := indexptr^[0];
indexptr^[MAXJSAMPLE+j] := indexptr^[MAXJSAMPLE];
end;
end;
end;
end;
{ Create an ordered-dither array for a component having ncolors
distinct output values. }
{LOCAL}
function make_odither_array (cinfo : j_decompress_ptr;
ncolors : int) : ODITHER_MATRIX_PTR;
var
odither : ODITHER_MATRIX_PTR;
j, k : int;
num, den : INT32;
begin
odither := ODITHER_MATRIX_PTR (
cinfo^.mem^.alloc_small(j_common_ptr(cinfo), JPOOL_IMAGE,
SIZEOF(ODITHER_MATRIX)));
{ The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
Hence the dither value for the matrix cell with fill order f
(f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
On 16-bit-int machine, be careful to avoid overflow. }
den := 2 * ODITHER_CELLS * ( INT32(ncolors - 1));
for j := 0 to pred(ODITHER_SIZE) do
begin
for k := 0 to pred(ODITHER_SIZE) do
begin
num := ( INT32(ODITHER_CELLS-1 - 2*( int(base_dither_matrix[j][k]))))
* MAXJSAMPLE;
{ Ensure round towards zero despite C's lack of consistency
about rounding negative values in integer division... }
if num<0 then
odither^[j][k] := int (-((-num) div den))
else
odither^[j][k] := int (num div den);
end;
end;
make_odither_array := odither;
end;
{ Create the ordered-dither tables.
Components having the same number of representative colors may
share a dither table. }
{LOCAL}
procedure create_odither_tables (cinfo : j_decompress_ptr);
var
cquantize : my_cquantize_ptr;
odither : ODITHER_MATRIX_PTR;
i, j, nci : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
for i := 0 to pred(cinfo^.out_color_components) do
begin
nci := cquantize^.Ncolors[i]; { # of distinct values for this color }
odither := NIL; { search for matching prior component }
for j := 0 to pred(i) do
begin
if (nci = cquantize^.Ncolors[j]) then
begin
odither := cquantize^.odither[j];
break;
end;
end;
if (odither = NIL) then { need a new table? }
odither := make_odither_array(cinfo, nci);
cquantize^.odither[i] := odither;
end;
end;
{ Map some rows of pixels to the output colormapped representation. }
{METHODDEF}
procedure color_quantize (cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
{ General case, no dithering }
var
cquantize : my_cquantize_ptr;
colorindex : JSAMPARRAY;
pixcode, ci : int; {register}
ptrin, ptrout : JSAMPLE_PTR; {register}
row : int;
col : JDIMENSION;
width : JDIMENSION;
nc : int; {register}
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
colorindex := cquantize^.colorindex;
width := cinfo^.output_width;
nc := cinfo^.out_color_components;
for row := 0 to pred(num_rows) do
begin
ptrin := JSAMPLE_PTR(input_buf^[row]);
ptrout := JSAMPLE_PTR(output_buf^[row]);
for col := pred(width) downto 0 do
begin
pixcode := 0;
for ci := 0 to pred(nc) do
begin
Inc(pixcode, GETJSAMPLE(colorindex^[ci]^[GETJSAMPLE(ptrin^)]) );
Inc(ptrin);
end;
ptrout^ := JSAMPLE (pixcode);
Inc(ptrout);
end;
end;
end;
{METHODDEF}
procedure color_quantize3 (cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
{ Fast path for out_color_components=3, no dithering }
var
cquantize : my_cquantize_ptr;
pixcode : int; {register}
ptrin, ptrout : JSAMPLE_PTR; {register}
colorindex0 : JSAMPROW;
colorindex1 : JSAMPROW;
colorindex2 : JSAMPROW;
row : int;
col : JDIMENSION;
width : JDIMENSION;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
colorindex0 := (cquantize^.colorindex)^[0];
colorindex1 := (cquantize^.colorindex)^[1];
colorindex2 := (cquantize^.colorindex)^[2];
width := cinfo^.output_width;
for row := 0 to pred(num_rows) do
begin
ptrin := JSAMPLE_PTR(input_buf^[row]);
ptrout := JSAMPLE_PTR(output_buf^[row]);
for col := pred(width) downto 0 do
begin
pixcode := GETJSAMPLE((colorindex0)^[GETJSAMPLE(ptrin^)]);
Inc(ptrin);
Inc( pixcode, GETJSAMPLE((colorindex1)^[GETJSAMPLE(ptrin^)]) );
Inc(ptrin);
Inc( pixcode, GETJSAMPLE((colorindex2)^[GETJSAMPLE(ptrin^)]) );
Inc(ptrin);
ptrout^ := JSAMPLE (pixcode);
Inc(ptrout);
end;
end;
end;
{METHODDEF}
procedure quantize_ord_dither (cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
{ General case, with ordered dithering }
var
cquantize : my_cquantize_ptr;
input_ptr, {register}
output_ptr : JSAMPLE_PTR; {register}
colorindex_ci : JSAMPROW;
dither : ^ODITHER_vector; { points to active row of dither matrix }
row_index, col_index : int; { current indexes into dither matrix }
nc : int;
ci : int;
row : int;
col : JDIMENSION;
width : JDIMENSION;
var
pad_offset : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
nc := cinfo^.out_color_components;
width := cinfo^.output_width;
{ Nomssi: work around negative offset }
if my_cquantize_ptr (cinfo^.cquantize)^.is_padded then
pad_offset := MAXJSAMPLE
else
pad_offset := 0;
for row := 0 to pred(num_rows) do
begin
{ Initialize output values to 0 so can process components separately }
jzero_far( {far} pointer(output_buf^[row]),
size_t(width * SIZEOF(JSAMPLE)));
row_index := cquantize^.row_index;
for ci := 0 to pred(nc) do
begin
input_ptr := JSAMPLE_PTR(@ input_buf^[row]^[ci]);
output_ptr := JSAMPLE_PTR(output_buf^[row]);
colorindex_ci := cquantize^.colorindex^[ci];
{ Nomssi }
Dec(JSAMPLE_PTR(colorindex_ci), pad_offset);
dither := @(cquantize^.odither[ci]^[row_index]);
col_index := 0;
for col := pred(width) downto 0 do
begin
{ Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
select output value, accumulate into output code for this pixel.
Range-limiting need not be done explicitly, as we have extended
the colorindex table to produce the right answers for out-of-range
inputs. The maximum dither is +- MAXJSAMPLE; this sets the
required amount of padding. }
Inc(output_ptr^,
colorindex_ci^[GETJSAMPLE(input_ptr^)+ pad_offset +
dither^[col_index]]);
Inc(output_ptr);
Inc(input_ptr, nc);
col_index := (col_index + 1) and ODITHER_MASK;
end;
end;
{ Advance row index for next row }
row_index := (row_index + 1) and ODITHER_MASK;
cquantize^.row_index := row_index;
end;
end;
{METHODDEF}
procedure quantize3_ord_dither (cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
{ Fast path for out_color_components=3, with ordered dithering }
var
cquantize : my_cquantize_ptr;
pixcode : int; {register}
input_ptr : JSAMPLE_PTR; {register}
output_ptr : JSAMPLE_PTR; {register}
colorindex0 : JSAMPROW;
colorindex1 : JSAMPROW;
colorindex2 : JSAMPROW;
dither0 : ^ODITHER_vector; { points to active row of dither matrix }
dither1 : ^ODITHER_vector;
dither2 : ^ODITHER_vector;
row_index, col_index : int; { current indexes into dither matrix }
row : int;
col : JDIMENSION;
width : JDIMENSION;
var
pad_offset : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
colorindex0 := (cquantize^.colorindex)^[0];
colorindex1 := (cquantize^.colorindex)^[1];
colorindex2 := (cquantize^.colorindex)^[2];
width := cinfo^.output_width;
{ Nomssi: work around negative offset }
if my_cquantize_ptr (cinfo^.cquantize)^.is_padded then
pad_offset := MAXJSAMPLE
else
pad_offset := 0;
Dec(JSAMPLE_PTR(colorindex0), pad_offset);
Dec(JSAMPLE_PTR(colorindex1), pad_offset);
Dec(JSAMPLE_PTR(colorindex2), pad_offset);
for row := 0 to pred(num_rows) do
begin
row_index := cquantize^.row_index;
input_ptr := JSAMPLE_PTR(input_buf^[row]);
output_ptr := JSAMPLE_PTR(output_buf^[row]);
dither0 := @(cquantize^.odither[0]^[row_index]);
dither1 := @(cquantize^.odither[1]^[row_index]);
dither2 := @(cquantize^.odither[2]^[row_index]);
col_index := 0;
for col := pred(width) downto 0 do
begin
pixcode := GETJSAMPLE(colorindex0^[GETJSAMPLE(input_ptr^) + pad_offset
+ dither0^[col_index]]);
Inc(input_ptr);
Inc(pixcode, GETJSAMPLE(colorindex1^[GETJSAMPLE(input_ptr^) + pad_offset
+ dither1^[col_index]]));
Inc(input_ptr);
Inc(pixcode, GETJSAMPLE(colorindex2^[GETJSAMPLE(input_ptr^) + pad_offset
+ dither2^[col_index]]));
Inc(input_ptr);
output_ptr^ := JSAMPLE (pixcode);
Inc(output_ptr);
col_index := (col_index + 1) and ODITHER_MASK;
end;
row_index := (row_index + 1) and ODITHER_MASK;
cquantize^.row_index := row_index;
end;
end;
{METHODDEF}
procedure quantize_fs_dither (cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
{ General case, with Floyd-Steinberg dithering }
var
cquantize : my_cquantize_ptr;
cur : LOCFSERROR; {register} { current error or pixel value }
belowerr : LOCFSERROR; { error for pixel below cur }
bpreverr : LOCFSERROR; { error for below/prev col }
bnexterr : LOCFSERROR; { error for below/next col }
delta : LOCFSERROR;
prev_errorptr,
errorptr : FSERRORPTR; {register} { => fserrors[] at column before current }
input_ptr, {register}
output_ptr : JSAMPLE_PTR; {register}
colorindex_ci : JSAMPROW;
colormap_ci : JSAMPROW;
pixcode : int;
nc : int;
dir : int; { 1 for left-to-right, -1 for right-to-left }
dirnc : int; { dir * nc }
ci : int;
row : int;
col : JDIMENSION;
width : JDIMENSION;
range_limit : range_limit_table_ptr;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
nc := cinfo^.out_color_components;
width := cinfo^.output_width;
range_limit := cinfo^.sample_range_limit;
for row := 0 to pred(num_rows) do
begin
{ Initialize output values to 0 so can process components separately }
jzero_far( (output_buf)^[row],
size_t(width * SIZEOF(JSAMPLE)));
for ci := 0 to pred(nc) do
begin
input_ptr := JSAMPLE_PTR(@ input_buf^[row]^[ci]);
output_ptr := JSAMPLE_PTR(output_buf^[row]);
errorptr := FSERRORPTR(cquantize^.fserrors[ci]); { => entry before first column }
if (cquantize^.on_odd_row) then
begin
{ work right to left in this row }
Inc(input_ptr, (width-1) * JDIMENSION(nc)); { so point to rightmost pixel }
Inc(output_ptr, width-1);
dir := -1;
dirnc := -nc;
Inc(errorptr, (width+1)); { => entry after last column }
end
else
begin
{ work left to right in this row }
dir := 1;
dirnc := nc;
{errorptr := cquantize^.fserrors[ci];}
end;
colorindex_ci := cquantize^.colorindex^[ci];
colormap_ci := (cquantize^.sv_colormap)^[ci];
{ Preset error values: no error propagated to first pixel from left }
cur := 0;
{ and no error propagated to row below yet }
belowerr := 0;
bpreverr := 0;
for col := pred(width) downto 0 do
begin
prev_errorptr := errorptr;
Inc(errorptr, dir); { advance errorptr to current column }
{ cur holds the error propagated from the previous pixel on the
current line. Add the error propagated from the previous line
to form the complete error correction term for this pixel, and
round the error term (which is expressed * 16) to an integer.
RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
for either sign of the error value.
Note: errorptr points to *previous* column's array entry. }
cur := (cur + errorptr^ + 8) div 16;
{ Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
The maximum error is +- MAXJSAMPLE; this sets the required size
of the range_limit array. }
Inc( cur, GETJSAMPLE(input_ptr^));
cur := GETJSAMPLE(range_limit^[cur]);
{ Select output value, accumulate into output code for this pixel }
pixcode := GETJSAMPLE(colorindex_ci^[cur]);
Inc(output_ptr^, JSAMPLE (pixcode));
{ Compute actual representation error at this pixel }
{ Note: we can do this even though we don't have the final }
{ pixel code, because the colormap is orthogonal. }
Dec(cur, GETJSAMPLE(colormap_ci^[pixcode]));
{ Compute error fractions to be propagated to adjacent pixels.
Add these into the running sums, and simultaneously shift the
next-line error sums left by 1 column. }
bnexterr := cur;
delta := cur * 2;
Inc(cur, delta); { form error * 3 }
prev_errorptr^ := FSERROR (bpreverr + cur);
Inc(cur, delta); { form error * 5 }
bpreverr := belowerr + cur;
belowerr := bnexterr;
Inc(cur, delta); { form error * 7 }
{ At this point cur contains the 7/16 error value to be propagated
to the next pixel on the current line, and all the errors for the
next line have been shifted over. We are therefore ready to move on. }
Inc(input_ptr, dirnc); { advance input ptr to next column }
Inc(output_ptr, dir); { advance output ptr to next column }
end;
{ Post-loop cleanup: we must unload the final error value into the
final fserrors[] entry. Note we need not unload belowerr because
it is for the dummy column before or after the actual array. }
errorptr^ := FSERROR (bpreverr); { unload prev err into array }
{ Nomssi : ?? }
end;
cquantize^.on_odd_row := not cquantize^.on_odd_row;
end;
end;
{ Allocate workspace for Floyd-Steinberg errors. }
{LOCAL}
procedure alloc_fs_workspace (cinfo : j_decompress_ptr);
var
cquantize : my_cquantize_ptr;
arraysize : size_t;
i : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
arraysize := size_t ((cinfo^.output_width + 2) * SIZEOF(FSERROR));
for i := 0 to pred(cinfo^.out_color_components) do
begin
cquantize^.fserrors[i] := FS_ERROR_FIELD_PTR(
cinfo^.mem^.alloc_large(j_common_ptr(cinfo), JPOOL_IMAGE, arraysize));
end;
end;
{ Initialize for one-pass color quantization. }
{METHODDEF}
procedure start_pass_1_quant (cinfo : j_decompress_ptr;
is_pre_scan : boolean);
var
cquantize : my_cquantize_ptr;
arraysize : size_t;
i : int;
begin
cquantize := my_cquantize_ptr (cinfo^.cquantize);
{ Install my colormap. }
cinfo^.colormap := cquantize^.sv_colormap;
cinfo^.actual_number_of_colors := cquantize^.sv_actual;
{ Initialize for desired dithering mode. }
case (cinfo^.dither_mode) of
JDITHER_NONE:
if (cinfo^.out_color_components = 3) then
cquantize^.pub.color_quantize := color_quantize3
else
cquantize^.pub.color_quantize := color_quantize;
JDITHER_ORDERED:
begin
if (cinfo^.out_color_components = 3) then
cquantize^.pub.color_quantize := quantize3_ord_dither
else
cquantize^.pub.color_quantize := quantize_ord_dither;
cquantize^.row_index := 0; { initialize state for ordered dither }
{ If user changed to ordered dither from another mode,
we must recreate the color index table with padding.
This will cost extra space, but probably isn't very likely. }
if (not cquantize^.is_padded) then
create_colorindex(cinfo);
{ Create ordered-dither tables if we didn't already. }
if (cquantize^.odither[0] = NIL) then
create_odither_tables(cinfo);
end;
JDITHER_FS:
begin
cquantize^.pub.color_quantize := quantize_fs_dither;
cquantize^.on_odd_row := FALSE; { initialize state for F-S dither }
{ Allocate Floyd-Steinberg workspace if didn't already. }
if (cquantize^.fserrors[0] = NIL) then
alloc_fs_workspace(cinfo);
{ Initialize the propagated errors to zero. }
arraysize := size_t ((cinfo^.output_width + 2) * SIZEOF(FSERROR));
for i := 0 to pred(cinfo^.out_color_components) do
jzero_far({far} pointer( cquantize^.fserrors[i] ), arraysize);
end;
else
ERREXIT(j_common_ptr(cinfo), JERR_NOT_COMPILED);
end;
end;
{ Finish up at the end of the pass. }
{METHODDEF}
procedure finish_pass_1_quant (cinfo : j_decompress_ptr);
begin
{ no work in 1-pass case }
end;
{ Switch to a new external colormap between output passes.
Shouldn't get to this module! }
{METHODDEF}
procedure new_color_map_1_quant (cinfo : j_decompress_ptr);
begin
ERREXIT(j_common_ptr(cinfo), JERR_MODE_CHANGE);
end;
{ Module initialization routine for 1-pass color quantization. }
{GLOBAL}
procedure jinit_1pass_quantizer (cinfo : j_decompress_ptr);
var
cquantize : my_cquantize_ptr;
begin
cquantize := my_cquantize_ptr(
cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
SIZEOF(my_cquantizer)));
cinfo^.cquantize := jpeg_color_quantizer_ptr(cquantize);
cquantize^.pub.start_pass := start_pass_1_quant;
cquantize^.pub.finish_pass := finish_pass_1_quant;
cquantize^.pub.new_color_map := new_color_map_1_quant;
cquantize^.fserrors[0] := NIL; { Flag FS workspace not allocated }
cquantize^.odither[0] := NIL; { Also flag odither arrays not allocated }
{ Make sure my internal arrays won't overflow }
if (cinfo^.out_color_components > MAX_Q_COMPS) then
ERREXIT1(j_common_ptr(cinfo), JERR_QUANT_COMPONENTS, MAX_Q_COMPS);
{ Make sure colormap indexes can be represented by JSAMPLEs }
if (cinfo^.desired_number_of_colors > (MAXJSAMPLE+1)) then
ERREXIT1(j_common_ptr(cinfo), JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1);
{ Create the colormap and color index table. }
create_colormap(cinfo);
create_colorindex(cinfo);
{ Allocate Floyd-Steinberg workspace now if requested.
We do this now since it is FAR storage and may affect the memory
manager's space calculations. If the user changes to FS dither
mode in a later pass, we will allocate the space then, and will
possibly overrun the max_memory_to_use setting. }
if (cinfo^.dither_mode = JDITHER_FS) then
alloc_fs_workspace(cinfo);
end;
end.