libvpx: Pull from upstream

source/libvpx/test/vp9_quantize_test.cc

 /*
  *  Copyright (c) 2014 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 16 matching lines @@
 
 namespace {
 #if CONFIG_VP9_HIGHBITDEPTH
 const int number_of_iterations = 100;
 
 typedef void (*QuantizeFunc)(const tran_low_t *coeff, intptr_t count,
                              int skip_block, const int16_t *zbin,
                              const int16_t *round, const int16_t *quant,
                              const int16_t *quant_shift,
                              tran_low_t *qcoeff, tran_low_t *dqcoeff,
-                             const int16_t *dequant, int zbin_oq_value,
+                             const int16_t *dequant,
                              uint16_t *eob, const int16_t *scan,
                              const int16_t *iscan);
 typedef std::tr1::tuple<QuantizeFunc, QuantizeFunc, vpx_bit_depth_t>
     QuantizeParam;
 
 class VP9QuantizeTest : public ::testing::TestWithParam<QuantizeParam> {
  public:
   virtual ~VP9QuantizeTest() {}
   virtual void SetUp() {
     quantize_op_   = GET_PARAM(0);
@@ skipping 25 matching lines @@
 
  protected:
   vpx_bit_depth_t bit_depth_;
   int mask_;
   QuantizeFunc quantize_op_;
   QuantizeFunc ref_quantize_op_;
 };
 
 TEST_P(VP9QuantizeTest, OperationCheck) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  int zbin_oq_value = 0;
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, coeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, int16_t, zbin_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, round_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_shift_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, qcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, dqcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_qcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_dqcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, int16_t, dequant_ptr, 2);
@@ skipping 15 matching lines @@
     }
     for (int j = 0; j < 2; j++) {
       zbin_ptr[j] = rnd.Rand16()&mask_;
       round_ptr[j] = rnd.Rand16();
       quant_ptr[j] = rnd.Rand16();
       quant_shift_ptr[j] = rnd.Rand16();
       dequant_ptr[j] = rnd.Rand16();
     }
     ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
                      quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
-                     ref_dqcoeff_ptr, dequant_ptr, zbin_oq_value,
+                     ref_dqcoeff_ptr, dequant_ptr,
                      ref_eob_ptr, scan_order->scan, scan_order->iscan);
     ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block,
                                           zbin_ptr, round_ptr, quant_ptr,
                                           quant_shift_ptr, qcoeff_ptr,
-                                          dqcoeff_ptr, dequant_ptr,
-                                          zbin_oq_value, eob_ptr,
+                                          dqcoeff_ptr, dequant_ptr, eob_ptr,
                                           scan_order->scan, scan_order->iscan));
     for (int j = 0; j < sz; ++j) {
       err_count += (ref_qcoeff_ptr[j]  != qcoeff_ptr[j]) |
           (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
     }
     err_count += (*ref_eob_ptr != *eob_ptr);
     if (err_count && !err_count_total) {
       first_failure = i;
     }
     err_count_total += err_count;
   }
   EXPECT_EQ(0, err_count_total)
       << "Error: Quantization Test, C output doesn't match SSE2 output. "
       << "First failed at test case " << first_failure;
 }
 
 TEST_P(VP9Quantize32Test, OperationCheck) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  int zbin_oq_value = 0;
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, coeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, int16_t, zbin_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, round_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_shift_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, qcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, dqcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_qcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_dqcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, int16_t, dequant_ptr, 2);
@@ skipping 15 matching lines @@
     }
     for (int j = 0; j < 2; j++) {
       zbin_ptr[j] = rnd.Rand16()&mask_;
       round_ptr[j] = rnd.Rand16();
       quant_ptr[j] = rnd.Rand16();
       quant_shift_ptr[j] = rnd.Rand16();
       dequant_ptr[j] = rnd.Rand16();
     }
     ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
                      quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
-                     ref_dqcoeff_ptr, dequant_ptr, zbin_oq_value,
+                     ref_dqcoeff_ptr, dequant_ptr,
                      ref_eob_ptr, scan_order->scan, scan_order->iscan);
     ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block,
                                           zbin_ptr, round_ptr, quant_ptr,
                                           quant_shift_ptr, qcoeff_ptr,
-                                          dqcoeff_ptr, dequant_ptr,
-                                          zbin_oq_value, eob_ptr,
+                                          dqcoeff_ptr, dequant_ptr, eob_ptr,
                                           scan_order->scan, scan_order->iscan));
     for (int j = 0; j < sz; ++j) {
       err_count += (ref_qcoeff_ptr[j]  != qcoeff_ptr[j]) |
           (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
     }
     err_count += (*ref_eob_ptr != *eob_ptr);
     if (err_count && !err_count_total) {
       first_failure = i;
     }
     err_count_total += err_count;
   }
   EXPECT_EQ(0, err_count_total)
       << "Error: Quantization Test, C output doesn't match SSE2 output. "
       << "First failed at test case " << first_failure;
 }
 
 TEST_P(VP9QuantizeTest, EOBCheck) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  int zbin_oq_value = 0;
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, coeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, int16_t, zbin_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, round_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_shift_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, qcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, dqcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_qcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_dqcoeff_ptr, 256);
   DECLARE_ALIGNED_ARRAY(16, int16_t, dequant_ptr, 2);
@@ skipping 19 matching lines @@
     for (int j = 0; j < 2; j++) {
       zbin_ptr[j] = rnd.Rand16()&mask_;
       round_ptr[j] = rnd.Rand16();
       quant_ptr[j] = rnd.Rand16();
       quant_shift_ptr[j] = rnd.Rand16();
       dequant_ptr[j] = rnd.Rand16();
     }
 
     ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
                      quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
-                     ref_dqcoeff_ptr, dequant_ptr, zbin_oq_value,
+                     ref_dqcoeff_ptr, dequant_ptr,
                      ref_eob_ptr, scan_order->scan, scan_order->iscan);
     ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block,
                                           zbin_ptr, round_ptr, quant_ptr,
                                           quant_shift_ptr, qcoeff_ptr,
-                                          dqcoeff_ptr, dequant_ptr,
-                                          zbin_oq_value, eob_ptr,
+                                          dqcoeff_ptr, dequant_ptr, eob_ptr,
                                           scan_order->scan, scan_order->iscan));
 
     for (int j = 0; j < sz; ++j) {
       err_count += (ref_qcoeff_ptr[j]  != qcoeff_ptr[j]) |
           (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
     }
     err_count += (*ref_eob_ptr != *eob_ptr);
     if (err_count && !err_count_total) {
       first_failure = i;
     }
     err_count_total += err_count;
   }
   EXPECT_EQ(0, err_count_total)
       << "Error: Quantization Test, C output doesn't match SSE2 output. "
       << "First failed at test case " << first_failure;
 }
 
 TEST_P(VP9Quantize32Test, EOBCheck) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  int zbin_oq_value = 0;
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, coeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, int16_t, zbin_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, round_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, int16_t, quant_shift_ptr, 2);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, qcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, dqcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_qcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, tran_low_t, ref_dqcoeff_ptr, 1024);
   DECLARE_ALIGNED_ARRAY(16, int16_t, dequant_ptr, 2);
@@ skipping 19 matching lines @@
     for (int j = 0; j < 2; j++) {
       zbin_ptr[j] = rnd.Rand16()&mask_;
       round_ptr[j] = rnd.Rand16();
       quant_ptr[j] = rnd.Rand16();
       quant_shift_ptr[j] = rnd.Rand16();
       dequant_ptr[j] = rnd.Rand16();
     }
 
     ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
                      quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
-                     ref_dqcoeff_ptr, dequant_ptr, zbin_oq_value,
+                     ref_dqcoeff_ptr, dequant_ptr,
                      ref_eob_ptr, scan_order->scan, scan_order->iscan);
     ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block,
                                           zbin_ptr, round_ptr, quant_ptr,
                                           quant_shift_ptr, qcoeff_ptr,
-                                          dqcoeff_ptr, dequant_ptr,
-                                          zbin_oq_value, eob_ptr,
+                                          dqcoeff_ptr, dequant_ptr, eob_ptr,
                                           scan_order->scan, scan_order->iscan));
 
     for (int j = 0; j < sz; ++j) {
       err_count += (ref_qcoeff_ptr[j]  != qcoeff_ptr[j]) |
           (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
     }
     err_count += (*ref_eob_ptr != *eob_ptr);
     if (err_count && !err_count_total) {
       first_failure = i;
     }
@@ skipping 20 matching lines @@
     ::testing::Values(
         make_tuple(&vp9_highbd_quantize_b_32x32_sse2,
                    &vp9_highbd_quantize_b_32x32_c, VPX_BITS_8),
         make_tuple(&vp9_highbd_quantize_b_32x32_sse2,
                    &vp9_highbd_quantize_b_32x32_c, VPX_BITS_10),
         make_tuple(&vp9_highbd_quantize_b_32x32_sse2,
                    &vp9_highbd_quantize_b_32x32_c, VPX_BITS_12)));
 #endif  // HAVE_SSE2
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 }  // namespace