src/lib/vampimg/JpegLib/imjddctmgr.pas

   1 unit imjddctmgr;
   2
   3 { Original : jddctmgr.c ;  Copyright (C) 1994-1996, Thomas G. Lane. }
   4
   5 { This file contains the inverse-DCT management logic.
   6   This code selects a particular IDCT implementation to be used,
   7   and it performs related housekeeping chores.  No code in this file
   8   is executed per IDCT step, only during output pass setup.
   9
  10   Note that the IDCT routines are responsible for performing coefficient
  11   dequantization as well as the IDCT proper.  This module sets up the
  12   dequantization multiplier table needed by the IDCT routine. }
  13
  14 interface
  15
  16 {$I imjconfig.inc}
  17
  18 {$N+}
  19
  20 uses
  21   imjmorecfg,
  22   imjinclude,
  23   imjdeferr,
  24   imjerror,
  25   imjpeglib,
  26   imjdct,   { Private declarations for DCT subsystem }
  27   imjidctfst,
  28   {$IFDEF BASM}
  29   imjidctasm,
  30   {$ELSE}
  31   imjidctint,
  32   {$ENDIF}
  33   imjidctflt,
  34   imjidctred;
  35
  36
  37
  38 { Initialize IDCT manager. }
  39
  40 {GLOBAL}
  41 procedure jinit_inverse_dct (cinfo : j_decompress_ptr);
  42
  43
  44 implementation
  45
  46 { The decompressor input side (jdinput.c) saves away the appropriate
  47   quantization table for each component at the start of the first scan
  48   involving that component.  (This is necessary in order to correctly
  49   decode files that reuse Q-table slots.)
  50   When we are ready to make an output pass, the saved Q-table is converted
  51   to a multiplier table that will actually be used by the IDCT routine.
  52   The multiplier table contents are IDCT-method-dependent.  To support
  53   application changes in IDCT method between scans, we can remake the
  54   multiplier tables if necessary.
  55   In buffered-image mode, the first output pass may occur before any data
  56   has been seen for some components, and thus before their Q-tables have
  57   been saved away.  To handle this case, multiplier tables are preset
  58   to zeroes; the result of the IDCT will be a neutral gray level. }
  59
  60
  61 { Private subobject for this module }
  62
  63 type
  64   my_idct_ptr = ^my_idct_controller;
  65   my_idct_controller = record
  66     pub : jpeg_inverse_dct; { public fields }
  67
  68     { This array contains the IDCT method code that each multiplier table
  69       is currently set up for, or -1 if it's not yet set up.
  70       The actual multiplier tables are pointed to by dct_table in the
  71       per-component comp_info structures. }
  72
  73     cur_method : array[0..MAX_COMPONENTS-1] of int;
  74   end; {my_idct_controller;}
  75
  76
  77 { Allocated multiplier tables: big enough for any supported variant }
  78
  79 type
  80   multiplier_table = record
  81   case byte of
  82     0:(islow_array : array[0..DCTSIZE2-1] of ISLOW_MULT_TYPE);
  83   {$ifdef DCT_IFAST_SUPPORTED}
  84     1:(ifast_array : array[0..DCTSIZE2-1] of IFAST_MULT_TYPE);
  85   {$endif}
  86   {$ifdef DCT_FLOAT_SUPPORTED}
  87     2:(float_array : array[0..DCTSIZE2-1] of FLOAT_MULT_TYPE);
  88   {$endif}
  89   end;
  90
  91
  92 { The current scaled-IDCT routines require ISLOW-style multiplier tables,
  93   so be sure to compile that code if either ISLOW or SCALING is requested. }
  94
  95 {$ifdef DCT_ISLOW_SUPPORTED}
  96   {$define PROVIDE_ISLOW_TABLES}
  97 {$else}
  98   {$ifdef IDCT_SCALING_SUPPORTED}
  99     {$define PROVIDE_ISLOW_TABLES}
 100   {$endif}
 101 {$endif}
 102
 103
 104 { Prepare for an output pass.
 105   Here we select the proper IDCT routine for each component and build
 106   a matching multiplier table. }
 107
 108 {METHODDEF}
 109 procedure start_pass (cinfo : j_decompress_ptr);
 110 var
 111   idct : my_idct_ptr;
 112   ci, i : int;
 113   compptr : jpeg_component_info_ptr;
 114   method : J_DCT_METHOD;
 115   method_ptr : inverse_DCT_method_ptr;
 116   qtbl : JQUANT_TBL_PTR;
 117 {$ifdef PROVIDE_ISLOW_TABLES}
 118 var
 119   ismtbl : ISLOW_MULT_TYPE_FIELD_PTR;
 120 {$endif}
 121 {$ifdef DCT_IFAST_SUPPORTED}
 122 const
 123   CONST_BITS = 14;
 124 const
 125   aanscales : array[0..DCTSIZE2-1] of INT16 =
 126     ({ precomputed values scaled up by 14 bits }
 127      16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 128      22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
 129      21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
 130      19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
 131      16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 132      12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
 133      8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
 134      4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247);
 135 var
 136   ifmtbl : IFAST_MULT_TYPE_FIELD_PTR;
 137   {SHIFT_TEMPS}
 138
 139   { Descale and correctly round an INT32 value that's scaled by N bits.
 140     We assume RIGHT_SHIFT rounds towards minus infinity, so adding
 141     the fudge factor is correct for either sign of X. }
 142
 143   function DESCALE(x : INT32; n : int) : INT32;
 144   var
 145     shift_temp : INT32;
 146   begin
 147   {$ifdef RIGHT_SHIFT_IS_UNSIGNED}
 148     shift_temp := x + (INT32(1) shl (n-1));
 149     if shift_temp < 0 then
 150       Descale :=  (shift_temp shr n) or ((not INT32(0)) shl (32-n))
 151     else
 152       Descale :=  (shift_temp shr n);
 153   {$else}
 154     Descale := (x + (INT32(1) shl (n-1)) shr n;
 155   {$endif}
 156   end;
 157
 158 {$endif}
 159 {$ifdef DCT_FLOAT_SUPPORTED}
 160 const
 161   aanscalefactor : array[0..DCTSIZE-1] of double =
 162   (1.0, 1.387039845, 1.306562965, 1.175875602,
 163     1.0, 0.785694958, 0.541196100, 0.275899379);
 164 var
 165   fmtbl : FLOAT_MULT_TYPE_FIELD_PTR;
 166   row, col : int;
 167 {$endif}
 168 begin
 169   idct := my_idct_ptr (cinfo^.idct);
 170   method := J_DCT_METHOD(0);
 171   method_ptr := NIL;
 172   compptr := jpeg_component_info_ptr(cinfo^.comp_info);
 173
 174   for ci := 0 to pred(cinfo^.num_components) do
 175   begin
 176     { Select the proper IDCT routine for this component's scaling }
 177     case (compptr^.DCT_scaled_size) of
 178 {$ifdef IDCT_SCALING_SUPPORTED}
 179     1:begin
 180         method_ptr := jpeg_idct_1x1;
 181         method := JDCT_ISLOW; { jidctred uses islow-style table }
 182       end;
 183     2:begin
 184         method_ptr := jpeg_idct_2x2;
 185         method := JDCT_ISLOW; { jidctred uses islow-style table }
 186       end;
 187     4:begin
 188         method_ptr := jpeg_idct_4x4;
 189         method := JDCT_ISLOW; { jidctred uses islow-style table }
 190       end;
 191 {$endif}
 192     DCTSIZE:
 193       case (cinfo^.dct_method) of
 194 {$ifdef DCT_ISLOW_SUPPORTED}
 195       JDCT_ISLOW:
 196         begin
 197           method_ptr := @jpeg_idct_islow;
 198           method := JDCT_ISLOW;
 199   end;
 200 {$endif}
 201 {$ifdef DCT_IFAST_SUPPORTED}
 202       JDCT_IFAST:
 203         begin
 204           method_ptr := @jpeg_idct_ifast;
 205           method := JDCT_IFAST;
 206         end;
 207 {$endif}
 208 {$ifdef DCT_FLOAT_SUPPORTED}
 209       JDCT_FLOAT:
 210         begin
 211           method_ptr := @jpeg_idct_float;
 212           method := JDCT_FLOAT;
 213         end;
 214 {$endif}
 215       else
 216         ERREXIT(j_common_ptr(cinfo), JERR_NOT_COMPILED);
 217       end;
 218     else
 219       ERREXIT1(j_common_ptr(cinfo), JERR_BAD_DCTSIZE, compptr^.DCT_scaled_size);
 220     end;
 221     idct^.pub.inverse_DCT[ci] := method_ptr;
 222     { Create multiplier table from quant table.
 223       However, we can skip this if the component is uninteresting
 224       or if we already built the table.  Also, if no quant table
 225       has yet been saved for the component, we leave the
 226       multiplier table all-zero; we'll be reading zeroes from the
 227       coefficient controller's buffer anyway. }
 228
 229     if (not compptr^.component_needed) or (idct^.cur_method[ci] = int(method)) then
 230       continue;
 231     qtbl := compptr^.quant_table;
 232     if (qtbl = NIL) then  { happens if no data yet for component }
 233       continue;
 234     idct^.cur_method[ci] := int(method);
 235     case (method) of
 236 {$ifdef PROVIDE_ISLOW_TABLES}
 237     JDCT_ISLOW:
 238       begin
 239   { For LL&M IDCT method, multipliers are equal to raw quantization
 240     coefficients, but are stored as ints to ensure access efficiency. }
 241
 242   ismtbl := ISLOW_MULT_TYPE_FIELD_PTR (compptr^.dct_table);
 243   for i := 0 to pred(DCTSIZE2) do
 244         begin
 245     ismtbl^[i] := ISLOW_MULT_TYPE (qtbl^.quantval[i]);
 246   end;
 247       end;
 248 {$endif}
 249 {$ifdef DCT_IFAST_SUPPORTED}
 250     JDCT_IFAST:
 251       begin
 252   { For AA&N IDCT method, multipliers are equal to quantization
 253     coefficients scaled by scalefactor[row]*scalefactor[col], where
 254       scalefactor[0] := 1
 255       scalefactor[k] := cos(k*PI/16) * sqrt(2)    for k=1..7
 256     For integer operation, the multiplier table is to be scaled by
 257     IFAST_SCALE_BITS. }
 258
 259   ifmtbl := IFAST_MULT_TYPE_FIELD_PTR (compptr^.dct_table);
 260
 261   for i := 0 to pred(DCTSIZE2) do
 262         begin
 263     ifmtbl^[i] := IFAST_MULT_TYPE(
 264       DESCALE(  INT32 (qtbl^.quantval[i]) * INT32 (aanscales[i]),
 265         CONST_BITS-IFAST_SCALE_BITS) );
 266   end;
 267       end;
 268 {$endif}
 269 {$ifdef DCT_FLOAT_SUPPORTED}
 270     JDCT_FLOAT:
 271       begin
 272   { For float AA&N IDCT method, multipliers are equal to quantization
 273     coefficients scaled by scalefactor[row]*scalefactor[col], where
 274       scalefactor[0] := 1
 275       scalefactor[k] := cos(k*PI/16) * sqrt(2)    for k=1..7 }
 276
 277   fmtbl := FLOAT_MULT_TYPE_FIELD_PTR(compptr^.dct_table);
 278
 279   i := 0;
 280   for row := 0 to pred(DCTSIZE) do
 281         begin
 282     for col := 0 to pred(DCTSIZE) do
 283           begin
 284       fmtbl^[i] := {FLOAT_MULT_TYPE} (
 285          {double} qtbl^.quantval[i] *
 286          aanscalefactor[row] * aanscalefactor[col] );
 287       Inc(i);
 288     end;
 289   end;
 290       end;
 291 {$endif}
 292     else
 293       ERREXIT(j_common_ptr(cinfo), JERR_NOT_COMPILED);
 294       break;
 295     end;
 296     Inc(compptr);
 297   end;
 298 end;
 299
 300
 301 { Initialize IDCT manager. }
 302
 303 {GLOBAL}
 304 procedure jinit_inverse_dct (cinfo : j_decompress_ptr);
 305 var
 306   idct : my_idct_ptr;
 307   ci : int;
 308   compptr : jpeg_component_info_ptr;
 309 begin
 310   idct := my_idct_ptr(
 311     cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
 312         SIZEOF(my_idct_controller)) );
 313   cinfo^.idct := jpeg_inverse_dct_ptr (idct);
 314   idct^.pub.start_pass := start_pass;
 315
 316   compptr := jpeg_component_info_ptr(cinfo^.comp_info);
 317   for ci := 0 to pred(cinfo^.num_components) do
 318   begin
 319     { Allocate and pre-zero a multiplier table for each component }
 320     compptr^.dct_table :=
 321       cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
 322           SIZEOF(multiplier_table));
 323     MEMZERO(compptr^.dct_table, SIZEOF(multiplier_table));
 324     { Mark multiplier table not yet set up for any method }
 325     idct^.cur_method[ci] := -1;
 326     Inc(compptr);
 327   end;
 328 end;
 329
 330 end.