Back to index

plt-scheme  4.2.1
Classes | Defines | Typedefs | Functions
jddctmgr.c File Reference
#include "jinclude.h"
#include "jpeglib.h"
#include "jdct.h"

Go to the source code of this file.

Classes

struct  my_idct_controller
union  multiplier_table

Defines

#define JPEG_INTERNALS
#define PROVIDE_ISLOW_TABLES
#define CONST_BITS   14

Typedefs

typedef my_idct_controllermy_idct_ptr

Functions

 start_pass (j_decompress_ptr cinfo)
 jinit_inverse_dct (j_decompress_ptr cinfo)

Class Documentation

struct my_idct_controller

Definition at line 43 of file jddctmgr.c.

Class Members
int cur_method
union multiplier_table

Definition at line 59 of file jddctmgr.c.

Class Members
FLOAT_MULT_TYPE float_array
IFAST_MULT_TYPE ifast_array
ISLOW_MULT_TYPE islow_array

Define Documentation

#define CONST_BITS   14
#define JPEG_INTERNALS

Definition at line 18 of file jddctmgr.c.

Definition at line 74 of file jddctmgr.c.


Typedef Documentation

Definition at line 54 of file jddctmgr.c.


Function Documentation

Definition at line 247 of file jddctmgr.c.

{
  my_idct_ptr idct;
  int ci;
  jpeg_component_info *compptr;

  idct = (my_idct_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                            SIZEOF(my_idct_controller));
  cinfo->idct = (struct jpeg_inverse_dct *) idct;
  idct->pub.start_pass = start_pass;

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Allocate and pre-zero a multiplier table for each component */
    compptr->dct_table =
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                              SIZEOF(multiplier_table));
    MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
    /* Mark multiplier table not yet set up for any method */
    idct->cur_method[ci] = -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 89 of file jddctmgr.c.

{
  my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
  int ci, i;
  jpeg_component_info *compptr;
  int method = 0;
  inverse_DCT_method_ptr method_ptr = NULL;
  JQUANT_TBL * qtbl;

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Select the proper IDCT routine for this component's scaling */
    switch (compptr->DCT_scaled_size) {
#ifdef IDCT_SCALING_SUPPORTED
    case 1:
      method_ptr = jpeg_idct_1x1;
      method = JDCT_ISLOW;  /* jidctred uses islow-style table */
      break;
    case 2:
      method_ptr = jpeg_idct_2x2;
      method = JDCT_ISLOW;  /* jidctred uses islow-style table */
      break;
    case 4:
      method_ptr = jpeg_idct_4x4;
      method = JDCT_ISLOW;  /* jidctred uses islow-style table */
      break;
#endif
    case DCTSIZE:
      switch (cinfo->dct_method) {
#ifdef DCT_ISLOW_SUPPORTED
      case JDCT_ISLOW:
       method_ptr = jpeg_idct_islow;
       method = JDCT_ISLOW;
       break;
#endif
#ifdef DCT_IFAST_SUPPORTED
      case JDCT_IFAST:
       method_ptr = jpeg_idct_ifast;
       method = JDCT_IFAST;
       break;
#endif
#ifdef DCT_FLOAT_SUPPORTED
      case JDCT_FLOAT:
       method_ptr = jpeg_idct_float;
       method = JDCT_FLOAT;
       break;
#endif
      default:
       ERREXIT(cinfo, JERR_NOT_COMPILED);
       break;
      }
      break;
    default:
      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
      break;
    }
    idct->pub.inverse_DCT[ci] = method_ptr;
    /* Create multiplier table from quant table.
     * However, we can skip this if the component is uninteresting
     * or if we already built the table.  Also, if no quant table
     * has yet been saved for the component, we leave the
     * multiplier table all-zero; we'll be reading zeroes from the
     * coefficient controller's buffer anyway.
     */
    if (! compptr->component_needed || idct->cur_method[ci] == method)
      continue;
    qtbl = compptr->quant_table;
    if (qtbl == NULL)              /* happens if no data yet for component */
      continue;
    idct->cur_method[ci] = method;
    switch (method) {
#ifdef PROVIDE_ISLOW_TABLES
    case JDCT_ISLOW:
      {
       /* For LL&M IDCT method, multipliers are equal to raw quantization
        * coefficients, but are stored as ints to ensure access efficiency.
        */
       ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
       for (i = 0; i < DCTSIZE2; i++) {
         ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
       }
      }
      break;
#endif
#ifdef DCT_IFAST_SUPPORTED
    case JDCT_IFAST:
      {
       /* For AA&N IDCT method, multipliers are equal to quantization
        * coefficients scaled by scalefactor[row]*scalefactor[col], where
        *   scalefactor[0] = 1
        *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
        * For integer operation, the multiplier table is to be scaled by
        * IFAST_SCALE_BITS.
        */
       IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
#define CONST_BITS 14
       static const INT16 aanscales[DCTSIZE2] = {
         /* precomputed values scaled up by 14 bits */
         16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
         22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
         21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
         19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
         16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
         12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
          8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
          4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
       };
       SHIFT_TEMPS

       for (i = 0; i < DCTSIZE2; i++) {
         ifmtbl[i] = (IFAST_MULT_TYPE)
           DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
                              (INT32) aanscales[i]),
                  CONST_BITS-IFAST_SCALE_BITS);
       }
      }
      break;
#endif
#ifdef DCT_FLOAT_SUPPORTED
    case JDCT_FLOAT:
      {
       /* For float AA&N IDCT method, multipliers are equal to quantization
        * coefficients scaled by scalefactor[row]*scalefactor[col], where
        *   scalefactor[0] = 1
        *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
        */
       FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
       int row, col;
       static const double aanscalefactor[DCTSIZE] = {
         1.0, 1.387039845, 1.306562965, 1.175875602,
         1.0, 0.785694958, 0.541196100, 0.275899379
       };

       i = 0;
       for (row = 0; row < DCTSIZE; row++) {
         for (col = 0; col < DCTSIZE; col++) {
           fmtbl[i] = (FLOAT_MULT_TYPE)
             ((double) qtbl->quantval[i] *
              aanscalefactor[row] * aanscalefactor[col]);
           i++;
         }
       }
      }
      break;
#endif
    default:
      ERREXIT(cinfo, JERR_NOT_COMPILED);
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: