vp8/encoder/quantize.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #include <math.h>
  13 #include "vpx_mem/vpx_mem.h"
  14
  15 #include "quantize.h"
  16 #include "entropy.h"
  17 #include "predictdc.h"
  18
  19 //#define EXACT_QUANT
  20 #ifdef EXACT_QUANT
  21 void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d)
  22 {
  23     int i, rc, eob;
  24     int zbin;
  25     int x, y, z, sz;
  26     short *coeff_ptr       = b->coeff;
  27     short *zbin_ptr        = b->zbin;
  28     short *round_ptr       = b->round;
  29     short *quant_ptr       = b->quant;
  30     short *quant_shift_ptr = b->quant_shift;
  31     short *qcoeff_ptr      = d->qcoeff;
  32     short *dqcoeff_ptr     = d->dqcoeff;
  33     short *dequant_ptr     = d->dequant;
  34
  35     vpx_memset(qcoeff_ptr, 0, 32);
  36     vpx_memset(dqcoeff_ptr, 0, 32);
  37
  38     eob = -1;
  39
  40     for (i = 0; i < 16; i++)
  41     {
  42         rc   = vp8_default_zig_zag1d[i];
  43         z    = coeff_ptr[rc];
  44         zbin = zbin_ptr[rc] ;
  45
  46         sz = (z >> 31);                                 // sign of z
  47         x  = (z ^ sz) - sz;                             // x = abs(z)
  48
  49         if (x >= zbin)
  50         {
  51             x += round_ptr[rc];
  52             y  = (((x * quant_ptr[rc]) >> 16) + x)
  53                  >> quant_shift_ptr[rc];                // quantize (x)
  54             x  = (y ^ sz) - sz;                         // get the sign back
  55             qcoeff_ptr[rc] = x;                          // write to destination
  56             dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
  57
  58             if (y)
  59             {
  60                 eob = i;                                // last nonzero coeffs
  61             }
  62         }
  63     }
  64     d->eob = eob + 1;
  65 }
  66
  67 void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d)
  68 {
  69     int i, rc, eob;
  70     int zbin;
  71     int x, y, z, sz;
  72     short *zbin_boost_ptr  = b->zrun_zbin_boost;
  73     short *coeff_ptr       = b->coeff;
  74     short *zbin_ptr        = b->zbin;
  75     short *round_ptr       = b->round;
  76     short *quant_ptr       = b->quant;
  77     short *quant_shift_ptr = b->quant_shift;
  78     short *qcoeff_ptr      = d->qcoeff;
  79     short *dqcoeff_ptr     = d->dqcoeff;
  80     short *dequant_ptr     = d->dequant;
  81     short zbin_oq_value    = b->zbin_extra;
  82
  83     vpx_memset(qcoeff_ptr, 0, 32);
  84     vpx_memset(dqcoeff_ptr, 0, 32);
  85
  86     eob = -1;
  87
  88     for (i = 0; i < 16; i++)
  89     {
  90         rc   = vp8_default_zig_zag1d[i];
  91         z    = coeff_ptr[rc];
  92
  93         //if ( i == 0 )
  94         //    zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value/2;
  95         //else
  96         zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value;
  97
  98         zbin_boost_ptr ++;
  99         sz = (z >> 31);                                 // sign of z
 100         x  = (z ^ sz) - sz;                             // x = abs(z)
 101
 102         if (x >= zbin)
 103         {
 104             x += round_ptr[rc];
 105             y  = (((x * quant_ptr[rc]) >> 16) + x)
 106                  >> quant_shift_ptr[rc];                // quantize (x)
 107             x  = (y ^ sz) - sz;                         // get the sign back
 108             qcoeff_ptr[rc]  = x;                         // write to destination
 109             dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
 110
 111             if (y)
 112             {
 113                 eob = i;                                // last nonzero coeffs
 114                 zbin_boost_ptr = &b->zrun_zbin_boost[0];    // reset zero runlength
 115             }
 116         }
 117     }
 118
 119     d->eob = eob + 1;
 120 }
 121
 122 /* Perform regular quantization, with unbiased rounding and no zero bin. */
 123 void vp8_strict_quantize_b(BLOCK *b, BLOCKD *d)
 124 {
 125     int i;
 126     int rc;
 127     int eob;
 128     int x;
 129     int y;
 130     int z;
 131     int sz;
 132     short *coeff_ptr;
 133     short *quant_ptr;
 134     short *quant_shift_ptr;
 135     short *qcoeff_ptr;
 136     short *dqcoeff_ptr;
 137     short *dequant_ptr;
 138
 139     coeff_ptr       = b->coeff;
 140     quant_ptr       = b->quant;
 141     quant_shift_ptr = b->quant_shift;
 142     qcoeff_ptr      = d->qcoeff;
 143     dqcoeff_ptr     = d->dqcoeff;
 144     dequant_ptr     = d->dequant;
 145     eob = - 1;
 146     vpx_memset(qcoeff_ptr, 0, 32);
 147     vpx_memset(dqcoeff_ptr, 0, 32);
 148     for (i = 0; i < 16; i++)
 149     {
 150         int dq;
 151         int round;
 152
 153         /*TODO: These arrays should be stored in zig-zag order.*/
 154         rc = vp8_default_zig_zag1d[i];
 155         z = coeff_ptr[rc];
 156         dq = dequant_ptr[rc];
 157         round = dq >> 1;
 158         /* Sign of z. */
 159         sz = -(z < 0);
 160         x = (z + sz) ^ sz;
 161         x += round;
 162         if (x >= dq)
 163         {
 164             /* Quantize x. */
 165             y  = (((x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc];
 166             /* Put the sign back. */
 167             x = (y + sz) ^ sz;
 168             /* Save the coefficient and its dequantized value. */
 169             qcoeff_ptr[rc] = x;
 170             dqcoeff_ptr[rc] = x * dq;
 171             /* Remember the last non-zero coefficient. */
 172             if (y)
 173                 eob = i;
 174         }
 175     }
 176
 177     d->eob = eob + 1;
 178 }
 179
 180 #else
 181 void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d)
 182 {
 183     int i, rc, eob;
 184     int zbin;
 185     int x, y, z, sz;
 186     short *coeff_ptr   = b->coeff;
 187     short *round_ptr   = b->round;
 188     short *quant_ptr   = b->quant;
 189     short *qcoeff_ptr  = d->qcoeff;
 190     short *dqcoeff_ptr = d->dqcoeff;
 191     short *dequant_ptr = d->dequant;
 192
 193     eob = -1;
 194     for (i = 0; i < 16; i++)
 195     {
 196         rc   = vp8_default_zig_zag1d[i];
 197         z    = coeff_ptr[rc];
 198
 199         sz = (z >> 31);                                 // sign of z
 200         x  = (z ^ sz) - sz;                             // x = abs(z)
 201
 202         y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)
 203         x  = (y ^ sz) - sz;                         // get the sign back
 204         qcoeff_ptr[rc] = x;                          // write to destination
 205         dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
 206
 207         if (y)
 208         {
 209             eob = i;                                // last nonzero coeffs
 210         }
 211     }
 212     d->eob = eob + 1;
 213 }
 214
 215 void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d)
 216 {
 217     int i, rc, eob;
 218     int zbin;
 219     int x, y, z, sz;
 220     short *zbin_boost_ptr = b->zrun_zbin_boost;
 221     short *coeff_ptr      = b->coeff;
 222     short *zbin_ptr       = b->zbin;
 223     short *round_ptr      = b->round;
 224     short *quant_ptr      = b->quant;
 225     short *qcoeff_ptr     = d->qcoeff;
 226     short *dqcoeff_ptr    = d->dqcoeff;
 227     short *dequant_ptr    = d->dequant;
 228     short zbin_oq_value   = b->zbin_extra;
 229
 230     vpx_memset(qcoeff_ptr, 0, 32);
 231     vpx_memset(dqcoeff_ptr, 0, 32);
 232
 233     eob = -1;
 234
 235     for (i = 0; i < 16; i++)
 236     {
 237         rc   = vp8_default_zig_zag1d[i];
 238         z    = coeff_ptr[rc];
 239
 240         //if ( i == 0 )
 241         //    zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value/2;
 242         //else
 243         zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value;
 244
 245         zbin_boost_ptr ++;
 246         sz = (z >> 31);                                 // sign of z
 247         x  = (z ^ sz) - sz;                             // x = abs(z)
 248
 249         if (x >= zbin)
 250         {
 251             y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)
 252             x  = (y ^ sz) - sz;                         // get the sign back
 253             qcoeff_ptr[rc]  = x;                         // write to destination
 254             dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
 255
 256             if (y)
 257             {
 258                 eob = i;                                // last nonzero coeffs
 259                 zbin_boost_ptr = &b->zrun_zbin_boost[0];    // reset zero runlength
 260             }
 261         }
 262     }
 263
 264     d->eob = eob + 1;
 265 }
 266
 267 #endif
 268
 269 void vp8_quantize_mby(MACROBLOCK *x)
 270 {
 271     int i;
 272     int has_2nd_order = (x->e_mbd.mode_info_context->mbmi.mode != B_PRED
 273         && x->e_mbd.mode_info_context->mbmi.mode != SPLITMV);
 274
 275     for (i = 0; i < 16; i++)
 276         x->quantize_b(&x->block[i], &x->e_mbd.block[i]);
 277
 278     if(has_2nd_order)
 279         x->quantize_b(&x->block[24], &x->e_mbd.block[24]);
 280 }
 281
 282 void vp8_quantize_mb(MACROBLOCK *x)
 283 {
 284     int i;
 285     int has_2nd_order=(x->e_mbd.mode_info_context->mbmi.mode != B_PRED
 286         && x->e_mbd.mode_info_context->mbmi.mode != SPLITMV);
 287
 288     for (i = 0; i < 24+has_2nd_order; i++)
 289         x->quantize_b(&x->block[i], &x->e_mbd.block[i]);
 290 }
 291
 292
 293 void vp8_quantize_mbuv(MACROBLOCK *x)
 294 {
 295     int i;
 296
 297     for (i = 16; i < 24; i++)
 298         x->quantize_b(&x->block[i], &x->e_mbd.block[i]);
 299 }