LCOV - code coverage report
Current view: directory - media/libjpeg - jddctmgr.c (source / functions) Found Hit Coverage
Test: app.info Lines: 82 36 43.9 %
Date: 2012-06-02 Functions: 2 2 100.0 %

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

Generated by: LCOV version 1.7