593 lines
19 KiB
Plaintext
593 lines
19 KiB
Plaintext
unit imjdsample;
|
|
|
|
{ Original: jdsample.c; Copyright (C) 1991-1996, Thomas G. Lane. }
|
|
|
|
{ This file contains upsampling routines.
|
|
|
|
Upsampling input data is counted in "row groups". A row group
|
|
is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
|
|
sample rows of each component. Upsampling will normally produce
|
|
max_v_samp_factor pixel rows from each row group (but this could vary
|
|
if the upsampler is applying a scale factor of its own).
|
|
|
|
An excellent reference for image resampling is
|
|
Digital Image Warping, George Wolberg, 1990.
|
|
Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.}
|
|
|
|
interface
|
|
|
|
{$I imjconfig.inc}
|
|
|
|
uses
|
|
imjmorecfg,
|
|
imjinclude,
|
|
imjutils,
|
|
imjpeglib,
|
|
imjdeferr,
|
|
imjerror;
|
|
|
|
|
|
{ Pointer to routine to upsample a single component }
|
|
type
|
|
upsample1_ptr = procedure (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
|
|
{ Module initialization routine for upsampling. }
|
|
|
|
{GLOBAL}
|
|
procedure jinit_upsampler (cinfo : j_decompress_ptr);
|
|
|
|
implementation
|
|
|
|
{ Private subobject }
|
|
|
|
type
|
|
my_upsample_ptr = ^my_upsampler;
|
|
my_upsampler = record
|
|
pub : jpeg_upsampler; { public fields }
|
|
|
|
{ Color conversion buffer. When using separate upsampling and color
|
|
conversion steps, this buffer holds one upsampled row group until it
|
|
has been color converted and output.
|
|
Note: we do not allocate any storage for component(s) which are full-size,
|
|
ie do not need rescaling. The corresponding entry of color_buf[] is
|
|
simply set to point to the input data array, thereby avoiding copying.}
|
|
|
|
color_buf : array[0..MAX_COMPONENTS-1] of JSAMPARRAY;
|
|
|
|
{ Per-component upsampling method pointers }
|
|
methods : array[0..MAX_COMPONENTS-1] of upsample1_ptr;
|
|
|
|
next_row_out : int; { counts rows emitted from color_buf }
|
|
rows_to_go : JDIMENSION; { counts rows remaining in image }
|
|
|
|
{ Height of an input row group for each component. }
|
|
rowgroup_height : array[0..MAX_COMPONENTS-1] of int;
|
|
|
|
{ These arrays save pixel expansion factors so that int_expand need not
|
|
recompute them each time. They are unused for other upsampling methods.}
|
|
h_expand : array[0..MAX_COMPONENTS-1] of UINT8 ;
|
|
v_expand : array[0..MAX_COMPONENTS-1] of UINT8 ;
|
|
end;
|
|
|
|
|
|
{ Initialize for an upsampling pass. }
|
|
|
|
{METHODDEF}
|
|
procedure start_pass_upsample (cinfo : j_decompress_ptr);
|
|
var
|
|
upsample : my_upsample_ptr;
|
|
begin
|
|
upsample := my_upsample_ptr (cinfo^.upsample);
|
|
|
|
{ Mark the conversion buffer empty }
|
|
upsample^.next_row_out := cinfo^.max_v_samp_factor;
|
|
{ Initialize total-height counter for detecting bottom of image }
|
|
upsample^.rows_to_go := cinfo^.output_height;
|
|
end;
|
|
|
|
|
|
{ Control routine to do upsampling (and color conversion).
|
|
|
|
In this version we upsample each component independently.
|
|
We upsample one row group into the conversion buffer, then apply
|
|
color conversion a row at a time. }
|
|
|
|
{METHODDEF}
|
|
procedure sep_upsample (cinfo : j_decompress_ptr;
|
|
input_buf : JSAMPIMAGE;
|
|
var in_row_group_ctr : JDIMENSION;
|
|
in_row_groups_avail : JDIMENSION;
|
|
output_buf : JSAMPARRAY;
|
|
var out_row_ctr : JDIMENSION;
|
|
out_rows_avail : JDIMENSION);
|
|
var
|
|
upsample : my_upsample_ptr;
|
|
ci : int;
|
|
compptr : jpeg_component_info_ptr;
|
|
num_rows : JDIMENSION;
|
|
begin
|
|
upsample := my_upsample_ptr (cinfo^.upsample);
|
|
|
|
{ Fill the conversion buffer, if it's empty }
|
|
if (upsample^.next_row_out >= cinfo^.max_v_samp_factor) then
|
|
begin
|
|
compptr := jpeg_component_info_ptr(cinfo^.comp_info);
|
|
for ci := 0 to pred(cinfo^.num_components) do
|
|
begin
|
|
{ Invoke per-component upsample method. Notice we pass a POINTER
|
|
to color_buf[ci], so that fullsize_upsample can change it. }
|
|
|
|
upsample^.methods[ci] (cinfo, compptr,
|
|
JSAMPARRAY(@ input_buf^[ci]^
|
|
[LongInt(in_row_group_ctr) * upsample^.rowgroup_height[ci]]),
|
|
upsample^.color_buf[ci]);
|
|
|
|
Inc(compptr);
|
|
end;
|
|
upsample^.next_row_out := 0;
|
|
end;
|
|
|
|
{ Color-convert and emit rows }
|
|
|
|
{ How many we have in the buffer: }
|
|
num_rows := JDIMENSION (cinfo^.max_v_samp_factor - upsample^.next_row_out);
|
|
{ Not more than the distance to the end of the image. Need this test
|
|
in case the image height is not a multiple of max_v_samp_factor: }
|
|
|
|
if (num_rows > upsample^.rows_to_go) then
|
|
num_rows := upsample^.rows_to_go;
|
|
{ And not more than what the client can accept: }
|
|
Dec(out_rows_avail, out_row_ctr);
|
|
if (num_rows > out_rows_avail) then
|
|
num_rows := out_rows_avail;
|
|
|
|
cinfo^.cconvert^.color_convert (cinfo,
|
|
JSAMPIMAGE(@(upsample^.color_buf)),
|
|
JDIMENSION (upsample^.next_row_out),
|
|
JSAMPARRAY(@(output_buf^[out_row_ctr])),
|
|
int (num_rows));
|
|
|
|
{ Adjust counts }
|
|
Inc(out_row_ctr, num_rows);
|
|
Dec(upsample^.rows_to_go, num_rows);
|
|
Inc(upsample^.next_row_out, num_rows);
|
|
{ When the buffer is emptied, declare this input row group consumed }
|
|
if (upsample^.next_row_out >= cinfo^.max_v_samp_factor) then
|
|
Inc(in_row_group_ctr);
|
|
end;
|
|
|
|
|
|
{ These are the routines invoked by sep_upsample to upsample pixel values
|
|
of a single component. One row group is processed per call. }
|
|
|
|
|
|
{ For full-size components, we just make color_buf[ci] point at the
|
|
input buffer, and thus avoid copying any data. Note that this is
|
|
safe only because sep_upsample doesn't declare the input row group
|
|
"consumed" until we are done color converting and emitting it. }
|
|
|
|
{METHODDEF}
|
|
procedure fullsize_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
begin
|
|
output_data_ptr := input_data;
|
|
end;
|
|
|
|
|
|
{ This is a no-op version used for "uninteresting" components.
|
|
These components will not be referenced by color conversion. }
|
|
|
|
{METHODDEF}
|
|
procedure noop_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
begin
|
|
output_data_ptr := NIL; { safety check }
|
|
end;
|
|
|
|
|
|
{ This version handles any integral sampling ratios.
|
|
This is not used for typical JPEG files, so it need not be fast.
|
|
Nor, for that matter, is it particularly accurate: the algorithm is
|
|
simple replication of the input pixel onto the corresponding output
|
|
pixels. The hi-falutin sampling literature refers to this as a
|
|
"box filter". A box filter tends to introduce visible artifacts,
|
|
so if you are actually going to use 3:1 or 4:1 sampling ratios
|
|
you would be well advised to improve this code. }
|
|
|
|
{METHODDEF}
|
|
procedure int_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
var
|
|
upsample : my_upsample_ptr;
|
|
output_data : JSAMPARRAY;
|
|
{register} inptr, outptr : JSAMPLE_PTR;
|
|
{register} invalue : JSAMPLE;
|
|
{register} h : int;
|
|
{outend}
|
|
h_expand, v_expand : int;
|
|
inrow, outrow : int;
|
|
var
|
|
outcount : int; { Nomssi: avoid pointer arithmetic }
|
|
begin
|
|
upsample := my_upsample_ptr (cinfo^.upsample);
|
|
output_data := output_data_ptr;
|
|
|
|
h_expand := upsample^.h_expand[compptr^.component_index];
|
|
v_expand := upsample^.v_expand[compptr^.component_index];
|
|
|
|
inrow := 0;
|
|
outrow := 0;
|
|
while (outrow < cinfo^.max_v_samp_factor) do
|
|
begin
|
|
{ Generate one output row with proper horizontal expansion }
|
|
inptr := JSAMPLE_PTR(input_data^[inrow]);
|
|
outptr := JSAMPLE_PTR(output_data^[outrow]);
|
|
outcount := cinfo^.output_width;
|
|
while (outcount > 0) do { Nomssi }
|
|
begin
|
|
invalue := inptr^; { don't need GETJSAMPLE() here }
|
|
Inc(inptr);
|
|
for h := pred(h_expand) downto 0 do
|
|
begin
|
|
outptr^ := invalue;
|
|
inc(outptr); { <-- fix: this was left out in PasJpeg 1.0 }
|
|
Dec(outcount); { thanks to Jannie Gerber for the report }
|
|
end;
|
|
end;
|
|
|
|
{ Generate any additional output rows by duplicating the first one }
|
|
if (v_expand > 1) then
|
|
begin
|
|
jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
|
|
v_expand-1, cinfo^.output_width);
|
|
end;
|
|
Inc(inrow);
|
|
Inc(outrow, v_expand);
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
|
|
It's still a box filter. }
|
|
|
|
{METHODDEF}
|
|
procedure h2v1_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
var
|
|
output_data : JSAMPARRAY;
|
|
{register} inptr, outptr : JSAMPLE_PTR;
|
|
{register} invalue : JSAMPLE;
|
|
{outend : JSAMPROW;}
|
|
outcount : int;
|
|
inrow : int;
|
|
begin
|
|
output_data := output_data_ptr;
|
|
|
|
for inrow := 0 to pred(cinfo^.max_v_samp_factor) do
|
|
begin
|
|
inptr := JSAMPLE_PTR(input_data^[inrow]);
|
|
outptr := JSAMPLE_PTR(output_data^[inrow]);
|
|
{outend := outptr + cinfo^.output_width;}
|
|
outcount := cinfo^.output_width;
|
|
while (outcount > 0) do
|
|
begin
|
|
invalue := inptr^; { don't need GETJSAMPLE() here }
|
|
Inc(inptr);
|
|
outptr^ := invalue;
|
|
Inc(outptr);
|
|
outptr^ := invalue;
|
|
Inc(outptr);
|
|
Dec(outcount, 2); { Nomssi: to avoid pointer arithmetic }
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
|
|
It's still a box filter. }
|
|
|
|
{METHODDEF}
|
|
procedure h2v2_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
var
|
|
output_data : JSAMPARRAY;
|
|
{register} inptr, outptr : JSAMPLE_PTR;
|
|
{register} invalue : JSAMPLE;
|
|
{outend : JSAMPROW;}
|
|
outcount : int;
|
|
inrow, outrow : int;
|
|
begin
|
|
output_data := output_data_ptr;
|
|
|
|
inrow := 0;
|
|
outrow := 0;
|
|
while (outrow < cinfo^.max_v_samp_factor) do
|
|
begin
|
|
inptr := JSAMPLE_PTR(input_data^[inrow]);
|
|
outptr := JSAMPLE_PTR(output_data^[outrow]);
|
|
{outend := outptr + cinfo^.output_width;}
|
|
outcount := cinfo^.output_width;
|
|
while (outcount > 0) do
|
|
begin
|
|
invalue := inptr^; { don't need GETJSAMPLE() here }
|
|
Inc(inptr);
|
|
outptr^ := invalue;
|
|
Inc(outptr);
|
|
outptr^ := invalue;
|
|
Inc(outptr);
|
|
Dec(outcount, 2);
|
|
end;
|
|
jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
|
|
1, cinfo^.output_width);
|
|
Inc(inrow);
|
|
Inc(outrow, 2);
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
|
|
|
|
The upsampling algorithm is linear interpolation between pixel centers,
|
|
also known as a "triangle filter". This is a good compromise between
|
|
speed and visual quality. The centers of the output pixels are 1/4 and 3/4
|
|
of the way between input pixel centers.
|
|
|
|
A note about the "bias" calculations: when rounding fractional values to
|
|
integer, we do not want to always round 0.5 up to the next integer.
|
|
If we did that, we'd introduce a noticeable bias towards larger values.
|
|
Instead, this code is arranged so that 0.5 will be rounded up or down at
|
|
alternate pixel locations (a simple ordered dither pattern). }
|
|
|
|
{METHODDEF}
|
|
procedure h2v1_fancy_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
var
|
|
output_data : JSAMPARRAY;
|
|
{register} pre_inptr, inptr, outptr : JSAMPLE_PTR;
|
|
{register} invalue : int;
|
|
{register} colctr : JDIMENSION;
|
|
inrow : int;
|
|
begin
|
|
output_data := output_data_ptr;
|
|
|
|
for inrow := 0 to pred(cinfo^.max_v_samp_factor) do
|
|
begin
|
|
inptr := JSAMPLE_PTR(input_data^[inrow]);
|
|
outptr := JSAMPLE_PTR(output_data^[inrow]);
|
|
{ Special case for first column }
|
|
pre_inptr := inptr;
|
|
invalue := GETJSAMPLE(inptr^);
|
|
Inc(inptr);
|
|
outptr^ := JSAMPLE (invalue);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE ((invalue * 3 + GETJSAMPLE(inptr^) + 2) shr 2);
|
|
Inc(outptr);
|
|
|
|
for colctr := pred(compptr^.downsampled_width - 2) downto 0 do
|
|
begin
|
|
{ General case: 3/4 * nearer pixel + 1/4 * further pixel }
|
|
invalue := GETJSAMPLE(inptr^) * 3;
|
|
Inc(inptr);
|
|
outptr^ := JSAMPLE ((invalue + GETJSAMPLE(pre_inptr^) + 1) shr 2);
|
|
Inc(pre_inptr);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE ((invalue + GETJSAMPLE(inptr^) + 2) shr 2);
|
|
Inc(outptr);
|
|
end;
|
|
|
|
{ Special case for last column }
|
|
invalue := GETJSAMPLE(inptr^);
|
|
outptr^ := JSAMPLE ((invalue * 3 + GETJSAMPLE(pre_inptr^) + 1) shr 2);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE (invalue);
|
|
{Inc(outptr); - value never used }
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
|
|
Again a triangle filter; see comments for h2v1 case, above.
|
|
|
|
It is OK for us to reference the adjacent input rows because we demanded
|
|
context from the main buffer controller (see initialization code). }
|
|
|
|
{METHODDEF}
|
|
procedure h2v2_fancy_upsample (cinfo : j_decompress_ptr;
|
|
compptr : jpeg_component_info_ptr;
|
|
input_data : JSAMPARRAY;
|
|
var output_data_ptr : JSAMPARRAY);
|
|
var
|
|
output_data : JSAMPARRAY;
|
|
{register} inptr0, inptr1, outptr : JSAMPLE_PTR;
|
|
{$ifdef BITS_IN_JSAMPLE_IS_8}
|
|
{register} thiscolsum, lastcolsum, nextcolsum : int;
|
|
{$else}
|
|
{register} thiscolsum, lastcolsum, nextcolsum : INT32;
|
|
{$endif}
|
|
{register} colctr : JDIMENSION;
|
|
inrow, outrow, v : int;
|
|
var
|
|
prev_input_data : JSAMPARRAY; { Nomssi work around }
|
|
begin
|
|
output_data := output_data_ptr;
|
|
|
|
outrow := 0;
|
|
inrow := 0;
|
|
while (outrow < cinfo^.max_v_samp_factor) do
|
|
begin
|
|
for v := 0 to pred(2) do
|
|
begin
|
|
{ inptr0 points to nearest input row, inptr1 points to next nearest }
|
|
inptr0 := JSAMPLE_PTR(input_data^[inrow]);
|
|
if (v = 0) then { next nearest is row above }
|
|
begin
|
|
{inptr1 := JSAMPLE_PTR(input_data^[inrow-1]);}
|
|
prev_input_data := input_data; { work around }
|
|
Dec(JSAMPROW_PTR(prev_input_data)); { negative offsets }
|
|
inptr1 := JSAMPLE_PTR(prev_input_data^[inrow]);
|
|
end
|
|
else { next nearest is row below }
|
|
inptr1 := JSAMPLE_PTR(input_data^[inrow+1]);
|
|
outptr := JSAMPLE_PTR(output_data^[outrow]);
|
|
Inc(outrow);
|
|
|
|
{ Special case for first column }
|
|
thiscolsum := GETJSAMPLE(inptr0^) * 3 + GETJSAMPLE(inptr1^);
|
|
Inc(inptr0);
|
|
Inc(inptr1);
|
|
nextcolsum := GETJSAMPLE(inptr0^) * 3 + GETJSAMPLE(inptr1^);
|
|
Inc(inptr0);
|
|
Inc(inptr1);
|
|
|
|
outptr^ := JSAMPLE ((thiscolsum * 4 + 8) shr 4);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE ((thiscolsum * 3 + nextcolsum + 7) shr 4);
|
|
Inc(outptr);
|
|
lastcolsum := thiscolsum; thiscolsum := nextcolsum;
|
|
|
|
for colctr := pred(compptr^.downsampled_width - 2) downto 0 do
|
|
begin
|
|
{ General case: 3/4 * nearer pixel + 1/4 * further pixel in each }
|
|
{ dimension, thus 9/16, 3/16, 3/16, 1/16 overall }
|
|
nextcolsum := GETJSAMPLE(inptr0^) * 3 + GETJSAMPLE(inptr1^);
|
|
Inc(inptr0);
|
|
Inc(inptr1);
|
|
outptr^ := JSAMPLE ((thiscolsum * 3 + lastcolsum + 8) shr 4);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE ((thiscolsum * 3 + nextcolsum + 7) shr 4);
|
|
Inc(outptr);
|
|
lastcolsum := thiscolsum;
|
|
thiscolsum := nextcolsum;
|
|
end;
|
|
|
|
{ Special case for last column }
|
|
outptr^ := JSAMPLE ((thiscolsum * 3 + lastcolsum + 8) shr 4);
|
|
Inc(outptr);
|
|
outptr^ := JSAMPLE ((thiscolsum * 4 + 7) shr 4);
|
|
{Inc(outptr); - value never used }
|
|
end;
|
|
Inc(inrow);
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Module initialization routine for upsampling. }
|
|
|
|
{GLOBAL}
|
|
procedure jinit_upsampler (cinfo : j_decompress_ptr);
|
|
var
|
|
upsample : my_upsample_ptr;
|
|
ci : int;
|
|
compptr : jpeg_component_info_ptr;
|
|
need_buffer, do_fancy : boolean;
|
|
h_in_group, v_in_group, h_out_group, v_out_group : int;
|
|
begin
|
|
upsample := my_upsample_ptr (
|
|
cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
|
|
SIZEOF(my_upsampler)) );
|
|
cinfo^.upsample := jpeg_upsampler_ptr (upsample);
|
|
upsample^.pub.start_pass := start_pass_upsample;
|
|
upsample^.pub.upsample := sep_upsample;
|
|
upsample^.pub.need_context_rows := FALSE; { until we find out differently }
|
|
|
|
if (cinfo^.CCIR601_sampling) then { this isn't supported }
|
|
ERREXIT(j_common_ptr(cinfo), JERR_CCIR601_NOTIMPL);
|
|
|
|
{ jdmainct.c doesn't support context rows when min_DCT_scaled_size := 1,
|
|
so don't ask for it. }
|
|
|
|
do_fancy := cinfo^.do_fancy_upsampling and (cinfo^.min_DCT_scaled_size > 1);
|
|
|
|
{ Verify we can handle the sampling factors, select per-component methods,
|
|
and create storage as needed. }
|
|
|
|
compptr := jpeg_component_info_ptr(cinfo^.comp_info);
|
|
for ci := 0 to pred(cinfo^.num_components) do
|
|
begin
|
|
{ Compute size of an "input group" after IDCT scaling. This many samples
|
|
are to be converted to max_h_samp_factor * max_v_samp_factor pixels. }
|
|
|
|
h_in_group := (compptr^.h_samp_factor * compptr^.DCT_scaled_size) div
|
|
cinfo^.min_DCT_scaled_size;
|
|
v_in_group := (compptr^.v_samp_factor * compptr^.DCT_scaled_size) div
|
|
cinfo^.min_DCT_scaled_size;
|
|
h_out_group := cinfo^.max_h_samp_factor;
|
|
v_out_group := cinfo^.max_v_samp_factor;
|
|
upsample^.rowgroup_height[ci] := v_in_group; { save for use later }
|
|
need_buffer := TRUE;
|
|
if (not compptr^.component_needed) then
|
|
begin
|
|
{ Don't bother to upsample an uninteresting component. }
|
|
upsample^.methods[ci] := noop_upsample;
|
|
need_buffer := FALSE;
|
|
end
|
|
else
|
|
if (h_in_group = h_out_group) and (v_in_group = v_out_group) then
|
|
begin
|
|
{ Fullsize components can be processed without any work. }
|
|
upsample^.methods[ci] := fullsize_upsample;
|
|
need_buffer := FALSE;
|
|
end
|
|
else
|
|
if (h_in_group * 2 = h_out_group) and
|
|
(v_in_group = v_out_group) then
|
|
begin
|
|
{ Special cases for 2h1v upsampling }
|
|
if (do_fancy) and (compptr^.downsampled_width > 2) then
|
|
upsample^.methods[ci] := h2v1_fancy_upsample
|
|
else
|
|
upsample^.methods[ci] := h2v1_upsample;
|
|
end
|
|
else
|
|
if (h_in_group * 2 = h_out_group) and
|
|
(v_in_group * 2 = v_out_group) then
|
|
begin
|
|
{ Special cases for 2h2v upsampling }
|
|
if (do_fancy) and (compptr^.downsampled_width > 2) then
|
|
begin
|
|
upsample^.methods[ci] := h2v2_fancy_upsample;
|
|
upsample^.pub.need_context_rows := TRUE;
|
|
end
|
|
else
|
|
upsample^.methods[ci] := h2v2_upsample;
|
|
end
|
|
else
|
|
if ((h_out_group mod h_in_group) = 0) and
|
|
((v_out_group mod v_in_group) = 0) then
|
|
begin
|
|
{ Generic integral-factors upsampling method }
|
|
upsample^.methods[ci] := int_upsample;
|
|
upsample^.h_expand[ci] := UINT8 (h_out_group div h_in_group);
|
|
upsample^.v_expand[ci] := UINT8 (v_out_group div v_in_group);
|
|
end
|
|
else
|
|
ERREXIT(j_common_ptr(cinfo), JERR_FRACT_SAMPLE_NOTIMPL);
|
|
if (need_buffer) then
|
|
begin
|
|
upsample^.color_buf[ci] := cinfo^.mem^.alloc_sarray
|
|
(j_common_ptr(cinfo), JPOOL_IMAGE,
|
|
JDIMENSION (jround_up( long (cinfo^.output_width),
|
|
long (cinfo^.max_h_samp_factor))),
|
|
JDIMENSION (cinfo^.max_v_samp_factor));
|
|
end;
|
|
Inc(compptr);
|
|
end;
|
|
end;
|
|
|
|
end.
|