PageRenderTime 38ms CodeModel.GetById 30ms app.highlight 6ms RepoModel.GetById 1ms app.codeStats 0ms

/media/libtheora/lib/quant.c

http://github.com/zpao/v8monkey
C | 127 lines | 67 code | 3 blank | 57 comment | 14 complexity | cba98a472605c7ccc7ab2ce7711e6888 MD5 | raw file
  1/********************************************************************
  2 *                                                                  *
  3 * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
  4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
  5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  7 *                                                                  *
  8 * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
  9 * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
 10 *                                                                  *
 11 ********************************************************************
 12
 13  function:
 14    last mod: $Id: quant.c 17307 2010-06-27 06:02:15Z tterribe $
 15
 16 ********************************************************************/
 17
 18#include <stdlib.h>
 19#include <string.h>
 20#include <ogg/ogg.h>
 21#include "quant.h"
 22#include "decint.h"
 23
 24/*The maximum output of the DCT with +/- 255 inputs is +/- 8157.
 25  These minimum quantizers ensure the result after quantization (and after
 26   prediction for DC) will be no more than +/- 510.
 27  The tokenization system can handle values up to +/- 580, so there is no need
 28   to do any coefficient clamping.
 29  I would rather have allowed smaller quantizers and had to clamp, but these
 30   minimums were required when constructing the original VP3 matrices and have
 31   been formalized in the spec.*/
 32static const unsigned OC_DC_QUANT_MIN[2]={4<<2,8<<2};
 33static const unsigned OC_AC_QUANT_MIN[2]={2<<2,4<<2};
 34
 35/*Initializes the dequantization tables from a set of quantizer info.
 36  Currently the dequantizer (and elsewhere enquantizer) tables are expected to
 37   be initialized as pointing to the storage reserved for them in the
 38   oc_theora_state (resp. oc_enc_ctx) structure.
 39  If some tables are duplicates of others, the pointers will be adjusted to
 40   point to a single copy of the tables, but the storage for them will not be
 41   freed.
 42  If you're concerned about the memory footprint, the obvious thing to do is
 43   to move the storage out of its fixed place in the structures and allocate
 44   it on demand.
 45  However, a much, much better option is to only store the quantization
 46   matrices being used for the current frame, and to recalculate these as the
 47   qi values change between frames (this is what VP3 did).*/
 48void oc_dequant_tables_init(ogg_uint16_t *_dequant[64][3][2],
 49 int _pp_dc_scale[64],const th_quant_info *_qinfo){
 50  /*Coding mode: intra or inter.*/
 51  int          qti;
 52  /*Y', C_b, C_r*/
 53  int          pli;
 54  for(qti=0;qti<2;qti++)for(pli=0;pli<3;pli++){
 55    /*Quality index.*/
 56    int qi;
 57    /*Range iterator.*/
 58    int qri;
 59    for(qi=0,qri=0;qri<=_qinfo->qi_ranges[qti][pli].nranges;qri++){
 60      th_quant_base base;
 61      ogg_uint32_t  q;
 62      int           qi_start;
 63      int           qi_end;
 64      memcpy(base,_qinfo->qi_ranges[qti][pli].base_matrices[qri],
 65       sizeof(base));
 66      qi_start=qi;
 67      if(qri==_qinfo->qi_ranges[qti][pli].nranges)qi_end=qi+1;
 68      else qi_end=qi+_qinfo->qi_ranges[qti][pli].sizes[qri];
 69      /*Iterate over quality indicies in this range.*/
 70      for(;;){
 71        ogg_uint32_t qfac;
 72        int          zzi;
 73        int          ci;
 74        /*In the original VP3.2 code, the rounding offset and the size of the
 75           dead zone around 0 were controlled by a "sharpness" parameter.
 76          The size of our dead zone is now controlled by the per-coefficient
 77           quality thresholds returned by our HVS module.
 78          We round down from a more accurate value when the quality of the
 79           reconstruction does not fall below our threshold and it saves bits.
 80          Hence, all of that VP3.2 code is gone from here, and the remaining
 81           floating point code has been implemented as equivalent integer code
 82           with exact precision.*/
 83        qfac=(ogg_uint32_t)_qinfo->dc_scale[qi]*base[0];
 84        /*For postprocessing, not dequantization.*/
 85        if(_pp_dc_scale!=NULL)_pp_dc_scale[qi]=(int)(qfac/160);
 86        /*Scale DC the coefficient from the proper table.*/
 87        q=(qfac/100)<<2;
 88        q=OC_CLAMPI(OC_DC_QUANT_MIN[qti],q,OC_QUANT_MAX);
 89        _dequant[qi][pli][qti][0]=(ogg_uint16_t)q;
 90        /*Now scale AC coefficients from the proper table.*/
 91        for(zzi=1;zzi<64;zzi++){
 92          q=((ogg_uint32_t)_qinfo->ac_scale[qi]*base[OC_FZIG_ZAG[zzi]]/100)<<2;
 93          q=OC_CLAMPI(OC_AC_QUANT_MIN[qti],q,OC_QUANT_MAX);
 94          _dequant[qi][pli][qti][zzi]=(ogg_uint16_t)q;
 95        }
 96        /*If this is a duplicate of a previous matrix, use that instead.
 97          This simple check helps us improve cache coherency later.*/
 98        {
 99          int dupe;
100          int qtj;
101          int plj;
102          dupe=0;
103          for(qtj=0;qtj<=qti;qtj++){
104            for(plj=0;plj<(qtj<qti?3:pli);plj++){
105              if(!memcmp(_dequant[qi][pli][qti],_dequant[qi][plj][qtj],
106               sizeof(oc_quant_table))){
107                dupe=1;
108                break;
109              }
110            }
111            if(dupe)break;
112          }
113          if(dupe)_dequant[qi][pli][qti]=_dequant[qi][plj][qtj];
114        }
115        if(++qi>=qi_end)break;
116        /*Interpolate the next base matrix.*/
117        for(ci=0;ci<64;ci++){
118          base[ci]=(unsigned char)(
119           (2*((qi_end-qi)*_qinfo->qi_ranges[qti][pli].base_matrices[qri][ci]+
120           (qi-qi_start)*_qinfo->qi_ranges[qti][pli].base_matrices[qri+1][ci])
121           +_qinfo->qi_ranges[qti][pli].sizes[qri])/
122           (2*_qinfo->qi_ranges[qti][pli].sizes[qri]));
123        }
124      }
125    }
126  }
127}