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