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