libvpx: Pull from upstream

source/libvpx/test/fdct4x4_test.cc

 /*
  *  Copyright (c) 2012 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 12 matching lines @@
 #include "vpx/vpx_integer.h"
 
 extern "C" {
 void vp9_idct4x4_16_add_c(const int16_t *input, uint8_t *output, int pitch);
 }
 
 using libvpx_test::ACMRandom;
 
 namespace {
 const int kNumCoeffs = 16;
-typedef void (*fdct_t)(const int16_t *in, int16_t *out, int stride);
-typedef void (*idct_t)(const int16_t *in, uint8_t *out, int stride);
-typedef void (*fht_t) (const int16_t *in, int16_t *out, int stride,
-                       int tx_type);
-typedef void (*iht_t) (const int16_t *in, uint8_t *out, int stride,
-                       int tx_type);
+typedef void (*FdctFunc)(const int16_t *in, int16_t *out, int stride);
+typedef void (*IdctFunc)(const int16_t *in, uint8_t *out, int stride);
+typedef void (*FhtFunc)(const int16_t *in, int16_t *out, int stride,
+                        int tx_type);
+typedef void (*IhtFunc)(const int16_t *in, uint8_t *out, int stride,
+                        int tx_type);
 
-typedef std::tr1::tuple<fdct_t, idct_t, int> dct_4x4_param_t;
-typedef std::tr1::tuple<fht_t, iht_t, int> ht_4x4_param_t;
+typedef std::tr1::tuple<FdctFunc, IdctFunc, int> Dct4x4Param;
+typedef std::tr1::tuple<FhtFunc, IhtFunc, int> Ht4x4Param;
 
 void fdct4x4_ref(const int16_t *in, int16_t *out, int stride, int tx_type) {
   vp9_fdct4x4_c(in, out, stride);
 }
 
 void fht4x4_ref(const int16_t *in, int16_t *out, int stride, int tx_type) {
   vp9_fht4x4_c(in, out, stride, tx_type);
 }
 
 void fwht4x4_ref(const int16_t *in, int16_t *out, int stride, int tx_type) {
@@ skipping 130 matching lines @@
         const uint32_t error = diff * diff;
         EXPECT_GE(static_cast<uint32_t>(limit), error)
             << "Error: 4x4 IDCT has error " << error
             << " at index " << j;
       }
     }
   }
 
   int pitch_;
   int tx_type_;
-  fht_t fwd_txfm_ref;
+  FhtFunc fwd_txfm_ref;
 };
 
 class Trans4x4DCT
     : public Trans4x4TestBase,
-      public ::testing::TestWithParam<dct_4x4_param_t> {
+      public ::testing::TestWithParam<Dct4x4Param> {
  public:
   virtual ~Trans4x4DCT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
     tx_type_  = GET_PARAM(2);
     pitch_    = 4;
     fwd_txfm_ref = fdct4x4_ref;
   }
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   void RunFwdTxfm(const int16_t *in, int16_t *out, int stride) {
     fwd_txfm_(in, out, stride);
   }
   void RunInvTxfm(const int16_t *out, uint8_t *dst, int stride) {
     inv_txfm_(out, dst, stride);
   }
 
-  fdct_t fwd_txfm_;
-  idct_t inv_txfm_;
+  FdctFunc fwd_txfm_;
+  IdctFunc inv_txfm_;
 };
 
 TEST_P(Trans4x4DCT, AccuracyCheck) {
   RunAccuracyCheck(1);
 }
 
 TEST_P(Trans4x4DCT, CoeffCheck) {
   RunCoeffCheck();
 }
 
 TEST_P(Trans4x4DCT, MemCheck) {
   RunMemCheck();
 }
 
 TEST_P(Trans4x4DCT, InvAccuracyCheck) {
   RunInvAccuracyCheck(1);
 }
 
 class Trans4x4HT
     : public Trans4x4TestBase,
-      public ::testing::TestWithParam<ht_4x4_param_t> {
+      public ::testing::TestWithParam<Ht4x4Param> {
  public:
   virtual ~Trans4x4HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
     tx_type_  = GET_PARAM(2);
     pitch_    = 4;
     fwd_txfm_ref = fht4x4_ref;
   }
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   void RunFwdTxfm(const int16_t *in, int16_t *out, int stride) {
     fwd_txfm_(in, out, stride, tx_type_);
   }
 
   void RunInvTxfm(const int16_t *out, uint8_t *dst, int stride) {
     inv_txfm_(out, dst, stride, tx_type_);
   }
 
-  fht_t fwd_txfm_;
-  iht_t inv_txfm_;
+  FhtFunc fwd_txfm_;
+  IhtFunc inv_txfm_;
 };
 
 TEST_P(Trans4x4HT, AccuracyCheck) {
   RunAccuracyCheck(1);
 }
 
 TEST_P(Trans4x4HT, CoeffCheck) {
   RunCoeffCheck();
 }
 
 TEST_P(Trans4x4HT, MemCheck) {
   RunMemCheck();
 }
 
 TEST_P(Trans4x4HT, InvAccuracyCheck) {
   RunInvAccuracyCheck(1);
 }
 
 class Trans4x4WHT
     : public Trans4x4TestBase,
-      public ::testing::TestWithParam<dct_4x4_param_t> {
+      public ::testing::TestWithParam<Dct4x4Param> {
  public:
   virtual ~Trans4x4WHT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
     tx_type_  = GET_PARAM(2);
     pitch_    = 4;
     fwd_txfm_ref = fwht4x4_ref;
   }
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   void RunFwdTxfm(const int16_t *in, int16_t *out, int stride) {
     fwd_txfm_(in, out, stride);
   }
   void RunInvTxfm(const int16_t *out, uint8_t *dst, int stride) {
     inv_txfm_(out, dst, stride);
   }
 
-  fdct_t fwd_txfm_;
-  idct_t inv_txfm_;
+  FdctFunc fwd_txfm_;
+  IdctFunc inv_txfm_;
 };
 
 TEST_P(Trans4x4WHT, AccuracyCheck) {
   RunAccuracyCheck(0);
 }
 
 TEST_P(Trans4x4WHT, CoeffCheck) {
   RunCoeffCheck();
 }
 
@@ skipping 68 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     AVX2, Trans4x4HT,
     ::testing::Values(
         make_tuple(&vp9_fht4x4_avx2, &vp9_iht4x4_16_add_c, 0),
         make_tuple(&vp9_fht4x4_avx2, &vp9_iht4x4_16_add_c, 1),
         make_tuple(&vp9_fht4x4_avx2, &vp9_iht4x4_16_add_c, 2),
         make_tuple(&vp9_fht4x4_avx2, &vp9_iht4x4_16_add_c, 3)));
 #endif
 
 }  // namespace