jddctmgr.c

   1 /*
   2  * jddctmgr.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1994-1996, Thomas G. Lane.
   6  * Modified 2002-2010 by Guido Vollbeding.
   7  * libjpeg-turbo Modifications:
   8  * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
   9  * Copyright (C) 2010, 2015, 2022, D. R. Commander.
  10  * Copyright (C) 2013, MIPS Technologies, Inc., California.
  11  * For conditions of distribution and use, see the accompanying README.ijg
  12  * file.
  13  *
  14  * This file contains the inverse-DCT management logic.
  15  * This code selects a particular IDCT implementation to be used,
  16  * and it performs related housekeeping chores.  No code in this file
  17  * is executed per IDCT step, only during output pass setup.
  18  *
  19  * Note that the IDCT routines are responsible for performing coefficient
  20  * dequantization as well as the IDCT proper.  This module sets up the
  21  * dequantization multiplier table needed by the IDCT routine.
  22  */
  23
  24 #define JPEG_INTERNALS
  25 #include "jinclude.h"
  26 #include "jpeglib.h"
  27 #include "jdct.h"               /* Private declarations for DCT subsystem */
  28 #include "jsimddct.h"
  29 #include "jpegapicomp.h"
  30
  31
  32 /*
  33  * The decompressor input side (jdinput.c) saves away the appropriate
  34  * quantization table for each component at the start of the first scan
  35  * involving that component.  (This is necessary in order to correctly
  36  * decode files that reuse Q-table slots.)
  37  * When we are ready to make an output pass, the saved Q-table is converted
  38  * to a multiplier table that will actually be used by the IDCT routine.
  39  * The multiplier table contents are IDCT-method-dependent.  To support
  40  * application changes in IDCT method between scans, we can remake the
  41  * multiplier tables if necessary.
  42  * In buffered-image mode, the first output pass may occur before any data
  43  * has been seen for some components, and thus before their Q-tables have
  44  * been saved away.  To handle this case, multiplier tables are preset
  45  * to zeroes; the result of the IDCT will be a neutral gray level.
  46  */
  47
  48
  49 /* Private subobject for this module */
  50
  51 typedef struct {
  52   struct jpeg_inverse_dct pub;  /* public fields */
  53
  54   /* This array contains the IDCT method code that each multiplier table
  55    * is currently set up for, or -1 if it's not yet set up.
  56    * The actual multiplier tables are pointed to by dct_table in the
  57    * per-component comp_info structures.
  58    */
  59   int cur_method[MAX_COMPONENTS];
  60 } my_idct_controller;
  61
  62 typedef my_idct_controller *my_idct_ptr;
  63
  64
  65 /* Allocated multiplier tables: big enough for any supported variant */
  66
  67 typedef union {
  68   ISLOW_MULT_TYPE islow_array[DCTSIZE2];
  69 #ifdef DCT_IFAST_SUPPORTED
  70   IFAST_MULT_TYPE ifast_array[DCTSIZE2];
  71 #endif
  72 #ifdef DCT_FLOAT_SUPPORTED
  73   FLOAT_MULT_TYPE float_array[DCTSIZE2];
  74 #endif
  75 } multiplier_table;
  76
  77
  78 /* The current scaled-IDCT routines require ISLOW-style multiplier tables,
  79  * so be sure to compile that code if either ISLOW or SCALING is requested.
  80  */
  81 #ifdef DCT_ISLOW_SUPPORTED
  82 #define PROVIDE_ISLOW_TABLES
  83 #else
  84 #ifdef IDCT_SCALING_SUPPORTED
  85 #define PROVIDE_ISLOW_TABLES
  86 #endif
  87 #endif
  88
  89
  90 /*
  91  * Prepare for an output pass.
  92  * Here we select the proper IDCT routine for each component and build
  93  * a matching multiplier table.
  94  */
  95
  96 METHODDEF(void)
  97 start_pass(j_decompress_ptr cinfo)
  98 {
  99   my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
 100   int ci, i;
 101   jpeg_component_info *compptr;
 102   int method = 0;
 103   _inverse_DCT_method_ptr method_ptr = NULL;
 104   JQUANT_TBL *qtbl;
 105
 106   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 107        ci++, compptr++) {
 108     /* Select the proper IDCT routine for this component's scaling */
 109     switch (compptr->_DCT_scaled_size) {
 110 #ifdef IDCT_SCALING_SUPPORTED
 111     case 1:
 112       method_ptr = _jpeg_idct_1x1;
 113       method = JDCT_ISLOW;      /* jidctred uses islow-style table */
 114       break;
 115     case 2:
 116 #ifdef WITH_SIMD
 117       if (jsimd_can_idct_2x2())
 118         method_ptr = jsimd_idct_2x2;
 119       else
 120 #endif
 121         method_ptr = _jpeg_idct_2x2;
 122       method = JDCT_ISLOW;      /* jidctred uses islow-style table */
 123       break;
 124     case 3:
 125       method_ptr = _jpeg_idct_3x3;
 126       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 127       break;
 128     case 4:
 129 #ifdef WITH_SIMD
 130       if (jsimd_can_idct_4x4())
 131         method_ptr = jsimd_idct_4x4;
 132       else
 133 #endif
 134         method_ptr = _jpeg_idct_4x4;
 135       method = JDCT_ISLOW;      /* jidctred uses islow-style table */
 136       break;
 137     case 5:
 138       method_ptr = _jpeg_idct_5x5;
 139       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 140       break;
 141     case 6:
 142 #if defined(WITH_SIMD) && defined(__mips__)
 143       if (jsimd_can_idct_6x6())
 144         method_ptr = jsimd_idct_6x6;
 145       else
 146 #endif
 147       method_ptr = _jpeg_idct_6x6;
 148       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 149       break;
 150     case 7:
 151       method_ptr = _jpeg_idct_7x7;
 152       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 153       break;
 154 #endif
 155     case DCTSIZE:
 156       switch (cinfo->dct_method) {
 157 #ifdef DCT_ISLOW_SUPPORTED
 158       case JDCT_ISLOW:
 159 #ifdef WITH_SIMD
 160         if (jsimd_can_idct_islow())
 161           method_ptr = jsimd_idct_islow;
 162         else
 163 #endif
 164           method_ptr = _jpeg_idct_islow;
 165         method = JDCT_ISLOW;
 166         break;
 167 #endif
 168 #ifdef DCT_IFAST_SUPPORTED
 169       case JDCT_IFAST:
 170 #ifdef WITH_SIMD
 171         if (jsimd_can_idct_ifast())
 172           method_ptr = jsimd_idct_ifast;
 173         else
 174 #endif
 175           method_ptr = _jpeg_idct_ifast;
 176         method = JDCT_IFAST;
 177         break;
 178 #endif
 179 #ifdef DCT_FLOAT_SUPPORTED
 180       case JDCT_FLOAT:
 181 #ifdef WITH_SIMD
 182         if (jsimd_can_idct_float())
 183           method_ptr = jsimd_idct_float;
 184         else
 185 #endif
 186           method_ptr = _jpeg_idct_float;
 187         method = JDCT_FLOAT;
 188         break;
 189 #endif
 190       default:
 191         ERREXIT(cinfo, JERR_NOT_COMPILED);
 192         break;
 193       }
 194       break;
 195 #ifdef IDCT_SCALING_SUPPORTED
 196     case 9:
 197       method_ptr = _jpeg_idct_9x9;
 198       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 199       break;
 200     case 10:
 201       method_ptr = _jpeg_idct_10x10;
 202       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 203       break;
 204     case 11:
 205       method_ptr = _jpeg_idct_11x11;
 206       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 207       break;
 208     case 12:
 209 #if defined(WITH_SIMD) && defined(__mips__)
 210       if (jsimd_can_idct_12x12())
 211         method_ptr = jsimd_idct_12x12;
 212       else
 213 #endif
 214       method_ptr = _jpeg_idct_12x12;
 215       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 216       break;
 217     case 13:
 218       method_ptr = _jpeg_idct_13x13;
 219       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 220       break;
 221     case 14:
 222       method_ptr = _jpeg_idct_14x14;
 223       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 224       break;
 225     case 15:
 226       method_ptr = _jpeg_idct_15x15;
 227       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 228       break;
 229     case 16:
 230       method_ptr = _jpeg_idct_16x16;
 231       method = JDCT_ISLOW;      /* jidctint uses islow-style table */
 232       break;
 233 #endif
 234     default:
 235       ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->_DCT_scaled_size);
 236       break;
 237     }
 238     idct->pub._inverse_DCT[ci] = method_ptr;
 239     /* Create multiplier table from quant table.
 240      * However, we can skip this if the component is uninteresting
 241      * or if we already built the table.  Also, if no quant table
 242      * has yet been saved for the component, we leave the
 243      * multiplier table all-zero; we'll be reading zeroes from the
 244      * coefficient controller's buffer anyway.
 245      */
 246     if (!compptr->component_needed || idct->cur_method[ci] == method)
 247       continue;
 248     qtbl = compptr->quant_table;
 249     if (qtbl == NULL)           /* happens if no data yet for component */
 250       continue;
 251     idct->cur_method[ci] = method;
 252     switch (method) {
 253 #ifdef PROVIDE_ISLOW_TABLES
 254     case JDCT_ISLOW:
 255       {
 256         /* For LL&M IDCT method, multipliers are equal to raw quantization
 257          * coefficients, but are stored as ints to ensure access efficiency.
 258          */
 259         ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *)compptr->dct_table;
 260         for (i = 0; i < DCTSIZE2; i++) {
 261           ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
 262         }
 263       }
 264       break;
 265 #endif
 266 #ifdef DCT_IFAST_SUPPORTED
 267     case JDCT_IFAST:
 268       {
 269         /* For AA&N IDCT method, multipliers are equal to quantization
 270          * coefficients scaled by scalefactor[row]*scalefactor[col], where
 271          *   scalefactor[0] = 1
 272          *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
 273          * For integer operation, the multiplier table is to be scaled by
 274          * IFAST_SCALE_BITS.
 275          */
 276         IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
 277 #define CONST_BITS  14
 278         static const INT16 aanscales[DCTSIZE2] = {
 279           /* precomputed values scaled up by 14 bits */
 280           16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 281           22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
 282           21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
 283           19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
 284           16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 285           12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
 286            8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
 287            4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
 288         };
 289         SHIFT_TEMPS
 290
 291         for (i = 0; i < DCTSIZE2; i++) {
 292           ifmtbl[i] = (IFAST_MULT_TYPE)
 293             DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
 294                                   (JLONG)aanscales[i]),
 295                     CONST_BITS - IFAST_SCALE_BITS);
 296         }
 297       }
 298       break;
 299 #endif
 300 #ifdef DCT_FLOAT_SUPPORTED
 301     case JDCT_FLOAT:
 302       {
 303         /* For float AA&N IDCT method, multipliers are equal to quantization
 304          * coefficients scaled by scalefactor[row]*scalefactor[col], where
 305          *   scalefactor[0] = 1
 306          *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
 307          */
 308         FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *)compptr->dct_table;
 309         int row, col;
 310         static const double aanscalefactor[DCTSIZE] = {
 311           1.0, 1.387039845, 1.306562965, 1.175875602,
 312           1.0, 0.785694958, 0.541196100, 0.275899379
 313         };
 314
 315         i = 0;
 316         for (row = 0; row < DCTSIZE; row++) {
 317           for (col = 0; col < DCTSIZE; col++) {
 318             fmtbl[i] = (FLOAT_MULT_TYPE)
 319               ((double)qtbl->quantval[i] *
 320                aanscalefactor[row] * aanscalefactor[col]);
 321             i++;
 322           }
 323         }
 324       }
 325       break;
 326 #endif
 327     default:
 328       ERREXIT(cinfo, JERR_NOT_COMPILED);
 329       break;
 330     }
 331   }
 332 }
 333
 334
 335 /*
 336  * Initialize IDCT manager.
 337  */
 338
 339 GLOBAL(void)
 340 _jinit_inverse_dct(j_decompress_ptr cinfo)
 341 {
 342   my_idct_ptr idct;
 343   int ci;
 344   jpeg_component_info *compptr;
 345
 346   if (cinfo->data_precision != BITS_IN_JSAMPLE)
 347     ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
 348
 349   idct = (my_idct_ptr)
 350     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 351                                 sizeof(my_idct_controller));
 352   cinfo->idct = (struct jpeg_inverse_dct *)idct;
 353   idct->pub.start_pass = start_pass;
 354
 355   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 356        ci++, compptr++) {
 357     /* Allocate and pre-zero a multiplier table for each component */
 358     compptr->dct_table =
 359       (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 360                                   sizeof(multiplier_table));
 361     memset(compptr->dct_table, 0, sizeof(multiplier_table));
 362     /* Mark multiplier table not yet set up for any method */
 363     idct->cur_method[ci] = -1;
 364   }
 365 }