Description:

source/libvpx/vp8/encoder/quantize.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 32 matching lines @@
         rc   = vp8_default_zig_zag1d[i];
         z    = coeff_ptr[rc];
         zbin = zbin_ptr[rc] ;
 
         sz = (z >> 31);                              /* sign of z */
         x  = (z ^ sz) - sz;                          /* x = abs(z) */
 
         if (x >= zbin)
         {
             x += round_ptr[rc];
-            y  = (((x * quant_ptr[rc]) >> 16) + x)
-                 >> quant_shift_ptr[rc];             /* quantize (x) */
+            y  = ((((x * quant_ptr[rc]) >> 16) + x)
+                 * quant_shift_ptr[rc]) >> 16;       /* quantize (x) */
             x  = (y ^ sz) - sz;                      /* get the sign back */
             qcoeff_ptr[rc] = x;                      /* write to destination */
             dqcoeff_ptr[rc] = x * dequant_ptr[rc];   /* dequantized value */
 
             if (y)
             {
                 eob = i;                             /* last nonzero coeffs */
             }
         }
     }
@@ skipping 41 matching lines @@
 void vp8_regular_quantize_b_c(BLOCK *b, BLOCKD *d)
 {
     int i, rc, eob;
     int zbin;
     int x, y, z, sz;
     short *zbin_boost_ptr  = b->zrun_zbin_boost;
     short *coeff_ptr       = b->coeff;
     short *zbin_ptr        = b->zbin;
     short *round_ptr       = b->round;
     short *quant_ptr       = b->quant;
-    unsigned char *quant_shift_ptr = b->quant_shift;
+    short *quant_shift_ptr = b->quant_shift;
     short *qcoeff_ptr      = d->qcoeff;
     short *dqcoeff_ptr     = d->dqcoeff;
     short *dequant_ptr     = d->dequant;
     short zbin_oq_value    = b->zbin_extra;
 
     vpx_memset(qcoeff_ptr, 0, 32);
     vpx_memset(dqcoeff_ptr, 0, 32);
 
     eob = -1;
 
     for (i = 0; i < 16; i++)
     {
         rc   = vp8_default_zig_zag1d[i];
         z    = coeff_ptr[rc];
 
         zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value;
 
         zbin_boost_ptr ++;
         sz = (z >> 31);                              /* sign of z */
         x  = (z ^ sz) - sz;                          /* x = abs(z) */
 
         if (x >= zbin)
         {
             x += round_ptr[rc];
-            y  = (((x * quant_ptr[rc]) >> 16) + x)
-                 >> quant_shift_ptr[rc];             /* quantize (x) */
+            y  = ((((x * quant_ptr[rc]) >> 16) + x)
+                 * quant_shift_ptr[rc]) >> 16;       /* quantize (x) */
             x  = (y ^ sz) - sz;                      /* get the sign back */
             qcoeff_ptr[rc]  = x;                     /* write to destination */
             dqcoeff_ptr[rc] = x * dequant_ptr[rc];   /* dequantized value */
 
             if (y)
             {
                 eob = i;                             /* last nonzero coeffs */
                 zbin_boost_ptr = b->zrun_zbin_boost; /* reset zero runlength */
             }
         }
     }
 
     *d->eob = (char)(eob + 1);
 }
 
 /* Perform regular quantization, with unbiased rounding and no zero bin. */
 void vp8_strict_quantize_b_c(BLOCK *b, BLOCKD *d)
 {
     int i;
     int rc;
     int eob;
     int x;
     int y;
     int z;
     int sz;
     short *coeff_ptr;
     short *quant_ptr;
-    unsigned char *quant_shift_ptr;
+    short *quant_shift_ptr;
     short *qcoeff_ptr;
     short *dqcoeff_ptr;
     short *dequant_ptr;
 
     coeff_ptr       = b->coeff;
     quant_ptr       = b->quant;
     quant_shift_ptr = b->quant_shift;
     qcoeff_ptr      = d->qcoeff;
     dqcoeff_ptr     = d->dqcoeff;
     dequant_ptr     = d->dequant;
@@ skipping 10 matching lines @@
         z = coeff_ptr[rc];
         dq = dequant_ptr[rc];
         round = dq >> 1;
         /* Sign of z. */
         sz = -(z < 0);
         x = (z + sz) ^ sz;
         x += round;
         if (x >= dq)
         {
             /* Quantize x. */
-            y  = (((x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc];
+            y  = ((((x * quant_ptr[rc]) >> 16) + x) * quant_shift_ptr[rc]) >> 16;
             /* Put the sign back. */
             x = (y + sz) ^ sz;
             /* Save the coefficient and its dequantized value. */
             qcoeff_ptr[rc] = x;
             dqcoeff_ptr[rc] = x * dq;
             /* Remember the last non-zero coefficient. */
             if (y)
                 eob = i;
         }
     }
@@ skipping 187 matching lines @@
     80, 80, 80, 80, 80, 80, 80, 80,
     80, 80, 80, 80, 80, 80, 80, 80,
     80, 80, 80, 80, 80, 80, 80, 80,
     80
 };
 
 
 #define EXACT_QUANT
 #ifdef EXACT_QUANT
 static void invert_quant(int improved_quant, short *quant,
-                               unsigned char *shift, short d)
+                         short *shift, short d)
 {
     if(improved_quant)
     {
         unsigned t;
         int l;
         t = d;
         for(l = 0; t > 1; l++)
             t>>=1;
         t = 1 + (1<<(16+l))/d;
         *quant = (short)(t - (1<<16));
         *shift = l;
+        /* use multiplication and constant shift by 16 */
+        *shift = 1 << (16 - *shift);
     }
     else
     {
         *quant = (1 << 16) / d;
         *shift = 0;
+        /* use multiplication and constant shift by 16 */
+        *shift = 1 << (16 - *shift);
     }
 }
 
 
 void vp8cx_init_quantizer(VP8_COMP *cpi)
 {
     int i;
     int quant_val;
     int Q;
 
@@ skipping 366 matching lines @@
     mbd->segment_feature_data[MB_LVL_ALT_Q][0] = cpi->segment_feature_data[MB_LVL_ALT_Q][0];
     mbd->segment_feature_data[MB_LVL_ALT_Q][1] = cpi->segment_feature_data[MB_LVL_ALT_Q][1];
     mbd->segment_feature_data[MB_LVL_ALT_Q][2] = cpi->segment_feature_data[MB_LVL_ALT_Q][2];
     mbd->segment_feature_data[MB_LVL_ALT_Q][3] = cpi->segment_feature_data[MB_LVL_ALT_Q][3];
 
     /* quantizer has to be reinitialized for any delta_q changes */
     if(update)
         vp8cx_init_quantizer(cpi);
 
 }