📄 jidctred.pas
字号:
{ Final output stage }
wsptr^[DCTSIZE*0] := int(DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1));
wsptr^[DCTSIZE*3] := int(DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1));
wsptr^[DCTSIZE*1] := int(DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1));
wsptr^[DCTSIZE*2] := int(DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1));
Inc(JCOEF_PTR(inptr));
Inc(ISLOW_MULT_TYPE_PTR(quantptr));
Inc(int_ptr(wsptr));
end;
{ Pass 2: process 4 rows from work array, store into output array. }
wsptr := @workspace;
for ctr := 0 to pred(4) do
begin
outptr := JSAMPROW(@ output_buf^[ctr]^[output_col]);
{ It's not clear whether a zero row test is worthwhile here ... }
{$ifndef NO_ZERO_ROW_TEST}
if ((wsptr^[1]) or (wsptr^[2]) or (wsptr^[3]) or (wsptr^[5]) or
(wsptr^[6]) or (wsptr^[7]) = 0) then
begin
{ AC terms all zero }
JSAMPLE(dcval_) := range_limit^[int(DESCALE(INT32(wsptr^[0]), PASS1_BITS+3))
and RANGE_MASK];
outptr^[0] := dcval_;
outptr^[1] := dcval_;
outptr^[2] := dcval_;
outptr^[3] := dcval_;
Inc(int_ptr(wsptr), DCTSIZE); { advance pointer to next row }
continue;
end;
{$endif}
{ Even part }
tmp0 := (INT32(wsptr^[0])) shl (CONST_BITS+1);
tmp2 := MULTIPLY(INT32(wsptr^[2]), FIX_1_847759065)
+ MULTIPLY(INT32(wsptr^[6]), - FIX_0_765366865);
tmp10 := tmp0 + tmp2;
tmp12 := tmp0 - tmp2;
{ Odd part }
z1 := INT32(wsptr^[7]);
z2 := INT32(wsptr^[5]);
z3 := INT32(wsptr^[3]);
z4 := INT32(wsptr^[1]);
tmp0 := MULTIPLY(z1, - FIX_0_211164243) { sqrt(2) * (c3-c1) }
+ MULTIPLY(z2, FIX_1_451774981) { sqrt(2) * (c3+c7) }
+ MULTIPLY(z3, - FIX_2_172734803) { sqrt(2) * (-c1-c5) }
+ MULTIPLY(z4, FIX_1_061594337); { sqrt(2) * (c5+c7) }
tmp2 := MULTIPLY(z1, - FIX_0_509795579) { sqrt(2) * (c7-c5) }
+ MULTIPLY(z2, - FIX_0_601344887) { sqrt(2) * (c5-c1) }
+ MULTIPLY(z3, FIX_0_899976223) { sqrt(2) * (c3-c7) }
+ MULTIPLY(z4, FIX_2_562915447); { sqrt(2) * (c1+c3) }
{ Final output stage }
outptr^[0] := range_limit^[ int(DESCALE(tmp10 + tmp2,
CONST_BITS+PASS1_BITS+3+1))
and RANGE_MASK];
outptr^[3] := range_limit^[ int(DESCALE(tmp10 - tmp2,
CONST_BITS+PASS1_BITS+3+1))
and RANGE_MASK];
outptr^[1] := range_limit^[ int(DESCALE(tmp12 + tmp0,
CONST_BITS+PASS1_BITS+3+1))
and RANGE_MASK];
outptr^[2] := range_limit^[ int(DESCALE(tmp12 - tmp0,
CONST_BITS+PASS1_BITS+3+1))
and RANGE_MASK];
Inc(int_ptr(wsptr), DCTSIZE); { advance pointer to next row }
end;
end;
{ Perform dequantization and inverse DCT on one block of coefficients,
producing a reduced-size 2x2 output block. }
{GLOBAL}
procedure jpeg_idct_2x2 (cinfo : j_decompress_ptr;
compptr : jpeg_component_info_ptr;
coef_block : JCOEFPTR;
output_buf : JSAMPARRAY;
output_col : JDIMENSION);
type
PWorkspace = ^TWorkspace;
TWorkspace = array[0..(DCTSIZE*2)-1] of int; { buffers data between passes }
var
tmp0, tmp10, z1 : INT32;
inptr : JCOEFPTR;
quantptr : ISLOW_MULT_TYPE_FIELD_PTR;
wsptr : PWorkspace;
outptr : JSAMPROW;
range_limit : JSAMPROW;
ctr : int;
workspace : TWorkspace; { buffers data between passes }
{SHIFT_TEMPS}
var
dcval : int;
begin
{ Each IDCT routine is responsible for range-limiting its results and
converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could
be quite far out of range if the input data is corrupt, so a bulletproof
range-limiting step is required. We use a mask-and-table-lookup method
to do the combined operations quickly. See the comments with
prepare_range_limit_table (in jdmaster.c) for more info. }
range_limit := JSAMPROW(@(cinfo^.sample_range_limit^[CENTERJSAMPLE]));
{ Pass 1: process columns from input, store into work array. }
inptr := coef_block;
quantptr := ISLOW_MULT_TYPE_FIELD_PTR (compptr^.dct_table);
wsptr := @workspace;
for ctr := DCTSIZE downto 1 do
begin
{ Don't bother to process columns 2,4,6 }
if (ctr = DCTSIZE-2) or (ctr = DCTSIZE-4) or (ctr = DCTSIZE-6) then
begin
Inc(JCOEF_PTR(inptr));
Inc(ISLOW_MULT_TYPE_PTR(quantptr));
Inc(int_ptr(wsptr));
continue;
end;
if ((inptr^[DCTSIZE*1]) or (inptr^[DCTSIZE*3]) or
(inptr^[DCTSIZE*5]) or (inptr^[DCTSIZE*7]) = 0) then
begin
{ AC terms all zero; we need not examine terms 2,4,6 for 2x2 output }
dcval := DEQUANTIZE(inptr^[DCTSIZE*0], quantptr^[DCTSIZE*0]) shl PASS1_BITS;
wsptr^[DCTSIZE*0] := dcval;
wsptr^[DCTSIZE*1] := dcval;
Inc(JCOEF_PTR(inptr));
Inc(ISLOW_MULT_TYPE_PTR(quantptr));
Inc(int_ptr(wsptr));
continue;
end;
{ Even part }
z1 := DEQUANTIZE(inptr^[DCTSIZE*0], quantptr^[DCTSIZE*0]);
tmp10 := z1 shl (CONST_BITS+2);
{ Odd part }
z1 := DEQUANTIZE(inptr^[DCTSIZE*7], quantptr^[DCTSIZE*7]);
tmp0 := MULTIPLY(z1, - FIX_0_720959822); { sqrt(2) * (c7-c5+c3-c1) }
z1 := DEQUANTIZE(inptr^[DCTSIZE*5], quantptr^[DCTSIZE*5]);
Inc(tmp0, MULTIPLY(z1, FIX_0_850430095)); { sqrt(2) * (-c1+c3+c5+c7) }
z1 := DEQUANTIZE(inptr^[DCTSIZE*3], quantptr^[DCTSIZE*3]);
Inc(tmp0, MULTIPLY(z1, - FIX_1_272758580)); { sqrt(2) * (-c1+c3-c5-c7) }
z1 := DEQUANTIZE(inptr^[DCTSIZE*1], quantptr^[DCTSIZE*1]);
Inc(tmp0, MULTIPLY(z1, FIX_3_624509785)); { sqrt(2) * (c1+c3+c5+c7) }
{ Final output stage }
wsptr^[DCTSIZE*0] := int (DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2));
wsptr^[DCTSIZE*1] := int (DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2));
Inc(JCOEF_PTR(inptr));
Inc(ISLOW_MULT_TYPE_PTR(quantptr));
Inc(int_ptr(wsptr));
end;
{ Pass 2: process 2 rows from work array, store into output array. }
wsptr := @workspace;
for ctr := 0 to pred(2) do
begin
outptr := JSAMPROW(@ output_buf^[ctr]^[output_col]);
{ It's not clear whether a zero row test is worthwhile here ... }
{$ifndef NO_ZERO_ROW_TEST}
if ((wsptr^[1]) or (wsptr^[3]) or (wsptr^[5]) or (wsptr^[7]) = 0) then
begin
{ AC terms all zero }
JSAMPLE(dcval) := range_limit^[ int(DESCALE(INT32(wsptr^[0]), PASS1_BITS+3))
and RANGE_MASK];
outptr^[0] := dcval;
outptr^[1] := dcval;
Inc(int_ptr(wsptr), DCTSIZE); { advance pointer to next row }
continue;
end;
{$endif}
{ Even part }
tmp10 := (INT32 (wsptr^[0])) shl (CONST_BITS+2);
{ Odd part }
tmp0 := MULTIPLY( INT32(wsptr^[7]), - FIX_0_720959822) { sqrt(2) * (c7-c5+c3-c1) }
+ MULTIPLY( INT32(wsptr^[5]), FIX_0_850430095) { sqrt(2) * (-c1+c3+c5+c7) }
+ MULTIPLY( INT32(wsptr^[3]), - FIX_1_272758580) { sqrt(2) * (-c1+c3-c5-c7) }
+ MULTIPLY( INT32(wsptr^[1]), FIX_3_624509785); { sqrt(2) * (c1+c3+c5+c7) }
{ Final output stage }
outptr^[0] := range_limit^[ int(DESCALE(tmp10 + tmp0,
CONST_BITS+PASS1_BITS+3+2))
and RANGE_MASK];
outptr^[1] := range_limit^[ int(DESCALE(tmp10 - tmp0,
CONST_BITS+PASS1_BITS+3+2))
and RANGE_MASK];
Inc(int_ptr(wsptr), DCTSIZE); { advance pointer to next row }
end;
end;
{ Perform dequantization and inverse DCT on one block of coefficients,
producing a reduced-size 1x1 output block. }
{GLOBAL}
procedure jpeg_idct_1x1 (cinfo : j_decompress_ptr;
compptr : jpeg_component_info_ptr;
coef_block : JCOEFPTR;
output_buf : JSAMPARRAY;
output_col : JDIMENSION);
var
dcval : int;
quantptr : ISLOW_MULT_TYPE_FIELD_PTR;
range_limit : JSAMPROW;
{SHIFT_TEMPS}
begin
{ Each IDCT routine is responsible for range-limiting its results and
converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could
be quite far out of range if the input data is corrupt, so a bulletproof
range-limiting step is required. We use a mask-and-table-lookup method
to do the combined operations quickly. See the comments with
prepare_range_limit_table (in jdmaster.c) for more info. }
range_limit := JSAMPROW(@(cinfo^.sample_range_limit^[CENTERJSAMPLE]));
{ Pass 1: process columns from input, store into work array. }
{ We hardly need an inverse DCT routine for this: just take the
average pixel value, which is one-eighth of the DC coefficient. }
quantptr := ISLOW_MULT_TYPE_FIELD_PTR (compptr^.dct_table);
dcval := DEQUANTIZE(coef_block^[0], quantptr^[0]);
dcval := int (DESCALE( INT32(dcval), 3));
output_buf^[0]^[output_col] := range_limit^[dcval and RANGE_MASK];
end;
end.⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -