rosapps/lib/libjpeg/jddctmgr.c

   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 extern int SSE2Available;
  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 GLOBAL(void)
  82 jpeg_idct_islow_sse2 (
  83         j_decompress_ptr cinfo,
  84         jpeg_component_info * compptr,
  85         JCOEFPTR coef_block,
  86         JSAMPARRAY output_buf,
  87         JDIMENSION output_col);
  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       method_ptr = jpeg_idct_2x2;
 117       method = JDCT_ISLOW;      /* jidctred uses islow-style table */
 118       break;
 119     case 4:
 120       method_ptr = jpeg_idct_4x4;
 121       method = JDCT_ISLOW;      /* jidctred uses islow-style table */
 122       break;
 123 #endif
 124     case DCTSIZE:
 125       switch (cinfo->dct_method) {
 126 #ifdef DCT_ISLOW_SUPPORTED
 127       case JDCT_ISLOW:
 128 #ifdef HAVE_SSE2_INTEL_MNEMONICS
 129                 if(SSE2Available == 1)
 130                 {
 131                         method_ptr = jpeg_idct_islow_sse2;
 132                         method = JDCT_ISLOW;
 133                 }
 134                 else
 135                 {
 136                         method_ptr = jpeg_idct_islow;
 137                         method = JDCT_ISLOW;
 138                 }
 139 #else
 140                 method_ptr = jpeg_idct_islow;
 141                 method = JDCT_ISLOW;
 142
 143 #endif /* HAVE_SSE2_INTEL_MNEMONICS */
 144         break;
 145 #endif
 146 #ifdef DCT_IFAST_SUPPORTED
 147       case JDCT_IFAST:
 148 #ifdef HAVE_SSE2_INTEL_MNEMONICS
 149                 if (SSE2Available==1)
 150                 {
 151                         method_ptr = jpeg_idct_islow_sse2;
 152                         method = JDCT_ISLOW;
 153                 }
 154                 else
 155                 {
 156                         method_ptr = jpeg_idct_ifast;
 157                         method = JDCT_IFAST;
 158                 }
 159 #else
 160                 method_ptr = jpeg_idct_ifast;
 161                 method = JDCT_IFAST;
 162 #endif /* HAVE_SSE2_INTEL_MNEMONICS */
 163         break;
 164
 165 #endif
 166 #ifdef DCT_FLOAT_SUPPORTED
 167       case JDCT_FLOAT:
 168         method_ptr = jpeg_idct_float;
 169         method = JDCT_FLOAT;
 170         break;
 171 #endif
 172       default:
 173         ERREXIT(cinfo, JERR_NOT_COMPILED);
 174         break;
 175       }
 176       break;
 177     default:
 178       ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
 179       break;
 180     }
 181     idct->pub.inverse_DCT[ci] = method_ptr;
 182     /* Create multiplier table from quant table.
 183      * However, we can skip this if the component is uninteresting
 184      * or if we already built the table.  Also, if no quant table
 185      * has yet been saved for the component, we leave the
 186      * multiplier table all-zero; we'll be reading zeroes from the
 187      * coefficient controller's buffer anyway.
 188      */
 189     if (! compptr->component_needed || idct->cur_method[ci] == method)
 190       continue;
 191     qtbl = compptr->quant_table;
 192     if (qtbl == NULL)           /* happens if no data yet for component */
 193       continue;
 194     idct->cur_method[ci] = method;
 195     switch (method) {
 196 #ifdef PROVIDE_ISLOW_TABLES
 197     case JDCT_ISLOW:
 198       {
 199         /* For LL&M IDCT method, multipliers are equal to raw quantization
 200          * coefficients, but are stored as ints to ensure access efficiency.
 201          */
 202         ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
 203         for (i = 0; i < DCTSIZE2; i++) {
 204           ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
 205         }
 206       }
 207       break;
 208 #endif
 209 #ifdef DCT_IFAST_SUPPORTED
 210     case JDCT_IFAST:
 211       {
 212         /* For AA&N IDCT method, multipliers are equal to quantization
 213          * coefficients scaled by scalefactor[row]*scalefactor[col], where
 214          *   scalefactor[0] = 1
 215          *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
 216          * For integer operation, the multiplier table is to be scaled by
 217          * IFAST_SCALE_BITS.
 218          */
 219         IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
 220 #define CONST_BITS 14
 221         static const INT16 aanscales[DCTSIZE2] = {
 222           /* precomputed values scaled up by 14 bits */
 223           16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 224           22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
 225           21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
 226           19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
 227           16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
 228           12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
 229            8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
 230            4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
 231         };
 232         SHIFT_TEMPS
 233
 234         for (i = 0; i < DCTSIZE2; i++) {
 235           ifmtbl[i] = (IFAST_MULT_TYPE)
 236             DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
 237                                   (INT32) aanscales[i]),
 238                     CONST_BITS-IFAST_SCALE_BITS);
 239         }
 240       }
 241       break;
 242 #endif
 243 #ifdef DCT_FLOAT_SUPPORTED
 244     case JDCT_FLOAT:
 245       {
 246         /* For float AA&N IDCT method, multipliers are equal to quantization
 247          * coefficients scaled by scalefactor[row]*scalefactor[col], where
 248          *   scalefactor[0] = 1
 249          *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
 250          */
 251         FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
 252         int row, col;
 253         static const double aanscalefactor[DCTSIZE] = {
 254           1.0, 1.387039845, 1.306562965, 1.175875602,
 255           1.0, 0.785694958, 0.541196100, 0.275899379
 256         };
 257
 258         i = 0;
 259         for (row = 0; row < DCTSIZE; row++) {
 260           for (col = 0; col < DCTSIZE; col++) {
 261             fmtbl[i] = (FLOAT_MULT_TYPE)
 262               ((double) qtbl->quantval[i] *
 263                aanscalefactor[row] * aanscalefactor[col]);
 264             i++;
 265           }
 266         }
 267       }
 268       break;
 269 #endif
 270     default:
 271       ERREXIT(cinfo, JERR_NOT_COMPILED);
 272       break;
 273     }
 274   }
 275 }
 276
 277
 278 /*
 279  * Initialize IDCT manager.
 280  */
 281
 282 GLOBAL(void)
 283 jinit_inverse_dct (j_decompress_ptr cinfo)
 284 {
 285   my_idct_ptr idct;
 286   int ci;
 287   jpeg_component_info *compptr;
 288
 289   idct = (my_idct_ptr)
 290     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 291                                 SIZEOF(my_idct_controller));
 292   cinfo->idct = (struct jpeg_inverse_dct *) idct;
 293   idct->pub.start_pass = start_pass;
 294
 295   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 296        ci++, compptr++) {
 297     /* Allocate and pre-zero a multiplier table for each component */
 298     compptr->dct_table =
 299       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 300                                   SIZEOF(multiplier_table));
 301     MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
 302     /* Mark multiplier table not yet set up for any method */
 303     idct->cur_method[ci] = -1;
 304   }
 305 }