Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
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

Typedefs

typedef my_idct_controllermy_idct_ptr

Functions

 jpeg_idct_islow_sse2 (j_decompress_ptr cinfo, jpeg_component_info *compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)
 start_pass (j_decompress_ptr cinfo)
 jinit_inverse_dct (j_decompress_ptr cinfo)

Variables

int SSE2Available

Class Documentation

struct my_idct_controller

Definition at line 43 of file jddctmgr.c.

Collaboration diagram for my_idct_controller:
Class Members
int cur_method
union multiplier_table

Definition at line 59 of file jddctmgr.c.

Class Members
ISLOW_MULT_TYPE islow_array

Define Documentation

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 283 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:

jpeg_idct_islow_sse2 ( j_decompress_ptr  cinfo,
jpeg_component_info compptr,
JCOEFPTR  coef_block,
JSAMPARRAY  output_buf,
JDIMENSION  output_col 
)

Here is the caller graph for this function:

Definition at line 97 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:
#ifdef HAVE_SSE2_INTEL_MNEMONICS
              if(SSE2Available == 1)
              {
                     method_ptr = jpeg_idct_islow_sse2;
                     method = JDCT_ISLOW;
              }
              else
              {
                     method_ptr = jpeg_idct_islow;
                     method = JDCT_ISLOW;
              }
#else
              method_ptr = jpeg_idct_islow;
              method = JDCT_ISLOW;
                
#endif /* HAVE_SSE2_INTEL_MNEMONICS */
       break;
#endif
#ifdef DCT_IFAST_SUPPORTED
      case JDCT_IFAST:
#ifdef HAVE_SSE2_INTEL_MNEMONICS
              if (SSE2Available==1) 
              {
                     method_ptr = jpeg_idct_islow_sse2;
                     method = JDCT_ISLOW;
              }
              else
              {
                     method_ptr = jpeg_idct_ifast;
                     method = JDCT_IFAST;
              }
#else
              method_ptr = jpeg_idct_ifast;
              method = JDCT_IFAST;
#endif /* HAVE_SSE2_INTEL_MNEMONICS */
       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:


Variable Documentation