test/variance_test.cc

   1 /*
   2  *  Copyright (c) 2012 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 #include <stdlib.h>
  11 #include <new>
  12
  13 #include "third_party/googletest/src/include/gtest/gtest.h"
  14
  15 #include "test/clear_system_state.h"
  16 #include "test/register_state_check.h"
  17
  18 #include "vpx/vpx_integer.h"
  19 #include "./vpx_config.h"
  20 #include "vpx_mem/vpx_mem.h"
  21 #if CONFIG_VP8_ENCODER
  22 # include "./vp8_rtcd.h"
  23 # include "vp8/common/variance.h"
  24 #endif
  25 #if CONFIG_VP9_ENCODER
  26 # include "./vp9_rtcd.h"
  27 # include "vp9/encoder/vp9_variance.h"
  28 #endif
  29 #include "test/acm_random.h"
  30
  31 namespace {
  32
  33 using ::std::tr1::get;
  34 using ::std::tr1::make_tuple;
  35 using ::std::tr1::tuple;
  36 using libvpx_test::ACMRandom;
  37
  38 static unsigned int mb_ss_ref(const int16_t *src) {
  39   unsigned int res = 0;
  40   for (int i = 0; i < 256; ++i) {
  41     res += src[i] * src[i];
  42   }
  43   return res;
  44 }
  45
  46 static unsigned int variance_ref(const uint8_t *ref, const uint8_t *src,
  47                                  int l2w, int l2h, unsigned int *sse_ptr) {
  48   int se = 0;
  49   unsigned int sse = 0;
  50   const int w = 1 << l2w, h = 1 << l2h;
  51   for (int y = 0; y < h; y++) {
  52     for (int x = 0; x < w; x++) {
  53       int diff = ref[w * y + x] - src[w * y + x];
  54       se += diff;
  55       sse += diff * diff;
  56     }
  57   }
  58   *sse_ptr = sse;
  59   return sse - (((int64_t) se * se) >> (l2w + l2h));
  60 }
  61
  62 static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
  63                                         int l2w, int l2h, int xoff, int yoff,
  64                                         unsigned int *sse_ptr) {
  65   int se = 0;
  66   unsigned int sse = 0;
  67   const int w = 1 << l2w, h = 1 << l2h;
  68   for (int y = 0; y < h; y++) {
  69     for (int x = 0; x < w; x++) {
  70       // bilinear interpolation at a 16th pel step
  71       const int a1 = ref[(w + 1) * (y + 0) + x + 0];
  72       const int a2 = ref[(w + 1) * (y + 0) + x + 1];
  73       const int b1 = ref[(w + 1) * (y + 1) + x + 0];
  74       const int b2 = ref[(w + 1) * (y + 1) + x + 1];
  75       const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
  76       const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
  77       const int r = a + (((b - a) * yoff + 8) >> 4);
  78       int diff = r - src[w * y + x];
  79       se += diff;
  80       sse += diff * diff;
  81     }
  82   }
  83   *sse_ptr = sse;
  84   return sse - (((int64_t) se * se) >> (l2w + l2h));
  85 }
  86
  87 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src);
  88
  89 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> {
  90  public:
  91   SumOfSquaresTest() : func_(GetParam()) {}
  92
  93   virtual ~SumOfSquaresTest() {
  94     libvpx_test::ClearSystemState();
  95   }
  96
  97  protected:
  98   void ConstTest();
  99   void RefTest();
 100
 101   SumOfSquaresFunction func_;
 102   ACMRandom rnd_;
 103 };
 104
 105 void SumOfSquaresTest::ConstTest() {
 106   int16_t mem[256];
 107   unsigned int res;
 108   for (int v = 0; v < 256; ++v) {
 109     for (int i = 0; i < 256; ++i) {
 110       mem[i] = v;
 111     }
 112     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 113     EXPECT_EQ(256u * (v * v), res);
 114   }
 115 }
 116
 117 void SumOfSquaresTest::RefTest() {
 118   int16_t mem[256];
 119   for (int i = 0; i < 100; ++i) {
 120     for (int j = 0; j < 256; ++j) {
 121       mem[j] = rnd_.Rand8() - rnd_.Rand8();
 122     }
 123
 124     const unsigned int expected = mb_ss_ref(mem);
 125     unsigned int res;
 126     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 127     EXPECT_EQ(expected, res);
 128   }
 129 }
 130
 131 template<typename VarianceFunctionType>
 132 class VarianceTest
 133     : public ::testing::TestWithParam<tuple<int, int, VarianceFunctionType> > {
 134  public:
 135   virtual void SetUp() {
 136     const tuple<int, int, VarianceFunctionType>& params = this->GetParam();
 137     log2width_  = get<0>(params);
 138     width_ = 1 << log2width_;
 139     log2height_ = get<1>(params);
 140     height_ = 1 << log2height_;
 141     variance_ = get<2>(params);
 142
 143     rnd_.Reset(ACMRandom::DeterministicSeed());
 144     block_size_ = width_ * height_;
 145     src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
 146     ref_ = new uint8_t[block_size_];
 147     ASSERT_TRUE(src_ != NULL);
 148     ASSERT_TRUE(ref_ != NULL);
 149   }
 150
 151   virtual void TearDown() {
 152     vpx_free(src_);
 153     delete[] ref_;
 154     libvpx_test::ClearSystemState();
 155   }
 156
 157  protected:
 158   void ZeroTest();
 159   void RefTest();
 160   void OneQuarterTest();
 161
 162   ACMRandom rnd_;
 163   uint8_t* src_;
 164   uint8_t* ref_;
 165   int width_, log2width_;
 166   int height_, log2height_;
 167   int block_size_;
 168   VarianceFunctionType variance_;
 169 };
 170
 171 template<typename VarianceFunctionType>
 172 void VarianceTest<VarianceFunctionType>::ZeroTest() {
 173   for (int i = 0; i <= 255; ++i) {
 174     memset(src_, i, block_size_);
 175     for (int j = 0; j <= 255; ++j) {
 176       memset(ref_, j, block_size_);
 177       unsigned int sse;
 178       unsigned int var;
 179       ASM_REGISTER_STATE_CHECK(
 180           var = variance_(src_, width_, ref_, width_, &sse));
 181       EXPECT_EQ(0u, var) << "src values: " << i << "ref values: " << j;
 182     }
 183   }
 184 }
 185
 186 template<typename VarianceFunctionType>
 187 void VarianceTest<VarianceFunctionType>::RefTest() {
 188   for (int i = 0; i < 10; ++i) {
 189     for (int j = 0; j < block_size_; j++) {
 190       src_[j] = rnd_.Rand8();
 191       ref_[j] = rnd_.Rand8();
 192     }
 193     unsigned int sse1, sse2;
 194     unsigned int var1;
 195     ASM_REGISTER_STATE_CHECK(
 196         var1 = variance_(src_, width_, ref_, width_, &sse1));
 197     const unsigned int var2 = variance_ref(src_, ref_, log2width_,
 198                                            log2height_, &sse2);
 199     EXPECT_EQ(sse1, sse2);
 200     EXPECT_EQ(var1, var2);
 201   }
 202 }
 203
 204 template<typename VarianceFunctionType>
 205 void VarianceTest<VarianceFunctionType>::OneQuarterTest() {
 206   memset(src_, 255, block_size_);
 207   const int half = block_size_ / 2;
 208   memset(ref_, 255, half);
 209   memset(ref_ + half, 0, half);
 210   unsigned int sse;
 211   unsigned int var;
 212   ASM_REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse));
 213   const unsigned int expected = block_size_ * 255 * 255 / 4;
 214   EXPECT_EQ(expected, var);
 215 }
 216
 217 #if CONFIG_VP8_ENCODER
 218 template<typename MseFunctionType>
 219 class MseTest
 220     : public ::testing::TestWithParam<tuple<int, int, MseFunctionType> > {
 221  public:
 222   virtual void SetUp() {
 223     const tuple<int, int, MseFunctionType>& params = this->GetParam();
 224     log2width_  = get<0>(params);
 225     width_ = 1 << log2width_;
 226     log2height_ = get<1>(params);
 227     height_ = 1 << log2height_;
 228     mse_ = get<2>(params);
 229
 230     rnd(ACMRandom::DeterministicSeed());
 231     block_size_ = width_ * height_;
 232     src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
 233     ref_ = new uint8_t[block_size_];
 234     ASSERT_TRUE(src_ != NULL);
 235     ASSERT_TRUE(ref_ != NULL);
 236   }
 237
 238   virtual void TearDown() {
 239     vpx_free(src_);
 240     delete[] ref_;
 241     libvpx_test::ClearSystemState();
 242   }
 243
 244  protected:
 245   void RefTest_mse();
 246   void RefTest_sse();
 247   void MaxTest_mse();
 248   void MaxTest_sse();
 249
 250   ACMRandom rnd;
 251   uint8_t* src_;
 252   uint8_t* ref_;
 253   int width_, log2width_;
 254   int height_, log2height_;
 255   int block_size_;
 256   MseFunctionType mse_;
 257 };
 258
 259 template<typename MseFunctionType>
 260 void MseTest<MseFunctionType>::RefTest_mse() {
 261   for (int i = 0; i < 10; ++i) {
 262     for (int j = 0; j < block_size_; j++) {
 263       src_[j] = rnd.Rand8();
 264       ref_[j] = rnd.Rand8();
 265     }
 266     unsigned int sse1, sse2;
 267     ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse1));
 268     variance_ref(src_, ref_, log2width_, log2height_, &sse2);
 269     EXPECT_EQ(sse1, sse2);
 270   }
 271 }
 272
 273 template<typename MseFunctionType>
 274 void MseTest<MseFunctionType>::RefTest_sse() {
 275   for (int i = 0; i < 10; ++i) {
 276     for (int j = 0; j < block_size_; j++) {
 277       src_[j] = rnd.Rand8();
 278       ref_[j] = rnd.Rand8();
 279     }
 280     unsigned int sse2;
 281     unsigned int var1;
 282     ASM_REGISTER_STATE_CHECK(
 283         var1 = mse_(src_, width_, ref_, width_));
 284     variance_ref(src_, ref_, log2width_, log2height_, &sse2);
 285     EXPECT_EQ(var1, sse2);
 286   }
 287 }
 288
 289 template<typename MseFunctionType>
 290 void MseTest<MseFunctionType>::MaxTest_mse() {
 291   memset(src_, 255, block_size_);
 292   memset(ref_, 0, block_size_);
 293   unsigned int sse;
 294   ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse));
 295   const unsigned int expected = block_size_ * 255 * 255;
 296   EXPECT_EQ(expected, sse);
 297 }
 298
 299 template<typename MseFunctionType>
 300 void MseTest<MseFunctionType>::MaxTest_sse() {
 301   memset(src_, 255, block_size_);
 302   memset(ref_, 0, block_size_);
 303   unsigned int var;
 304   ASM_REGISTER_STATE_CHECK(var = mse_(src_, width_, ref_, width_));
 305   const unsigned int expected = block_size_ * 255 * 255;
 306   EXPECT_EQ(expected, var);
 307 }
 308 #endif
 309
 310 #if CONFIG_VP9_ENCODER
 311
 312 unsigned int subpel_avg_variance_ref(const uint8_t *ref,
 313                                      const uint8_t *src,
 314                                      const uint8_t *second_pred,
 315                                      int l2w, int l2h,
 316                                      int xoff, int yoff,
 317                                      unsigned int *sse_ptr) {
 318   int se = 0;
 319   unsigned int sse = 0;
 320   const int w = 1 << l2w, h = 1 << l2h;
 321   for (int y = 0; y < h; y++) {
 322     for (int x = 0; x < w; x++) {
 323       // bilinear interpolation at a 16th pel step
 324       const int a1 = ref[(w + 1) * (y + 0) + x + 0];
 325       const int a2 = ref[(w + 1) * (y + 0) + x + 1];
 326       const int b1 = ref[(w + 1) * (y + 1) + x + 0];
 327       const int b2 = ref[(w + 1) * (y + 1) + x + 1];
 328       const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 329       const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 330       const int r = a + (((b - a) * yoff + 8) >> 4);
 331       int diff = ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x];
 332       se += diff;
 333       sse += diff * diff;
 334     }
 335   }
 336   *sse_ptr = sse;
 337   return sse - (((int64_t) se * se) >> (l2w + l2h));
 338 }
 339
 340 template<typename SubpelVarianceFunctionType>
 341 class SubpelVarianceTest
 342     : public ::testing::TestWithParam<tuple<int, int,
 343                                             SubpelVarianceFunctionType> > {
 344  public:
 345   virtual void SetUp() {
 346     const tuple<int, int, SubpelVarianceFunctionType>& params =
 347         this->GetParam();
 348     log2width_  = get<0>(params);
 349     width_ = 1 << log2width_;
 350     log2height_ = get<1>(params);
 351     height_ = 1 << log2height_;
 352     subpel_variance_ = get<2>(params);
 353
 354     rnd_.Reset(ACMRandom::DeterministicSeed());
 355     block_size_ = width_ * height_;
 356     src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
 357     sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
 358     ref_ = new uint8_t[block_size_ + width_ + height_ + 1];
 359     ASSERT_TRUE(src_ != NULL);
 360     ASSERT_TRUE(sec_ != NULL);
 361     ASSERT_TRUE(ref_ != NULL);
 362   }
 363
 364   virtual void TearDown() {
 365     vpx_free(src_);
 366     delete[] ref_;
 367     vpx_free(sec_);
 368     libvpx_test::ClearSystemState();
 369   }
 370
 371  protected:
 372   void RefTest();
 373
 374   ACMRandom rnd_;
 375   uint8_t *src_;
 376   uint8_t *ref_;
 377   uint8_t *sec_;
 378   int width_, log2width_;
 379   int height_, log2height_;
 380   int block_size_;
 381   SubpelVarianceFunctionType subpel_variance_;
 382 };
 383
 384 template<typename SubpelVarianceFunctionType>
 385 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
 386   for (int x = 0; x < 16; ++x) {
 387     for (int y = 0; y < 16; ++y) {
 388       for (int j = 0; j < block_size_; j++) {
 389         src_[j] = rnd_.Rand8();
 390       }
 391       for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
 392         ref_[j] = rnd_.Rand8();
 393       }
 394       unsigned int sse1, sse2;
 395       unsigned int var1;
 396       ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y,
 397                                                        src_, width_, &sse1));
 398       const unsigned int var2 = subpel_variance_ref(ref_, src_, log2width_,
 399                                                     log2height_, x, y, &sse2);
 400       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 401       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 402     }
 403   }
 404 }
 405
 406 template<>
 407 void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() {
 408   for (int x = 0; x < 16; ++x) {
 409     for (int y = 0; y < 16; ++y) {
 410       for (int j = 0; j < block_size_; j++) {
 411         src_[j] = rnd_.Rand8();
 412         sec_[j] = rnd_.Rand8();
 413       }
 414       for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
 415         ref_[j] = rnd_.Rand8();
 416       }
 417       unsigned int sse1, sse2;
 418       unsigned int var1;
 419       ASM_REGISTER_STATE_CHECK(
 420           var1 = subpel_variance_(ref_, width_ + 1, x, y,
 421                                   src_, width_, &sse1, sec_));
 422       const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_,
 423                                                         log2width_, log2height_,
 424                                                         x, y, &sse2);
 425       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 426       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 427     }
 428   }
 429 }
 430
 431 #endif  // CONFIG_VP9_ENCODER
 432
 433 // -----------------------------------------------------------------------------
 434 // VP8 test cases.
 435
 436 namespace vp8 {
 437
 438 #if CONFIG_VP8_ENCODER
 439 typedef unsigned int (*vp8_sse_fn_t)(const unsigned char *src_ptr,
 440     int source_stride, const unsigned char *ref_ptr, int  ref_stride);
 441
 442 typedef MseTest<vp8_sse_fn_t> VP8SseTest;
 443 typedef MseTest<vp8_variance_fn_t> VP8MseTest;
 444 typedef VarianceTest<vp8_variance_fn_t> VP8VarianceTest;
 445
 446 TEST_P(VP8SseTest, Ref_sse) { RefTest_sse(); }
 447 TEST_P(VP8SseTest, Max_sse) { MaxTest_sse(); }
 448 TEST_P(VP8MseTest, Ref_mse) { RefTest_mse(); }
 449 TEST_P(VP8MseTest, Max_mse) { MaxTest_mse(); }
 450 TEST_P(VP8VarianceTest, Zero) { ZeroTest(); }
 451 TEST_P(VP8VarianceTest, Ref) { RefTest(); }
 452 TEST_P(VP8VarianceTest, OneQuarter) { OneQuarterTest(); }
 453
 454 const vp8_sse_fn_t get4x4sse_cs_c = vp8_get4x4sse_cs_c;
 455 INSTANTIATE_TEST_CASE_P(
 456     C, VP8SseTest,
 457     ::testing::Values(make_tuple(2, 2, get4x4sse_cs_c)));
 458
 459 const vp8_variance_fn_t mse16x16_c = vp8_mse16x16_c;
 460 INSTANTIATE_TEST_CASE_P(
 461     C, VP8MseTest,
 462     ::testing::Values(make_tuple(4, 4, mse16x16_c)));
 463
 464 const vp8_variance_fn_t variance4x4_c = vp8_variance4x4_c;
 465 const vp8_variance_fn_t variance8x8_c = vp8_variance8x8_c;
 466 const vp8_variance_fn_t variance8x16_c = vp8_variance8x16_c;
 467 const vp8_variance_fn_t variance16x8_c = vp8_variance16x8_c;
 468 const vp8_variance_fn_t variance16x16_c = vp8_variance16x16_c;
 469 INSTANTIATE_TEST_CASE_P(
 470     C, VP8VarianceTest,
 471     ::testing::Values(make_tuple(2, 2, variance4x4_c),
 472                       make_tuple(3, 3, variance8x8_c),
 473                       make_tuple(3, 4, variance8x16_c),
 474                       make_tuple(4, 3, variance16x8_c),
 475                       make_tuple(4, 4, variance16x16_c)));
 476
 477 #if HAVE_NEON
 478 const vp8_sse_fn_t get4x4sse_cs_neon = vp8_get4x4sse_cs_neon;
 479 INSTANTIATE_TEST_CASE_P(
 480     NEON, VP8SseTest,
 481     ::testing::Values(make_tuple(2, 2, get4x4sse_cs_neon)));
 482
 483 const vp8_variance_fn_t mse16x16_neon = vp8_mse16x16_neon;
 484 INSTANTIATE_TEST_CASE_P(
 485     NEON, VP8MseTest,
 486     ::testing::Values(make_tuple(4, 4, mse16x16_neon)));
 487
 488 const vp8_variance_fn_t variance8x8_neon = vp8_variance8x8_neon;
 489 const vp8_variance_fn_t variance8x16_neon = vp8_variance8x16_neon;
 490 const vp8_variance_fn_t variance16x8_neon = vp8_variance16x8_neon;
 491 const vp8_variance_fn_t variance16x16_neon = vp8_variance16x16_neon;
 492 INSTANTIATE_TEST_CASE_P(
 493     NEON, VP8VarianceTest,
 494     ::testing::Values(make_tuple(3, 3, variance8x8_neon),
 495                       make_tuple(3, 4, variance8x16_neon),
 496                       make_tuple(4, 3, variance16x8_neon),
 497                       make_tuple(4, 4, variance16x16_neon)));
 498 #endif
 499
 500
 501 #if HAVE_MMX
 502 const vp8_variance_fn_t variance4x4_mmx = vp8_variance4x4_mmx;
 503 const vp8_variance_fn_t variance8x8_mmx = vp8_variance8x8_mmx;
 504 const vp8_variance_fn_t variance8x16_mmx = vp8_variance8x16_mmx;
 505 const vp8_variance_fn_t variance16x8_mmx = vp8_variance16x8_mmx;
 506 const vp8_variance_fn_t variance16x16_mmx = vp8_variance16x16_mmx;
 507 INSTANTIATE_TEST_CASE_P(
 508     MMX, VP8VarianceTest,
 509     ::testing::Values(make_tuple(2, 2, variance4x4_mmx),
 510                       make_tuple(3, 3, variance8x8_mmx),
 511                       make_tuple(3, 4, variance8x16_mmx),
 512                       make_tuple(4, 3, variance16x8_mmx),
 513                       make_tuple(4, 4, variance16x16_mmx)));
 514 #endif
 515
 516 #if HAVE_SSE2
 517 const vp8_variance_fn_t variance4x4_wmt = vp8_variance4x4_wmt;
 518 const vp8_variance_fn_t variance8x8_wmt = vp8_variance8x8_wmt;
 519 const vp8_variance_fn_t variance8x16_wmt = vp8_variance8x16_wmt;
 520 const vp8_variance_fn_t variance16x8_wmt = vp8_variance16x8_wmt;
 521 const vp8_variance_fn_t variance16x16_wmt = vp8_variance16x16_wmt;
 522 INSTANTIATE_TEST_CASE_P(
 523     SSE2, VP8VarianceTest,
 524     ::testing::Values(make_tuple(2, 2, variance4x4_wmt),
 525                       make_tuple(3, 3, variance8x8_wmt),
 526                       make_tuple(3, 4, variance8x16_wmt),
 527                       make_tuple(4, 3, variance16x8_wmt),
 528                       make_tuple(4, 4, variance16x16_wmt)));
 529 #endif
 530 #endif  // CONFIG_VP8_ENCODER
 531
 532 }  // namespace vp8
 533
 534 // -----------------------------------------------------------------------------
 535 // VP9 test cases.
 536
 537 namespace vp9 {
 538
 539 #if CONFIG_VP9_ENCODER
 540
 541 TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
 542 TEST_P(SumOfSquaresTest, Ref) { RefTest(); }
 543
 544 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
 545                         ::testing::Values(vp9_get_mb_ss_c));
 546
 547 typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest;
 548 typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest;
 549 typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest;
 550
 551 TEST_P(VP9VarianceTest, Zero) { ZeroTest(); }
 552 TEST_P(VP9VarianceTest, Ref) { RefTest(); }
 553 TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); }
 554 TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); }
 555 TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); }
 556
 557 const vp9_variance_fn_t variance4x4_c = vp9_variance4x4_c;
 558 const vp9_variance_fn_t variance4x8_c = vp9_variance4x8_c;
 559 const vp9_variance_fn_t variance8x4_c = vp9_variance8x4_c;
 560 const vp9_variance_fn_t variance8x8_c = vp9_variance8x8_c;
 561 const vp9_variance_fn_t variance8x16_c = vp9_variance8x16_c;
 562 const vp9_variance_fn_t variance16x8_c = vp9_variance16x8_c;
 563 const vp9_variance_fn_t variance16x16_c = vp9_variance16x16_c;
 564 const vp9_variance_fn_t variance16x32_c = vp9_variance16x32_c;
 565 const vp9_variance_fn_t variance32x16_c = vp9_variance32x16_c;
 566 const vp9_variance_fn_t variance32x32_c = vp9_variance32x32_c;
 567 const vp9_variance_fn_t variance32x64_c = vp9_variance32x64_c;
 568 const vp9_variance_fn_t variance64x32_c = vp9_variance64x32_c;
 569 const vp9_variance_fn_t variance64x64_c = vp9_variance64x64_c;
 570 INSTANTIATE_TEST_CASE_P(
 571     C, VP9VarianceTest,
 572     ::testing::Values(make_tuple(2, 2, variance4x4_c),
 573                       make_tuple(2, 3, variance4x8_c),
 574                       make_tuple(3, 2, variance8x4_c),
 575                       make_tuple(3, 3, variance8x8_c),
 576                       make_tuple(3, 4, variance8x16_c),
 577                       make_tuple(4, 3, variance16x8_c),
 578                       make_tuple(4, 4, variance16x16_c),
 579                       make_tuple(4, 5, variance16x32_c),
 580                       make_tuple(5, 4, variance32x16_c),
 581                       make_tuple(5, 5, variance32x32_c),
 582                       make_tuple(5, 6, variance32x64_c),
 583                       make_tuple(6, 5, variance64x32_c),
 584                       make_tuple(6, 6, variance64x64_c)));
 585
 586 const vp9_subpixvariance_fn_t subpel_variance4x4_c =
 587     vp9_sub_pixel_variance4x4_c;
 588 const vp9_subpixvariance_fn_t subpel_variance4x8_c =
 589     vp9_sub_pixel_variance4x8_c;
 590 const vp9_subpixvariance_fn_t subpel_variance8x4_c =
 591     vp9_sub_pixel_variance8x4_c;
 592 const vp9_subpixvariance_fn_t subpel_variance8x8_c =
 593     vp9_sub_pixel_variance8x8_c;
 594 const vp9_subpixvariance_fn_t subpel_variance8x16_c =
 595     vp9_sub_pixel_variance8x16_c;
 596 const vp9_subpixvariance_fn_t subpel_variance16x8_c =
 597     vp9_sub_pixel_variance16x8_c;
 598 const vp9_subpixvariance_fn_t subpel_variance16x16_c =
 599     vp9_sub_pixel_variance16x16_c;
 600 const vp9_subpixvariance_fn_t subpel_variance16x32_c =
 601     vp9_sub_pixel_variance16x32_c;
 602 const vp9_subpixvariance_fn_t subpel_variance32x16_c =
 603     vp9_sub_pixel_variance32x16_c;
 604 const vp9_subpixvariance_fn_t subpel_variance32x32_c =
 605     vp9_sub_pixel_variance32x32_c;
 606 const vp9_subpixvariance_fn_t subpel_variance32x64_c =
 607     vp9_sub_pixel_variance32x64_c;
 608 const vp9_subpixvariance_fn_t subpel_variance64x32_c =
 609     vp9_sub_pixel_variance64x32_c;
 610 const vp9_subpixvariance_fn_t subpel_variance64x64_c =
 611     vp9_sub_pixel_variance64x64_c;
 612 INSTANTIATE_TEST_CASE_P(
 613     C, VP9SubpelVarianceTest,
 614     ::testing::Values(make_tuple(2, 2, subpel_variance4x4_c),
 615                       make_tuple(2, 3, subpel_variance4x8_c),
 616                       make_tuple(3, 2, subpel_variance8x4_c),
 617                       make_tuple(3, 3, subpel_variance8x8_c),
 618                       make_tuple(3, 4, subpel_variance8x16_c),
 619                       make_tuple(4, 3, subpel_variance16x8_c),
 620                       make_tuple(4, 4, subpel_variance16x16_c),
 621                       make_tuple(4, 5, subpel_variance16x32_c),
 622                       make_tuple(5, 4, subpel_variance32x16_c),
 623                       make_tuple(5, 5, subpel_variance32x32_c),
 624                       make_tuple(5, 6, subpel_variance32x64_c),
 625                       make_tuple(6, 5, subpel_variance64x32_c),
 626                       make_tuple(6, 6, subpel_variance64x64_c)));
 627
 628 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_c =
 629     vp9_sub_pixel_avg_variance4x4_c;
 630 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_c =
 631     vp9_sub_pixel_avg_variance4x8_c;
 632 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_c =
 633     vp9_sub_pixel_avg_variance8x4_c;
 634 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_c =
 635     vp9_sub_pixel_avg_variance8x8_c;
 636 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_c =
 637     vp9_sub_pixel_avg_variance8x16_c;
 638 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_c =
 639     vp9_sub_pixel_avg_variance16x8_c;
 640 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_c =
 641     vp9_sub_pixel_avg_variance16x16_c;
 642 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_c =
 643     vp9_sub_pixel_avg_variance16x32_c;
 644 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_c =
 645     vp9_sub_pixel_avg_variance32x16_c;
 646 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_c =
 647     vp9_sub_pixel_avg_variance32x32_c;
 648 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_c =
 649     vp9_sub_pixel_avg_variance32x64_c;
 650 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_c =
 651     vp9_sub_pixel_avg_variance64x32_c;
 652 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_c =
 653     vp9_sub_pixel_avg_variance64x64_c;
 654 INSTANTIATE_TEST_CASE_P(
 655     C, VP9SubpelAvgVarianceTest,
 656     ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_c),
 657                       make_tuple(2, 3, subpel_avg_variance4x8_c),
 658                       make_tuple(3, 2, subpel_avg_variance8x4_c),
 659                       make_tuple(3, 3, subpel_avg_variance8x8_c),
 660                       make_tuple(3, 4, subpel_avg_variance8x16_c),
 661                       make_tuple(4, 3, subpel_avg_variance16x8_c),
 662                       make_tuple(4, 4, subpel_avg_variance16x16_c),
 663                       make_tuple(4, 5, subpel_avg_variance16x32_c),
 664                       make_tuple(5, 4, subpel_avg_variance32x16_c),
 665                       make_tuple(5, 5, subpel_avg_variance32x32_c),
 666                       make_tuple(5, 6, subpel_avg_variance32x64_c),
 667                       make_tuple(6, 5, subpel_avg_variance64x32_c),
 668                       make_tuple(6, 6, subpel_avg_variance64x64_c)));
 669
 670 #if HAVE_SSE2
 671 #if CONFIG_USE_X86INC
 672
 673 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
 674                         ::testing::Values(vp9_get_mb_ss_sse2));
 675
 676 const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2;
 677 const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2;
 678 const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2;
 679 const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2;
 680 const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2;
 681 const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2;
 682 const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2;
 683 const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2;
 684 const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2;
 685 const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2;
 686 const vp9_variance_fn_t variance32x64_sse2 = vp9_variance32x64_sse2;
 687 const vp9_variance_fn_t variance64x32_sse2 = vp9_variance64x32_sse2;
 688 const vp9_variance_fn_t variance64x64_sse2 = vp9_variance64x64_sse2;
 689 INSTANTIATE_TEST_CASE_P(
 690     SSE2, VP9VarianceTest,
 691     ::testing::Values(make_tuple(2, 2, variance4x4_sse2),
 692                       make_tuple(2, 3, variance4x8_sse2),
 693                       make_tuple(3, 2, variance8x4_sse2),
 694                       make_tuple(3, 3, variance8x8_sse2),
 695                       make_tuple(3, 4, variance8x16_sse2),
 696                       make_tuple(4, 3, variance16x8_sse2),
 697                       make_tuple(4, 4, variance16x16_sse2),
 698                       make_tuple(4, 5, variance16x32_sse2),
 699                       make_tuple(5, 4, variance32x16_sse2),
 700                       make_tuple(5, 5, variance32x32_sse2),
 701                       make_tuple(5, 6, variance32x64_sse2),
 702                       make_tuple(6, 5, variance64x32_sse2),
 703                       make_tuple(6, 6, variance64x64_sse2)));
 704
 705 const vp9_subpixvariance_fn_t subpel_variance4x4_sse =
 706     vp9_sub_pixel_variance4x4_sse;
 707 const vp9_subpixvariance_fn_t subpel_variance4x8_sse =
 708     vp9_sub_pixel_variance4x8_sse;
 709 const vp9_subpixvariance_fn_t subpel_variance8x4_sse2 =
 710     vp9_sub_pixel_variance8x4_sse2;
 711 const vp9_subpixvariance_fn_t subpel_variance8x8_sse2 =
 712     vp9_sub_pixel_variance8x8_sse2;
 713 const vp9_subpixvariance_fn_t subpel_variance8x16_sse2 =
 714     vp9_sub_pixel_variance8x16_sse2;
 715 const vp9_subpixvariance_fn_t subpel_variance16x8_sse2 =
 716     vp9_sub_pixel_variance16x8_sse2;
 717 const vp9_subpixvariance_fn_t subpel_variance16x16_sse2 =
 718     vp9_sub_pixel_variance16x16_sse2;
 719 const vp9_subpixvariance_fn_t subpel_variance16x32_sse2 =
 720     vp9_sub_pixel_variance16x32_sse2;
 721 const vp9_subpixvariance_fn_t subpel_variance32x16_sse2 =
 722     vp9_sub_pixel_variance32x16_sse2;
 723 const vp9_subpixvariance_fn_t subpel_variance32x32_sse2 =
 724     vp9_sub_pixel_variance32x32_sse2;
 725 const vp9_subpixvariance_fn_t subpel_variance32x64_sse2 =
 726     vp9_sub_pixel_variance32x64_sse2;
 727 const vp9_subpixvariance_fn_t subpel_variance64x32_sse2 =
 728     vp9_sub_pixel_variance64x32_sse2;
 729 const vp9_subpixvariance_fn_t subpel_variance64x64_sse2 =
 730     vp9_sub_pixel_variance64x64_sse2;
 731 INSTANTIATE_TEST_CASE_P(
 732     SSE2, VP9SubpelVarianceTest,
 733     ::testing::Values(make_tuple(2, 2, subpel_variance4x4_sse),
 734                       make_tuple(2, 3, subpel_variance4x8_sse),
 735                       make_tuple(3, 2, subpel_variance8x4_sse2),
 736                       make_tuple(3, 3, subpel_variance8x8_sse2),
 737                       make_tuple(3, 4, subpel_variance8x16_sse2),
 738                       make_tuple(4, 3, subpel_variance16x8_sse2),
 739                       make_tuple(4, 4, subpel_variance16x16_sse2),
 740                       make_tuple(4, 5, subpel_variance16x32_sse2),
 741                       make_tuple(5, 4, subpel_variance32x16_sse2),
 742                       make_tuple(5, 5, subpel_variance32x32_sse2),
 743                       make_tuple(5, 6, subpel_variance32x64_sse2),
 744                       make_tuple(6, 5, subpel_variance64x32_sse2),
 745                       make_tuple(6, 6, subpel_variance64x64_sse2)));
 746
 747 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_sse =
 748     vp9_sub_pixel_avg_variance4x4_sse;
 749 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_sse =
 750     vp9_sub_pixel_avg_variance4x8_sse;
 751 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_sse2 =
 752     vp9_sub_pixel_avg_variance8x4_sse2;
 753 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_sse2 =
 754     vp9_sub_pixel_avg_variance8x8_sse2;
 755 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_sse2 =
 756     vp9_sub_pixel_avg_variance8x16_sse2;
 757 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_sse2 =
 758     vp9_sub_pixel_avg_variance16x8_sse2;
 759 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_sse2 =
 760     vp9_sub_pixel_avg_variance16x16_sse2;
 761 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_sse2 =
 762     vp9_sub_pixel_avg_variance16x32_sse2;
 763 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_sse2 =
 764     vp9_sub_pixel_avg_variance32x16_sse2;
 765 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_sse2 =
 766     vp9_sub_pixel_avg_variance32x32_sse2;
 767 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_sse2 =
 768     vp9_sub_pixel_avg_variance32x64_sse2;
 769 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_sse2 =
 770     vp9_sub_pixel_avg_variance64x32_sse2;
 771 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_sse2 =
 772     vp9_sub_pixel_avg_variance64x64_sse2;
 773 INSTANTIATE_TEST_CASE_P(
 774     SSE2, VP9SubpelAvgVarianceTest,
 775     ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_sse),
 776                       make_tuple(2, 3, subpel_avg_variance4x8_sse),
 777                       make_tuple(3, 2, subpel_avg_variance8x4_sse2),
 778                       make_tuple(3, 3, subpel_avg_variance8x8_sse2),
 779                       make_tuple(3, 4, subpel_avg_variance8x16_sse2),
 780                       make_tuple(4, 3, subpel_avg_variance16x8_sse2),
 781                       make_tuple(4, 4, subpel_avg_variance16x16_sse2),
 782                       make_tuple(4, 5, subpel_avg_variance16x32_sse2),
 783                       make_tuple(5, 4, subpel_avg_variance32x16_sse2),
 784                       make_tuple(5, 5, subpel_avg_variance32x32_sse2),
 785                       make_tuple(5, 6, subpel_avg_variance32x64_sse2),
 786                       make_tuple(6, 5, subpel_avg_variance64x32_sse2),
 787                       make_tuple(6, 6, subpel_avg_variance64x64_sse2)));
 788 #endif
 789 #endif
 790
 791 #if HAVE_SSSE3
 792 #if CONFIG_USE_X86INC
 793
 794 const vp9_subpixvariance_fn_t subpel_variance4x4_ssse3 =
 795     vp9_sub_pixel_variance4x4_ssse3;
 796 const vp9_subpixvariance_fn_t subpel_variance4x8_ssse3 =
 797     vp9_sub_pixel_variance4x8_ssse3;
 798 const vp9_subpixvariance_fn_t subpel_variance8x4_ssse3 =
 799     vp9_sub_pixel_variance8x4_ssse3;
 800 const vp9_subpixvariance_fn_t subpel_variance8x8_ssse3 =
 801     vp9_sub_pixel_variance8x8_ssse3;
 802 const vp9_subpixvariance_fn_t subpel_variance8x16_ssse3 =
 803     vp9_sub_pixel_variance8x16_ssse3;
 804 const vp9_subpixvariance_fn_t subpel_variance16x8_ssse3 =
 805     vp9_sub_pixel_variance16x8_ssse3;
 806 const vp9_subpixvariance_fn_t subpel_variance16x16_ssse3 =
 807     vp9_sub_pixel_variance16x16_ssse3;
 808 const vp9_subpixvariance_fn_t subpel_variance16x32_ssse3 =
 809     vp9_sub_pixel_variance16x32_ssse3;
 810 const vp9_subpixvariance_fn_t subpel_variance32x16_ssse3 =
 811     vp9_sub_pixel_variance32x16_ssse3;
 812 const vp9_subpixvariance_fn_t subpel_variance32x32_ssse3 =
 813     vp9_sub_pixel_variance32x32_ssse3;
 814 const vp9_subpixvariance_fn_t subpel_variance32x64_ssse3 =
 815     vp9_sub_pixel_variance32x64_ssse3;
 816 const vp9_subpixvariance_fn_t subpel_variance64x32_ssse3 =
 817     vp9_sub_pixel_variance64x32_ssse3;
 818 const vp9_subpixvariance_fn_t subpel_variance64x64_ssse3 =
 819     vp9_sub_pixel_variance64x64_ssse3;
 820 INSTANTIATE_TEST_CASE_P(
 821     SSSE3, VP9SubpelVarianceTest,
 822     ::testing::Values(make_tuple(2, 2, subpel_variance4x4_ssse3),
 823                       make_tuple(2, 3, subpel_variance4x8_ssse3),
 824                       make_tuple(3, 2, subpel_variance8x4_ssse3),
 825                       make_tuple(3, 3, subpel_variance8x8_ssse3),
 826                       make_tuple(3, 4, subpel_variance8x16_ssse3),
 827                       make_tuple(4, 3, subpel_variance16x8_ssse3),
 828                       make_tuple(4, 4, subpel_variance16x16_ssse3),
 829                       make_tuple(4, 5, subpel_variance16x32_ssse3),
 830                       make_tuple(5, 4, subpel_variance32x16_ssse3),
 831                       make_tuple(5, 5, subpel_variance32x32_ssse3),
 832                       make_tuple(5, 6, subpel_variance32x64_ssse3),
 833                       make_tuple(6, 5, subpel_variance64x32_ssse3),
 834                       make_tuple(6, 6, subpel_variance64x64_ssse3)));
 835
 836 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_ssse3 =
 837     vp9_sub_pixel_avg_variance4x4_ssse3;
 838 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_ssse3 =
 839     vp9_sub_pixel_avg_variance4x8_ssse3;
 840 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_ssse3 =
 841     vp9_sub_pixel_avg_variance8x4_ssse3;
 842 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_ssse3 =
 843     vp9_sub_pixel_avg_variance8x8_ssse3;
 844 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_ssse3 =
 845     vp9_sub_pixel_avg_variance8x16_ssse3;
 846 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_ssse3 =
 847     vp9_sub_pixel_avg_variance16x8_ssse3;
 848 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_ssse3 =
 849     vp9_sub_pixel_avg_variance16x16_ssse3;
 850 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_ssse3 =
 851     vp9_sub_pixel_avg_variance16x32_ssse3;
 852 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_ssse3 =
 853     vp9_sub_pixel_avg_variance32x16_ssse3;
 854 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_ssse3 =
 855     vp9_sub_pixel_avg_variance32x32_ssse3;
 856 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_ssse3 =
 857     vp9_sub_pixel_avg_variance32x64_ssse3;
 858 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_ssse3 =
 859     vp9_sub_pixel_avg_variance64x32_ssse3;
 860 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_ssse3 =
 861     vp9_sub_pixel_avg_variance64x64_ssse3;
 862 INSTANTIATE_TEST_CASE_P(
 863     SSSE3, VP9SubpelAvgVarianceTest,
 864     ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_ssse3),
 865                       make_tuple(2, 3, subpel_avg_variance4x8_ssse3),
 866                       make_tuple(3, 2, subpel_avg_variance8x4_ssse3),
 867                       make_tuple(3, 3, subpel_avg_variance8x8_ssse3),
 868                       make_tuple(3, 4, subpel_avg_variance8x16_ssse3),
 869                       make_tuple(4, 3, subpel_avg_variance16x8_ssse3),
 870                       make_tuple(4, 4, subpel_avg_variance16x16_ssse3),
 871                       make_tuple(4, 5, subpel_avg_variance16x32_ssse3),
 872                       make_tuple(5, 4, subpel_avg_variance32x16_ssse3),
 873                       make_tuple(5, 5, subpel_avg_variance32x32_ssse3),
 874                       make_tuple(5, 6, subpel_avg_variance32x64_ssse3),
 875                       make_tuple(6, 5, subpel_avg_variance64x32_ssse3),
 876                       make_tuple(6, 6, subpel_avg_variance64x64_ssse3)));
 877 #endif
 878 #endif
 879
 880 #if HAVE_AVX2
 881
 882 const vp9_variance_fn_t variance16x16_avx2 = vp9_variance16x16_avx2;
 883 const vp9_variance_fn_t variance32x16_avx2 = vp9_variance32x16_avx2;
 884 const vp9_variance_fn_t variance32x32_avx2 = vp9_variance32x32_avx2;
 885 const vp9_variance_fn_t variance64x32_avx2 = vp9_variance64x32_avx2;
 886 const vp9_variance_fn_t variance64x64_avx2 = vp9_variance64x64_avx2;
 887 INSTANTIATE_TEST_CASE_P(
 888     AVX2, VP9VarianceTest,
 889     ::testing::Values(make_tuple(4, 4, variance16x16_avx2),
 890                       make_tuple(5, 4, variance32x16_avx2),
 891                       make_tuple(5, 5, variance32x32_avx2),
 892                       make_tuple(6, 5, variance64x32_avx2),
 893                       make_tuple(6, 6, variance64x64_avx2)));
 894
 895 const vp9_subpixvariance_fn_t subpel_variance32x32_avx2 =
 896     vp9_sub_pixel_variance32x32_avx2;
 897 const vp9_subpixvariance_fn_t subpel_variance64x64_avx2 =
 898     vp9_sub_pixel_variance64x64_avx2;
 899 INSTANTIATE_TEST_CASE_P(
 900     AVX2, VP9SubpelVarianceTest,
 901     ::testing::Values(make_tuple(5, 5, subpel_variance32x32_avx2),
 902                       make_tuple(6, 6, subpel_variance64x64_avx2)));
 903
 904 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_avx2 =
 905     vp9_sub_pixel_avg_variance32x32_avx2;
 906 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_avx2 =
 907     vp9_sub_pixel_avg_variance64x64_avx2;
 908 INSTANTIATE_TEST_CASE_P(
 909     AVX2, VP9SubpelAvgVarianceTest,
 910     ::testing::Values(make_tuple(5, 5, subpel_avg_variance32x32_avx2),
 911                       make_tuple(6, 6, subpel_avg_variance64x64_avx2)));
 912 #endif  // HAVE_AVX2
 913 #if HAVE_NEON
 914 const vp9_variance_fn_t variance8x8_neon = vp9_variance8x8_neon;
 915 const vp9_variance_fn_t variance16x16_neon = vp9_variance16x16_neon;
 916 const vp9_variance_fn_t variance32x32_neon = vp9_variance32x32_neon;
 917 INSTANTIATE_TEST_CASE_P(
 918     NEON, VP9VarianceTest,
 919     ::testing::Values(make_tuple(3, 3, variance8x8_neon),
 920                       make_tuple(4, 4, variance16x16_neon),
 921                       make_tuple(5, 5, variance32x32_neon)));
 922
 923 const vp9_subpixvariance_fn_t subpel_variance8x8_neon =
 924     vp9_sub_pixel_variance8x8_neon;
 925 const vp9_subpixvariance_fn_t subpel_variance16x16_neon =
 926     vp9_sub_pixel_variance16x16_neon;
 927 const vp9_subpixvariance_fn_t subpel_variance32x32_neon =
 928     vp9_sub_pixel_variance32x32_neon;
 929 INSTANTIATE_TEST_CASE_P(
 930     NEON, VP9SubpelVarianceTest,
 931     ::testing::Values(make_tuple(3, 3, subpel_variance8x8_neon),
 932                       make_tuple(4, 4, subpel_variance16x16_neon),
 933                       make_tuple(5, 5, subpel_variance32x32_neon)));
 934 #endif  // HAVE_NEON
 935 #endif  // CONFIG_VP9_ENCODER
 936
 937 }  // namespace vp9
 938
 939 }  // namespace