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