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 * 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 } 352
