granicus.if.org Git - libvpx/blob - 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
  11 #include <cstdlib>
  12 #include <new>
  13
  14 #include "third_party/googletest/src/include/gtest/gtest.h"
  15
  16 #include "./vpx_config.h"
  17 #include "./vpx_dsp_rtcd.h"
  18 #include "test/acm_random.h"
  19 #include "test/clear_system_state.h"
  20 #include "test/register_state_check.h"
  21 #include "vpx/vpx_codec.h"
  22 #include "vpx/vpx_integer.h"
  23 #include "vpx_mem/vpx_mem.h"
  24 #include "vpx_ports/mem.h"
  25 #include "vpx_ports/vpx_timer.h"
  26
  27 namespace {
  28
  29 typedef unsigned int (*VarianceMxNFunc)(const uint8_t *a, int a_stride,
  30                                         const uint8_t *b, int b_stride,
  31                                         unsigned int *sse);
  32 typedef unsigned int (*SubpixVarMxNFunc)(const uint8_t *a, int a_stride,
  33                                          int xoffset, int yoffset,
  34                                          const uint8_t *b, int b_stride,
  35                                          unsigned int *sse);
  36 typedef unsigned int (*SubpixAvgVarMxNFunc)(const uint8_t *a, int a_stride,
  37                                             int xoffset, int yoffset,
  38                                             const uint8_t *b, int b_stride,
  39                                             uint32_t *sse,
  40                                             const uint8_t *second_pred);
  41 typedef unsigned int (*Get4x4SseFunc)(const uint8_t *a, int a_stride,
  42                                       const uint8_t *b, int b_stride);
  43 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src);
  44
  45 using libvpx_test::ACMRandom;
  46
  47 // Truncate high bit depth results by downshifting (with rounding) by:
  48 // 2 * (bit_depth - 8) for sse
  49 // (bit_depth - 8) for se
  50 static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
  51   switch (bit_depth) {
  52     case VPX_BITS_12:
  53       *sse = (*sse + 128) >> 8;
  54       *se = (*se + 8) >> 4;
  55       break;
  56     case VPX_BITS_10:
  57       *sse = (*sse + 8) >> 4;
  58       *se = (*se + 2) >> 2;
  59       break;
  60     case VPX_BITS_8:
  61     default: break;
  62   }
  63 }
  64
  65 static unsigned int mb_ss_ref(const int16_t *src) {
  66   unsigned int res = 0;
  67   for (int i = 0; i < 256; ++i) {
  68     res += src[i] * src[i];
  69   }
  70   return res;
  71 }
  72
  73 /* Note:
  74  *  Our codebase calculates the "diff" value in the variance algorithm by
  75  *  (src - ref).
  76  */
  77 static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w,
  78                              int l2h, int src_stride, int ref_stride,
  79                              uint32_t *sse_ptr, bool use_high_bit_depth_,
  80                              vpx_bit_depth_t bit_depth) {
  81   int64_t se = 0;
  82   uint64_t sse = 0;
  83   const int w = 1 << l2w;
  84   const int h = 1 << l2h;
  85   for (int y = 0; y < h; y++) {
  86     for (int x = 0; x < w; x++) {
  87       int diff;
  88       if (!use_high_bit_depth_) {
  89         diff = src[y * src_stride + x] - ref[y * ref_stride + x];
  90         se += diff;
  91         sse += diff * diff;
  92 #if CONFIG_VP9_HIGHBITDEPTH
  93       } else {
  94         diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] -
  95                CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x];
  96         se += diff;
  97         sse += diff * diff;
  98 #endif  // CONFIG_VP9_HIGHBITDEPTH
  99       }
 100     }
 101   }
 102   RoundHighBitDepth(bit_depth, &se, &sse);
 103   *sse_ptr = static_cast<uint32_t>(sse);
 104   return static_cast<uint32_t>(
 105       sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
 106 }
 107
 108 /* The subpel reference functions differ from the codec version in one aspect:
 109  * they calculate the bilinear factors directly instead of using a lookup table
 110  * and therefore upshift xoff and yoff by 1. Only every other calculated value
 111  * is used so the codec version shrinks the table to save space and maintain
 112  * compatibility with vp8.
 113  */
 114 static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
 115                                     int l2w, int l2h, int xoff, int yoff,
 116                                     uint32_t *sse_ptr, bool use_high_bit_depth_,
 117                                     vpx_bit_depth_t bit_depth) {
 118   int64_t se = 0;
 119   uint64_t sse = 0;
 120   const int w = 1 << l2w;
 121   const int h = 1 << l2h;
 122
 123   xoff <<= 1;
 124   yoff <<= 1;
 125
 126   for (int y = 0; y < h; y++) {
 127     for (int x = 0; x < w; x++) {
 128       // Bilinear interpolation at a 16th pel step.
 129       if (!use_high_bit_depth_) {
 130         const int a1 = ref[(w + 1) * (y + 0) + x + 0];
 131         const int a2 = ref[(w + 1) * (y + 0) + x + 1];
 132         const int b1 = ref[(w + 1) * (y + 1) + x + 0];
 133         const int b2 = ref[(w + 1) * (y + 1) + x + 1];
 134         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 135         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 136         const int r = a + (((b - a) * yoff + 8) >> 4);
 137         const int diff = r - src[w * y + x];
 138         se += diff;
 139         sse += diff * diff;
 140 #if CONFIG_VP9_HIGHBITDEPTH
 141       } else {
 142         uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
 143         uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
 144         const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
 145         const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
 146         const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
 147         const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
 148         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 149         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 150         const int r = a + (((b - a) * yoff + 8) >> 4);
 151         const int diff = r - src16[w * y + x];
 152         se += diff;
 153         sse += diff * diff;
 154 #endif  // CONFIG_VP9_HIGHBITDEPTH
 155       }
 156     }
 157   }
 158   RoundHighBitDepth(bit_depth, &se, &sse);
 159   *sse_ptr = static_cast<uint32_t>(sse);
 160   return static_cast<uint32_t>(
 161       sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
 162 }
 163
 164 static uint32_t subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src,
 165                                         const uint8_t *second_pred, int l2w,
 166                                         int l2h, int xoff, int yoff,
 167                                         uint32_t *sse_ptr,
 168                                         bool use_high_bit_depth,
 169                                         vpx_bit_depth_t bit_depth) {
 170   int64_t se = 0;
 171   uint64_t sse = 0;
 172   const int w = 1 << l2w;
 173   const int h = 1 << l2h;
 174
 175   xoff <<= 1;
 176   yoff <<= 1;
 177
 178   for (int y = 0; y < h; y++) {
 179     for (int x = 0; x < w; x++) {
 180       // bilinear interpolation at a 16th pel step
 181       if (!use_high_bit_depth) {
 182         const int a1 = ref[(w + 1) * (y + 0) + x + 0];
 183         const int a2 = ref[(w + 1) * (y + 0) + x + 1];
 184         const int b1 = ref[(w + 1) * (y + 1) + x + 0];
 185         const int b2 = ref[(w + 1) * (y + 1) + x + 1];
 186         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 187         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 188         const int r = a + (((b - a) * yoff + 8) >> 4);
 189         const int diff =
 190             ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x];
 191         se += diff;
 192         sse += diff * diff;
 193 #if CONFIG_VP9_HIGHBITDEPTH
 194       } else {
 195         const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
 196         const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
 197         const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred);
 198         const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
 199         const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
 200         const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
 201         const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
 202         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 203         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 204         const int r = a + (((b - a) * yoff + 8) >> 4);
 205         const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x];
 206         se += diff;
 207         sse += diff * diff;
 208 #endif  // CONFIG_VP9_HIGHBITDEPTH
 209       }
 210     }
 211   }
 212   RoundHighBitDepth(bit_depth, &se, &sse);
 213   *sse_ptr = static_cast<uint32_t>(sse);
 214   return static_cast<uint32_t>(
 215       sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
 216 }
 217
 218 ////////////////////////////////////////////////////////////////////////////////
 219
 220 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> {
 221  public:
 222   SumOfSquaresTest() : func_(GetParam()) {}
 223
 224   virtual ~SumOfSquaresTest() { libvpx_test::ClearSystemState(); }
 225
 226  protected:
 227   void ConstTest();
 228   void RefTest();
 229
 230   SumOfSquaresFunction func_;
 231   ACMRandom rnd_;
 232 };
 233
 234 void SumOfSquaresTest::ConstTest() {
 235   int16_t mem[256];
 236   unsigned int res;
 237   for (int v = 0; v < 256; ++v) {
 238     for (int i = 0; i < 256; ++i) {
 239       mem[i] = v;
 240     }
 241     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 242     EXPECT_EQ(256u * (v * v), res);
 243   }
 244 }
 245
 246 void SumOfSquaresTest::RefTest() {
 247   int16_t mem[256];
 248   for (int i = 0; i < 100; ++i) {
 249     for (int j = 0; j < 256; ++j) {
 250       mem[j] = rnd_.Rand8() - rnd_.Rand8();
 251     }
 252
 253     const unsigned int expected = mb_ss_ref(mem);
 254     unsigned int res;
 255     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 256     EXPECT_EQ(expected, res);
 257   }
 258 }
 259
 260 ////////////////////////////////////////////////////////////////////////////////
 261 // Encapsulating struct to store the function to test along with
 262 // some testing context.
 263 // Can be used for MSE, SSE, Variance, etc.
 264
 265 template <typename Func>
 266 struct TestParams {
 267   TestParams(int log2w = 0, int log2h = 0, Func function = NULL,
 268              int bit_depth_value = 0)
 269       : log2width(log2w), log2height(log2h), func(function) {
 270     use_high_bit_depth = (bit_depth_value > 0);
 271     if (use_high_bit_depth) {
 272       bit_depth = static_cast<vpx_bit_depth_t>(bit_depth_value);
 273     } else {
 274       bit_depth = VPX_BITS_8;
 275     }
 276     width = 1 << log2width;
 277     height = 1 << log2height;
 278     block_size = width * height;
 279     mask = (1u << bit_depth) - 1;
 280   }
 281
 282   int log2width, log2height;
 283   int width, height;
 284   int block_size;
 285   Func func;
 286   vpx_bit_depth_t bit_depth;
 287   bool use_high_bit_depth;
 288   uint32_t mask;
 289 };
 290
 291 template <typename Func>
 292 std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) {
 293   return os << "log2width/height:" << p.log2width << "/" << p.log2height
 294             << " function:" << reinterpret_cast<const void *>(p.func)
 295             << " bit-depth:" << p.bit_depth;
 296 }
 297
 298 // Main class for testing a function type
 299 template <typename FunctionType>
 300 class MainTestClass
 301     : public ::testing::TestWithParam<TestParams<FunctionType> > {
 302  public:
 303   virtual void SetUp() {
 304     params_ = this->GetParam();
 305
 306     rnd_.Reset(ACMRandom::DeterministicSeed());
 307     const size_t unit =
 308         use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
 309     src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit));
 310     ref_ = new uint8_t[block_size() * unit];
 311     ASSERT_TRUE(src_ != NULL);
 312     ASSERT_TRUE(ref_ != NULL);
 313 #if CONFIG_VP9_HIGHBITDEPTH
 314     if (use_high_bit_depth()) {
 315       // TODO(skal): remove!
 316       src_ = CONVERT_TO_BYTEPTR(src_);
 317       ref_ = CONVERT_TO_BYTEPTR(ref_);
 318     }
 319 #endif
 320   }
 321
 322   virtual void TearDown() {
 323 #if CONFIG_VP9_HIGHBITDEPTH
 324     if (use_high_bit_depth()) {
 325       // TODO(skal): remove!
 326       src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
 327       ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_));
 328     }
 329 #endif
 330
 331     vpx_free(src_);
 332     delete[] ref_;
 333     src_ = NULL;
 334     ref_ = NULL;
 335     libvpx_test::ClearSystemState();
 336   }
 337
 338  protected:
 339   // We could sub-class MainTestClass into dedicated class for Variance
 340   // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing
 341   // to access top class fields xxx. That's cumbersome, so for now we'll just
 342   // implement the testing methods here:
 343
 344   // Variance tests
 345   void ZeroTest();
 346   void RefTest();
 347   void RefStrideTest();
 348   void OneQuarterTest();
 349   void SpeedTest();
 350
 351   // MSE/SSE tests
 352   void RefTestMse();
 353   void RefTestSse();
 354   void MaxTestMse();
 355   void MaxTestSse();
 356
 357  protected:
 358   ACMRandom rnd_;
 359   uint8_t *src_;
 360   uint8_t *ref_;
 361   TestParams<FunctionType> params_;
 362
 363   // some relay helpers
 364   bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
 365   int byte_shift() const { return params_.bit_depth - 8; }
 366   int block_size() const { return params_.block_size; }
 367   int width() const { return params_.width; }
 368   int height() const { return params_.height; }
 369   uint32_t mask() const { return params_.mask; }
 370 };
 371
 372 ////////////////////////////////////////////////////////////////////////////////
 373 // Tests related to variance.
 374
 375 template <typename VarianceFunctionType>
 376 void MainTestClass<VarianceFunctionType>::ZeroTest() {
 377   for (int i = 0; i <= 255; ++i) {
 378     if (!use_high_bit_depth()) {
 379       memset(src_, i, block_size());
 380     } else {
 381       uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_);
 382       for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift();
 383     }
 384     for (int j = 0; j <= 255; ++j) {
 385       if (!use_high_bit_depth()) {
 386         memset(ref_, j, block_size());
 387       } else {
 388         uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_);
 389         for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift();
 390       }
 391       unsigned int sse, var;
 392       ASM_REGISTER_STATE_CHECK(
 393           var = params_.func(src_, width(), ref_, width(), &sse));
 394       EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j;
 395     }
 396   }
 397 }
 398
 399 template <typename VarianceFunctionType>
 400 void MainTestClass<VarianceFunctionType>::RefTest() {
 401   for (int i = 0; i < 10; ++i) {
 402     for (int j = 0; j < block_size(); j++) {
 403       if (!use_high_bit_depth()) {
 404         src_[j] = rnd_.Rand8();
 405         ref_[j] = rnd_.Rand8();
 406 #if CONFIG_VP9_HIGHBITDEPTH
 407       } else {
 408         CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 409         CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 410 #endif  // CONFIG_VP9_HIGHBITDEPTH
 411       }
 412     }
 413     unsigned int sse1, sse2, var1, var2;
 414     const int stride = width();
 415     ASM_REGISTER_STATE_CHECK(
 416         var1 = params_.func(src_, stride, ref_, stride, &sse1));
 417     var2 =
 418         variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 419                      stride, &sse2, use_high_bit_depth(), params_.bit_depth);
 420     EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
 421     EXPECT_EQ(var1, var2) << "Error at test index: " << i;
 422   }
 423 }
 424
 425 template <typename VarianceFunctionType>
 426 void MainTestClass<VarianceFunctionType>::RefStrideTest() {
 427   for (int i = 0; i < 10; ++i) {
 428     const int ref_stride = (i & 1) * width();
 429     const int src_stride = ((i >> 1) & 1) * width();
 430     for (int j = 0; j < block_size(); j++) {
 431       const int ref_ind = (j / width()) * ref_stride + j % width();
 432       const int src_ind = (j / width()) * src_stride + j % width();
 433       if (!use_high_bit_depth()) {
 434         src_[src_ind] = rnd_.Rand8();
 435         ref_[ref_ind] = rnd_.Rand8();
 436 #if CONFIG_VP9_HIGHBITDEPTH
 437       } else {
 438         CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() & mask();
 439         CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() & mask();
 440 #endif  // CONFIG_VP9_HIGHBITDEPTH
 441       }
 442     }
 443     unsigned int sse1, sse2;
 444     unsigned int var1, var2;
 445
 446     ASM_REGISTER_STATE_CHECK(
 447         var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1));
 448     var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height,
 449                         src_stride, ref_stride, &sse2, use_high_bit_depth(),
 450                         params_.bit_depth);
 451     EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
 452     EXPECT_EQ(var1, var2) << "Error at test index: " << i;
 453   }
 454 }
 455
 456 template <typename VarianceFunctionType>
 457 void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
 458   const int half = block_size() / 2;
 459   if (!use_high_bit_depth()) {
 460     memset(src_, 255, block_size());
 461     memset(ref_, 255, half);
 462     memset(ref_ + half, 0, half);
 463 #if CONFIG_VP9_HIGHBITDEPTH
 464   } else {
 465     vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
 466     vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
 467     vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
 468 #endif  // CONFIG_VP9_HIGHBITDEPTH
 469   }
 470   unsigned int sse, var, expected;
 471   ASM_REGISTER_STATE_CHECK(
 472       var = params_.func(src_, width(), ref_, width(), &sse));
 473   expected = block_size() * 255 * 255 / 4;
 474   EXPECT_EQ(expected, var);
 475 }
 476
 477 template <typename VarianceFunctionType>
 478 void MainTestClass<VarianceFunctionType>::SpeedTest() {
 479   const int half = block_size() / 2;
 480   if (!use_high_bit_depth()) {
 481     memset(src_, 255, block_size());
 482     memset(ref_, 255, half);
 483     memset(ref_ + half, 0, half);
 484 #if CONFIG_VP9_HIGHBITDEPTH
 485   } else {
 486     vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
 487     vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
 488     vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
 489 #endif  // CONFIG_VP9_HIGHBITDEPTH
 490   }
 491   unsigned int sse;
 492
 493   vpx_usec_timer timer;
 494   vpx_usec_timer_start(&timer);
 495   for (int i = 0; i < (1 << 30) / block_size(); ++i) {
 496     const uint32_t variance = params_.func(src_, width(), ref_, width(), &sse);
 497     // Ignore return value.
 498     (void)variance;
 499   }
 500   vpx_usec_timer_mark(&timer);
 501   const int elapsed_time = static_cast<int>(vpx_usec_timer_elapsed(&timer));
 502   printf("Variance %dx%d time: %5d ms\n", width(), height(),
 503          elapsed_time / 1000);
 504 }
 505
 506 ////////////////////////////////////////////////////////////////////////////////
 507 // Tests related to MSE / SSE.
 508
 509 template <typename FunctionType>
 510 void MainTestClass<FunctionType>::RefTestMse() {
 511   for (int i = 0; i < 10; ++i) {
 512     for (int j = 0; j < block_size(); ++j) {
 513       src_[j] = rnd_.Rand8();
 514       ref_[j] = rnd_.Rand8();
 515     }
 516     unsigned int sse1, sse2;
 517     const int stride = width();
 518     ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
 519     variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 520                  stride, &sse2, false, VPX_BITS_8);
 521     EXPECT_EQ(sse1, sse2);
 522   }
 523 }
 524
 525 template <typename FunctionType>
 526 void MainTestClass<FunctionType>::RefTestSse() {
 527   for (int i = 0; i < 10; ++i) {
 528     for (int j = 0; j < block_size(); ++j) {
 529       src_[j] = rnd_.Rand8();
 530       ref_[j] = rnd_.Rand8();
 531     }
 532     unsigned int sse2;
 533     unsigned int var1;
 534     const int stride = width();
 535     ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride));
 536     variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 537                  stride, &sse2, false, VPX_BITS_8);
 538     EXPECT_EQ(var1, sse2);
 539   }
 540 }
 541
 542 template <typename FunctionType>
 543 void MainTestClass<FunctionType>::MaxTestMse() {
 544   memset(src_, 255, block_size());
 545   memset(ref_, 0, block_size());
 546   unsigned int sse;
 547   ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse));
 548   const unsigned int expected = block_size() * 255 * 255;
 549   EXPECT_EQ(expected, sse);
 550 }
 551
 552 template <typename FunctionType>
 553 void MainTestClass<FunctionType>::MaxTestSse() {
 554   memset(src_, 255, block_size());
 555   memset(ref_, 0, block_size());
 556   unsigned int var;
 557   ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_, width()));
 558   const unsigned int expected = block_size() * 255 * 255;
 559   EXPECT_EQ(expected, var);
 560 }
 561
 562 ////////////////////////////////////////////////////////////////////////////////
 563
 564 template <typename FunctionType>
 565 class SubpelVarianceTest
 566     : public ::testing::TestWithParam<TestParams<FunctionType> > {
 567  public:
 568   virtual void SetUp() {
 569     params_ = this->GetParam();
 570
 571     rnd_.Reset(ACMRandom::DeterministicSeed());
 572     if (!use_high_bit_depth()) {
 573       src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size()));
 574       sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size()));
 575       ref_ = new uint8_t[block_size() + width() + height() + 1];
 576 #if CONFIG_VP9_HIGHBITDEPTH
 577     } else {
 578       src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
 579           vpx_memalign(16, block_size() * sizeof(uint16_t))));
 580       sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
 581           vpx_memalign(16, block_size() * sizeof(uint16_t))));
 582       ref_ = CONVERT_TO_BYTEPTR(
 583           new uint16_t[block_size() + width() + height() + 1]);
 584 #endif  // CONFIG_VP9_HIGHBITDEPTH
 585     }
 586     ASSERT_TRUE(src_ != NULL);
 587     ASSERT_TRUE(sec_ != NULL);
 588     ASSERT_TRUE(ref_ != NULL);
 589   }
 590
 591   virtual void TearDown() {
 592     if (!use_high_bit_depth()) {
 593       vpx_free(src_);
 594       delete[] ref_;
 595       vpx_free(sec_);
 596 #if CONFIG_VP9_HIGHBITDEPTH
 597     } else {
 598       vpx_free(CONVERT_TO_SHORTPTR(src_));
 599       delete[] CONVERT_TO_SHORTPTR(ref_);
 600       vpx_free(CONVERT_TO_SHORTPTR(sec_));
 601 #endif  // CONFIG_VP9_HIGHBITDEPTH
 602     }
 603     libvpx_test::ClearSystemState();
 604   }
 605
 606  protected:
 607   void RefTest();
 608   void ExtremeRefTest();
 609
 610   ACMRandom rnd_;
 611   uint8_t *src_;
 612   uint8_t *ref_;
 613   uint8_t *sec_;
 614   TestParams<FunctionType> params_;
 615
 616   // some relay helpers
 617   bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
 618   int byte_shift() const { return params_.bit_depth - 8; }
 619   int block_size() const { return params_.block_size; }
 620   int width() const { return params_.width; }
 621   int height() const { return params_.height; }
 622   uint32_t mask() const { return params_.mask; }
 623 };
 624
 625 template <typename SubpelVarianceFunctionType>
 626 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
 627   for (int x = 0; x < 8; ++x) {
 628     for (int y = 0; y < 8; ++y) {
 629       if (!use_high_bit_depth()) {
 630         for (int j = 0; j < block_size(); j++) {
 631           src_[j] = rnd_.Rand8();
 632         }
 633         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 634           ref_[j] = rnd_.Rand8();
 635         }
 636 #if CONFIG_VP9_HIGHBITDEPTH
 637       } else {
 638         for (int j = 0; j < block_size(); j++) {
 639           CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 640         }
 641         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 642           CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 643         }
 644 #endif  // CONFIG_VP9_HIGHBITDEPTH
 645       }
 646       unsigned int sse1, sse2;
 647       unsigned int var1;
 648       ASM_REGISTER_STATE_CHECK(
 649           var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
 650       const unsigned int var2 = subpel_variance_ref(
 651           ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
 652           use_high_bit_depth(), params_.bit_depth);
 653       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 654       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 655     }
 656   }
 657 }
 658
 659 template <typename SubpelVarianceFunctionType>
 660 void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() {
 661   // Compare against reference.
 662   // Src: Set the first half of values to 0, the second half to the maximum.
 663   // Ref: Set the first half of values to the maximum, the second half to 0.
 664   for (int x = 0; x < 8; ++x) {
 665     for (int y = 0; y < 8; ++y) {
 666       const int half = block_size() / 2;
 667       if (!use_high_bit_depth()) {
 668         memset(src_, 0, half);
 669         memset(src_ + half, 255, half);
 670         memset(ref_, 255, half);
 671         memset(ref_ + half, 0, half + width() + height() + 1);
 672 #if CONFIG_VP9_HIGHBITDEPTH
 673       } else {
 674         vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask(), half);
 675         vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half);
 676         vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half);
 677         vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask(),
 678                      half + width() + height() + 1);
 679 #endif  // CONFIG_VP9_HIGHBITDEPTH
 680       }
 681       unsigned int sse1, sse2;
 682       unsigned int var1;
 683       ASM_REGISTER_STATE_CHECK(
 684           var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
 685       const unsigned int var2 = subpel_variance_ref(
 686           ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
 687           use_high_bit_depth(), params_.bit_depth);
 688       EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
 689       EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
 690     }
 691   }
 692 }
 693
 694 template <>
 695 void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() {
 696   for (int x = 0; x < 8; ++x) {
 697     for (int y = 0; y < 8; ++y) {
 698       if (!use_high_bit_depth()) {
 699         for (int j = 0; j < block_size(); j++) {
 700           src_[j] = rnd_.Rand8();
 701           sec_[j] = rnd_.Rand8();
 702         }
 703         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 704           ref_[j] = rnd_.Rand8();
 705         }
 706 #if CONFIG_VP9_HIGHBITDEPTH
 707       } else {
 708         for (int j = 0; j < block_size(); j++) {
 709           CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 710           CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask();
 711         }
 712         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 713           CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 714         }
 715 #endif  // CONFIG_VP9_HIGHBITDEPTH
 716       }
 717       uint32_t sse1, sse2;
 718       uint32_t var1, var2;
 719       ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 1, x, y,
 720                                                    src_, width(), &sse1, sec_));
 721       var2 = subpel_avg_variance_ref(ref_, src_, sec_, params_.log2width,
 722                                      params_.log2height, x, y, &sse2,
 723                                      use_high_bit_depth(), params_.bit_depth);
 724       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 725       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 726     }
 727   }
 728 }
 729
 730 typedef MainTestClass<Get4x4SseFunc> VpxSseTest;
 731 typedef MainTestClass<VarianceMxNFunc> VpxMseTest;
 732 typedef MainTestClass<VarianceMxNFunc> VpxVarianceTest;
 733 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxSubpelVarianceTest;
 734 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxSubpelAvgVarianceTest;
 735
 736 TEST_P(VpxSseTest, RefSse) { RefTestSse(); }
 737 TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); }
 738 TEST_P(VpxMseTest, RefMse) { RefTestMse(); }
 739 TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); }
 740 TEST_P(VpxVarianceTest, Zero) { ZeroTest(); }
 741 TEST_P(VpxVarianceTest, Ref) { RefTest(); }
 742 TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); }
 743 TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); }
 744 TEST_P(VpxVarianceTest, DISABLED_Speed) { SpeedTest(); }
 745 TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
 746 TEST_P(SumOfSquaresTest, Ref) { RefTest(); }
 747 TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); }
 748 TEST_P(VpxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
 749 TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); }
 750
 751 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
 752                         ::testing::Values(vpx_get_mb_ss_c));
 753
 754 typedef TestParams<Get4x4SseFunc> SseParams;
 755 INSTANTIATE_TEST_CASE_P(C, VpxSseTest,
 756                         ::testing::Values(SseParams(2, 2,
 757                                                     &vpx_get4x4sse_cs_c)));
 758
 759 typedef TestParams<VarianceMxNFunc> MseParams;
 760 INSTANTIATE_TEST_CASE_P(C, VpxMseTest,
 761                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c),
 762                                           MseParams(4, 3, &vpx_mse16x8_c),
 763                                           MseParams(3, 4, &vpx_mse8x16_c),
 764                                           MseParams(3, 3, &vpx_mse8x8_c)));
 765
 766 typedef TestParams<VarianceMxNFunc> VarianceParams;
 767 INSTANTIATE_TEST_CASE_P(
 768     C, VpxVarianceTest,
 769     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c),
 770                       VarianceParams(6, 5, &vpx_variance64x32_c),
 771                       VarianceParams(5, 6, &vpx_variance32x64_c),
 772                       VarianceParams(5, 5, &vpx_variance32x32_c),
 773                       VarianceParams(5, 4, &vpx_variance32x16_c),
 774                       VarianceParams(4, 5, &vpx_variance16x32_c),
 775                       VarianceParams(4, 4, &vpx_variance16x16_c),
 776                       VarianceParams(4, 3, &vpx_variance16x8_c),
 777                       VarianceParams(3, 4, &vpx_variance8x16_c),
 778                       VarianceParams(3, 3, &vpx_variance8x8_c),
 779                       VarianceParams(3, 2, &vpx_variance8x4_c),
 780                       VarianceParams(2, 3, &vpx_variance4x8_c),
 781                       VarianceParams(2, 2, &vpx_variance4x4_c)));
 782
 783 typedef TestParams<SubpixVarMxNFunc> SubpelVarianceParams;
 784 INSTANTIATE_TEST_CASE_P(
 785     C, VpxSubpelVarianceTest,
 786     ::testing::Values(
 787         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_c, 0),
 788         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_c, 0),
 789         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_c, 0),
 790         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_c, 0),
 791         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_c, 0),
 792         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_c, 0),
 793         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_c, 0),
 794         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_c, 0),
 795         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_c, 0),
 796         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_c, 0),
 797         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_c, 0),
 798         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_c, 0),
 799         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_c, 0)));
 800
 801 typedef TestParams<SubpixAvgVarMxNFunc> SubpelAvgVarianceParams;
 802 INSTANTIATE_TEST_CASE_P(
 803     C, VpxSubpelAvgVarianceTest,
 804     ::testing::Values(
 805         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_c, 0),
 806         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0),
 807         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_c, 0),
 808         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0),
 809         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0),
 810         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_c, 0),
 811         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0),
 812         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_c, 0),
 813         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0),
 814         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0),
 815         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0),
 816         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0),
 817         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0)));
 818
 819 #if CONFIG_VP9_HIGHBITDEPTH
 820 typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest;
 821 typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest;
 822 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest;
 823 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxHBDSubpelAvgVarianceTest;
 824
 825 TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); }
 826 TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); }
 827 TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); }
 828 TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); }
 829 TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); }
 830 TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
 831 TEST_P(VpxHBDVarianceTest, DISABLED_Speed) { SpeedTest(); }
 832 TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest(); }
 833 TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
 834 TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
 835
 836 /* TODO(debargha): This test does not support the highbd version
 837 INSTANTIATE_TEST_CASE_P(
 838     C, VpxHBDMseTest,
 839     ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_c),
 840                       MseParams(4, 4, &vpx_highbd_12_mse16x8_c),
 841                       MseParams(4, 4, &vpx_highbd_12_mse8x16_c),
 842                       MseParams(4, 4, &vpx_highbd_12_mse8x8_c),
 843                       MseParams(4, 4, &vpx_highbd_10_mse16x16_c),
 844                       MseParams(4, 4, &vpx_highbd_10_mse16x8_c),
 845                       MseParams(4, 4, &vpx_highbd_10_mse8x16_c),
 846                       MseParams(4, 4, &vpx_highbd_10_mse8x8_c),
 847                       MseParams(4, 4, &vpx_highbd_8_mse16x16_c),
 848                       MseParams(4, 4, &vpx_highbd_8_mse16x8_c),
 849                       MseParams(4, 4, &vpx_highbd_8_mse8x16_c),
 850                       MseParams(4, 4, &vpx_highbd_8_mse8x8_c)));
 851 */
 852
 853 INSTANTIATE_TEST_CASE_P(
 854     C, VpxHBDVarianceTest,
 855     ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
 856                       VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12),
 857                       VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12),
 858                       VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
 859                       VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12),
 860                       VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12),
 861                       VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
 862                       VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
 863                       VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
 864                       VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
 865                       VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
 866                       VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12),
 867                       VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12),
 868                       VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
 869                       VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
 870                       VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10),
 871                       VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10),
 872                       VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
 873                       VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10),
 874                       VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
 875                       VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
 876                       VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10),
 877                       VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
 878                       VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
 879                       VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
 880                       VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
 881                       VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
 882                       VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
 883                       VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8),
 884                       VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
 885                       VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
 886                       VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
 887                       VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
 888                       VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
 889                       VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
 890                       VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
 891                       VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
 892                       VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
 893                       VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)));
 894
 895 INSTANTIATE_TEST_CASE_P(
 896     C, VpxHBDSubpelVarianceTest,
 897     ::testing::Values(
 898         SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8),
 899         SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8),
 900         SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8),
 901         SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8),
 902         SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8),
 903         SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8),
 904         SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_c, 8),
 905         SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8),
 906         SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8),
 907         SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8),
 908         SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_c, 8),
 909         SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8),
 910         SubpelVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_c, 8),
 911         SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_c,
 912                              10),
 913         SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c,
 914                              10),
 915         SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c,
 916                              10),
 917         SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c,
 918                              10),
 919         SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_c,
 920                              10),
 921         SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_c,
 922                              10),
 923         SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c,
 924                              10),
 925         SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_c, 10),
 926         SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10),
 927         SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10),
 928         SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10),
 929         SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10),
 930         SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10),
 931         SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c,
 932                              12),
 933         SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c,
 934                              12),
 935         SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_c,
 936                              12),
 937         SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c,
 938                              12),
 939         SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c,
 940                              12),
 941         SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c,
 942                              12),
 943         SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c,
 944                              12),
 945         SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12),
 946         SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12),
 947         SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12),
 948         SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12),
 949         SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12),
 950         SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c,
 951                              12)));
 952
 953 INSTANTIATE_TEST_CASE_P(
 954     C, VpxHBDSubpelAvgVarianceTest,
 955     ::testing::Values(
 956         SubpelAvgVarianceParams(6, 6,
 957                                 &vpx_highbd_8_sub_pixel_avg_variance64x64_c, 8),
 958         SubpelAvgVarianceParams(6, 5,
 959                                 &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8),
 960         SubpelAvgVarianceParams(5, 6,
 961                                 &vpx_highbd_8_sub_pixel_avg_variance32x64_c, 8),
 962         SubpelAvgVarianceParams(5, 5,
 963                                 &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8),
 964         SubpelAvgVarianceParams(5, 4,
 965                                 &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8),
 966         SubpelAvgVarianceParams(4, 5,
 967                                 &vpx_highbd_8_sub_pixel_avg_variance16x32_c, 8),
 968         SubpelAvgVarianceParams(4, 4,
 969                                 &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8),
 970         SubpelAvgVarianceParams(4, 3,
 971                                 &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8),
 972         SubpelAvgVarianceParams(3, 4,
 973                                 &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8),
 974         SubpelAvgVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c,
 975                                 8),
 976         SubpelAvgVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c,
 977                                 8),
 978         SubpelAvgVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c,
 979                                 8),
 980         SubpelAvgVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c,
 981                                 8),
 982         SubpelAvgVarianceParams(6, 6,
 983                                 &vpx_highbd_10_sub_pixel_avg_variance64x64_c,
 984                                 10),
 985         SubpelAvgVarianceParams(6, 5,
 986                                 &vpx_highbd_10_sub_pixel_avg_variance64x32_c,
 987                                 10),
 988         SubpelAvgVarianceParams(5, 6,
 989                                 &vpx_highbd_10_sub_pixel_avg_variance32x64_c,
 990                                 10),
 991         SubpelAvgVarianceParams(5, 5,
 992                                 &vpx_highbd_10_sub_pixel_avg_variance32x32_c,
 993                                 10),
 994         SubpelAvgVarianceParams(5, 4,
 995                                 &vpx_highbd_10_sub_pixel_avg_variance32x16_c,
 996                                 10),
 997         SubpelAvgVarianceParams(4, 5,
 998                                 &vpx_highbd_10_sub_pixel_avg_variance16x32_c,
 999                                 10),
1000         SubpelAvgVarianceParams(4, 4,
1001                                 &vpx_highbd_10_sub_pixel_avg_variance16x16_c,
1002                                 10),
1003         SubpelAvgVarianceParams(4, 3,
1004                                 &vpx_highbd_10_sub_pixel_avg_variance16x8_c,
1005                                 10),
1006         SubpelAvgVarianceParams(3, 4,
1007                                 &vpx_highbd_10_sub_pixel_avg_variance8x16_c,
1008                                 10),
1009         SubpelAvgVarianceParams(3, 3,
1010                                 &vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10),
1011         SubpelAvgVarianceParams(3, 2,
1012                                 &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10),
1013         SubpelAvgVarianceParams(2, 3,
1014                                 &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10),
1015         SubpelAvgVarianceParams(2, 2,
1016                                 &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10),
1017         SubpelAvgVarianceParams(6, 6,
1018                                 &vpx_highbd_12_sub_pixel_avg_variance64x64_c,
1019                                 12),
1020         SubpelAvgVarianceParams(6, 5,
1021                                 &vpx_highbd_12_sub_pixel_avg_variance64x32_c,
1022                                 12),
1023         SubpelAvgVarianceParams(5, 6,
1024                                 &vpx_highbd_12_sub_pixel_avg_variance32x64_c,
1025                                 12),
1026         SubpelAvgVarianceParams(5, 5,
1027                                 &vpx_highbd_12_sub_pixel_avg_variance32x32_c,
1028                                 12),
1029         SubpelAvgVarianceParams(5, 4,
1030                                 &vpx_highbd_12_sub_pixel_avg_variance32x16_c,
1031                                 12),
1032         SubpelAvgVarianceParams(4, 5,
1033                                 &vpx_highbd_12_sub_pixel_avg_variance16x32_c,
1034                                 12),
1035         SubpelAvgVarianceParams(4, 4,
1036                                 &vpx_highbd_12_sub_pixel_avg_variance16x16_c,
1037                                 12),
1038         SubpelAvgVarianceParams(4, 3,
1039                                 &vpx_highbd_12_sub_pixel_avg_variance16x8_c,
1040                                 12),
1041         SubpelAvgVarianceParams(3, 4,
1042                                 &vpx_highbd_12_sub_pixel_avg_variance8x16_c,
1043                                 12),
1044         SubpelAvgVarianceParams(3, 3,
1045                                 &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12),
1046         SubpelAvgVarianceParams(3, 2,
1047                                 &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12),
1048         SubpelAvgVarianceParams(2, 3,
1049                                 &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12),
1050         SubpelAvgVarianceParams(2, 2,
1051                                 &vpx_highbd_12_sub_pixel_avg_variance4x4_c,
1052                                 12)));
1053 #endif  // CONFIG_VP9_HIGHBITDEPTH
1054
1055 #if HAVE_SSE2
1056 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
1057                         ::testing::Values(vpx_get_mb_ss_sse2));
1058
1059 INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest,
1060                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2),
1061                                           MseParams(4, 3, &vpx_mse16x8_sse2),
1062                                           MseParams(3, 4, &vpx_mse8x16_sse2),
1063                                           MseParams(3, 3, &vpx_mse8x8_sse2)));
1064
1065 INSTANTIATE_TEST_CASE_P(
1066     SSE2, VpxVarianceTest,
1067     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2),
1068                       VarianceParams(6, 5, &vpx_variance64x32_sse2),
1069                       VarianceParams(5, 6, &vpx_variance32x64_sse2),
1070                       VarianceParams(5, 5, &vpx_variance32x32_sse2),
1071                       VarianceParams(5, 4, &vpx_variance32x16_sse2),
1072                       VarianceParams(4, 5, &vpx_variance16x32_sse2),
1073                       VarianceParams(4, 4, &vpx_variance16x16_sse2),
1074                       VarianceParams(4, 3, &vpx_variance16x8_sse2),
1075                       VarianceParams(3, 4, &vpx_variance8x16_sse2),
1076                       VarianceParams(3, 3, &vpx_variance8x8_sse2),
1077                       VarianceParams(3, 2, &vpx_variance8x4_sse2),
1078                       VarianceParams(2, 3, &vpx_variance4x8_sse2),
1079                       VarianceParams(2, 2, &vpx_variance4x4_sse2)));
1080
1081 INSTANTIATE_TEST_CASE_P(
1082     SSE2, VpxSubpelVarianceTest,
1083     ::testing::Values(
1084         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0),
1085         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0),
1086         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_sse2, 0),
1087         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0),
1088         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0),
1089         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0),
1090         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0),
1091         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0),
1092         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0),
1093         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0),
1094         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0),
1095         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0),
1096         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0)));
1097
1098 INSTANTIATE_TEST_CASE_P(
1099     SSE2, VpxSubpelAvgVarianceTest,
1100     ::testing::Values(
1101         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0),
1102         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_sse2, 0),
1103         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0),
1104         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0),
1105         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0),
1106         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0),
1107         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0),
1108         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_sse2, 0),
1109         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0),
1110         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0),
1111         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_sse2, 0),
1112         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0),
1113         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0)));
1114
1115 #if CONFIG_VP9_HIGHBITDEPTH
1116 /* TODO(debargha): This test does not support the highbd version
1117 INSTANTIATE_TEST_CASE_P(
1118     SSE2, VpxHBDMseTest,
1119     ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2),
1120                       MseParams(4, 3, &vpx_highbd_12_mse16x8_sse2),
1121                       MseParams(3, 4, &vpx_highbd_12_mse8x16_sse2),
1122                       MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2),
1123                       MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2),
1124                       MseParams(4, 3, &vpx_highbd_10_mse16x8_sse2),
1125                       MseParams(3, 4, &vpx_highbd_10_mse8x16_sse2),
1126                       MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2),
1127                       MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2),
1128                       MseParams(4, 3, &vpx_highbd_8_mse16x8_sse2),
1129                       MseParams(3, 4, &vpx_highbd_8_mse8x16_sse2),
1130                       MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2)));
1131 */
1132
1133 INSTANTIATE_TEST_CASE_P(
1134     SSE2, VpxHBDVarianceTest,
1135     ::testing::Values(
1136         VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
1137         VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
1138         VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
1139         VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
1140         VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
1141         VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
1142         VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
1143         VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
1144         VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
1145         VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
1146         VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
1147         VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
1148         VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
1149         VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
1150         VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
1151         VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
1152         VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10),
1153         VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
1154         VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
1155         VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10),
1156         VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8),
1157         VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8),
1158         VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
1159         VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
1160         VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
1161         VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
1162         VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
1163         VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
1164         VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
1165         VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));
1166
1167 INSTANTIATE_TEST_CASE_P(
1168     SSE2, VpxHBDSubpelVarianceTest,
1169     ::testing::Values(
1170         SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2,
1171                              12),
1172         SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2,
1173                              12),
1174         SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2,
1175                              12),
1176         SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2,
1177                              12),
1178         SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2,
1179                              12),
1180         SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2,
1181                              12),
1182         SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2,
1183                              12),
1184         SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2,
1185                              12),
1186         SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2,
1187                              12),
1188         SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2,
1189                              12),
1190         SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2,
1191                              12),
1192         SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2,
1193                              10),
1194         SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2,
1195                              10),
1196         SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2,
1197                              10),
1198         SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2,
1199                              10),
1200         SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_sse2,
1201                              10),
1202         SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2,
1203                              10),
1204         SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2,
1205                              10),
1206         SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2,
1207                              10),
1208         SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2,
1209                              10),
1210         SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2,
1211                              10),
1212         SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2,
1213                              10),
1214         SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2,
1215                              8),
1216         SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2,
1217                              8),
1218         SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_sse2,
1219                              8),
1220         SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2,
1221                              8),
1222         SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse2,
1223                              8),
1224         SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2,
1225                              8),
1226         SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2,
1227                              8),
1228         SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2,
1229                              8),
1230         SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2,
1231                              8),
1232         SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8),
1233         SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2,
1234                              8)));
1235
1236 INSTANTIATE_TEST_CASE_P(
1237     SSE2, VpxHBDSubpelAvgVarianceTest,
1238     ::testing::Values(
1239         SubpelAvgVarianceParams(6, 6,
1240                                 &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2,
1241                                 12),
1242         SubpelAvgVarianceParams(6, 5,
1243                                 &vpx_highbd_12_sub_pixel_avg_variance64x32_sse2,
1244                                 12),
1245         SubpelAvgVarianceParams(5, 6,
1246                                 &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2,
1247                                 12),
1248         SubpelAvgVarianceParams(5, 5,
1249                                 &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2,
1250                                 12),
1251         SubpelAvgVarianceParams(5, 4,
1252                                 &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2,
1253                                 12),
1254         SubpelAvgVarianceParams(4, 5,
1255                                 &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2,
1256                                 12),
1257         SubpelAvgVarianceParams(4, 4,
1258                                 &vpx_highbd_12_sub_pixel_avg_variance16x16_sse2,
1259                                 12),
1260         SubpelAvgVarianceParams(4, 3,
1261                                 &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2,
1262                                 12),
1263         SubpelAvgVarianceParams(3, 4,
1264                                 &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2,
1265                                 12),
1266         SubpelAvgVarianceParams(3, 3,
1267                                 &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2,
1268                                 12),
1269         SubpelAvgVarianceParams(3, 2,
1270                                 &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2,
1271                                 12),
1272         SubpelAvgVarianceParams(6, 6,
1273                                 &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2,
1274                                 10),
1275         SubpelAvgVarianceParams(6, 5,
1276                                 &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2,
1277                                 10),
1278         SubpelAvgVarianceParams(5, 6,
1279                                 &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2,
1280                                 10),
1281         SubpelAvgVarianceParams(5, 5,
1282                                 &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2,
1283                                 10),
1284         SubpelAvgVarianceParams(5, 4,
1285                                 &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2,
1286                                 10),
1287         SubpelAvgVarianceParams(4, 5,
1288                                 &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2,
1289                                 10),
1290         SubpelAvgVarianceParams(4, 4,
1291                                 &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2,
1292                                 10),
1293         SubpelAvgVarianceParams(4, 3,
1294                                 &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2,
1295                                 10),
1296         SubpelAvgVarianceParams(3, 4,
1297                                 &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2,
1298                                 10),
1299         SubpelAvgVarianceParams(3, 3,
1300                                 &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2,
1301                                 10),
1302         SubpelAvgVarianceParams(3, 2,
1303                                 &vpx_highbd_10_sub_pixel_avg_variance8x4_sse2,
1304                                 10),
1305         SubpelAvgVarianceParams(6, 6,
1306                                 &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2,
1307                                 8),
1308         SubpelAvgVarianceParams(6, 5,
1309                                 &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2,
1310                                 8),
1311         SubpelAvgVarianceParams(5, 6,
1312                                 &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2,
1313                                 8),
1314         SubpelAvgVarianceParams(5, 5,
1315                                 &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2,
1316                                 8),
1317         SubpelAvgVarianceParams(5, 4,
1318                                 &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2,
1319                                 8),
1320         SubpelAvgVarianceParams(4, 5,
1321                                 &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2,
1322                                 8),
1323         SubpelAvgVarianceParams(4, 4,
1324                                 &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2,
1325                                 8),
1326         SubpelAvgVarianceParams(4, 3,
1327                                 &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2,
1328                                 8),
1329         SubpelAvgVarianceParams(3, 4,
1330                                 &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2,
1331                                 8),
1332         SubpelAvgVarianceParams(3, 3,
1333                                 &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2,
1334                                 8),
1335         SubpelAvgVarianceParams(3, 2,
1336                                 &vpx_highbd_8_sub_pixel_avg_variance8x4_sse2,
1337                                 8)));
1338 #endif  // CONFIG_VP9_HIGHBITDEPTH
1339 #endif  // HAVE_SSE2
1340
1341 #if HAVE_SSSE3
1342 INSTANTIATE_TEST_CASE_P(
1343     SSSE3, VpxSubpelVarianceTest,
1344     ::testing::Values(
1345         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0),
1346         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0),
1347         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0),
1348         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0),
1349         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0),
1350         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_ssse3, 0),
1351         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0),
1352         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0),
1353         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0),
1354         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_ssse3, 0),
1355         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0),
1356         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_ssse3, 0),
1357         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_ssse3, 0)));
1358
1359 INSTANTIATE_TEST_CASE_P(
1360     SSSE3, VpxSubpelAvgVarianceTest,
1361     ::testing::Values(
1362         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3,
1363                                 0),
1364         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_ssse3,
1365                                 0),
1366         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3,
1367                                 0),
1368         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3,
1369                                 0),
1370         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3,
1371                                 0),
1372         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3,
1373                                 0),
1374         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3,
1375                                 0),
1376         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0),
1377         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0),
1378         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3, 0),
1379         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_ssse3, 0),
1380         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0),
1381         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3,
1382                                 0)));
1383 #endif  // HAVE_SSSE3
1384
1385 #if HAVE_AVX2
1386 INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest,
1387                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2)));
1388
1389 INSTANTIATE_TEST_CASE_P(
1390     AVX2, VpxVarianceTest,
1391     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2),
1392                       VarianceParams(6, 5, &vpx_variance64x32_avx2),
1393                       VarianceParams(5, 5, &vpx_variance32x32_avx2),
1394                       VarianceParams(5, 4, &vpx_variance32x16_avx2),
1395                       VarianceParams(4, 4, &vpx_variance16x16_avx2)));
1396
1397 INSTANTIATE_TEST_CASE_P(
1398     AVX2, VpxSubpelVarianceTest,
1399     ::testing::Values(
1400         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0),
1401         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0)));
1402
1403 INSTANTIATE_TEST_CASE_P(
1404     AVX2, VpxSubpelAvgVarianceTest,
1405     ::testing::Values(
1406         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0),
1407         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2,
1408                                 0)));
1409 #endif  // HAVE_AVX2
1410
1411 #if HAVE_NEON
1412 INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest,
1413                         ::testing::Values(SseParams(2, 2,
1414                                                     &vpx_get4x4sse_cs_neon)));
1415
1416 INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest,
1417                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon)));
1418
1419 INSTANTIATE_TEST_CASE_P(
1420     NEON, VpxVarianceTest,
1421     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon),
1422                       VarianceParams(6, 5, &vpx_variance64x32_neon),
1423                       VarianceParams(5, 6, &vpx_variance32x64_neon),
1424                       VarianceParams(5, 5, &vpx_variance32x32_neon),
1425                       VarianceParams(5, 4, &vpx_variance32x16_neon),
1426                       VarianceParams(4, 5, &vpx_variance16x32_neon),
1427                       VarianceParams(4, 4, &vpx_variance16x16_neon),
1428                       VarianceParams(4, 3, &vpx_variance16x8_neon),
1429                       VarianceParams(3, 4, &vpx_variance8x16_neon),
1430                       VarianceParams(3, 3, &vpx_variance8x8_neon),
1431                       VarianceParams(3, 2, &vpx_variance8x4_neon),
1432                       VarianceParams(2, 3, &vpx_variance4x8_neon),
1433                       VarianceParams(2, 2, &vpx_variance4x4_neon)));
1434
1435 INSTANTIATE_TEST_CASE_P(
1436     NEON, VpxSubpelVarianceTest,
1437     ::testing::Values(
1438         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_neon, 0),
1439         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_neon, 0),
1440         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_neon, 0),
1441         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_neon, 0),
1442         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_neon, 0),
1443         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_neon, 0),
1444         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_neon, 0),
1445         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_neon, 0),
1446         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_neon, 0),
1447         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_neon, 0),
1448         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_neon, 0),
1449         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_neon, 0),
1450         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_neon, 0)));
1451
1452 INSTANTIATE_TEST_CASE_P(
1453     NEON, VpxSubpelAvgVarianceTest,
1454     ::testing::Values(
1455         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_neon, 0),
1456         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_neon, 0),
1457         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_neon, 0),
1458         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_neon, 0),
1459         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_neon, 0),
1460         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_neon, 0),
1461         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_neon, 0),
1462         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_neon, 0),
1463         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_neon, 0),
1464         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_neon, 0),
1465         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_neon, 0),
1466         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_neon, 0),
1467         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_neon, 0)));
1468 #endif  // HAVE_NEON
1469
1470 #if HAVE_MSA
1471 INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest,
1472                         ::testing::Values(vpx_get_mb_ss_msa));
1473
1474 INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest,
1475                         ::testing::Values(SseParams(2, 2,
1476                                                     &vpx_get4x4sse_cs_msa)));
1477
1478 INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest,
1479                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa),
1480                                           MseParams(4, 3, &vpx_mse16x8_msa),
1481                                           MseParams(3, 4, &vpx_mse8x16_msa),
1482                                           MseParams(3, 3, &vpx_mse8x8_msa)));
1483
1484 INSTANTIATE_TEST_CASE_P(
1485     MSA, VpxVarianceTest,
1486     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa),
1487                       VarianceParams(6, 5, &vpx_variance64x32_msa),
1488                       VarianceParams(5, 6, &vpx_variance32x64_msa),
1489                       VarianceParams(5, 5, &vpx_variance32x32_msa),
1490                       VarianceParams(5, 4, &vpx_variance32x16_msa),
1491                       VarianceParams(4, 5, &vpx_variance16x32_msa),
1492                       VarianceParams(4, 4, &vpx_variance16x16_msa),
1493                       VarianceParams(4, 3, &vpx_variance16x8_msa),
1494                       VarianceParams(3, 4, &vpx_variance8x16_msa),
1495                       VarianceParams(3, 3, &vpx_variance8x8_msa),
1496                       VarianceParams(3, 2, &vpx_variance8x4_msa),
1497                       VarianceParams(2, 3, &vpx_variance4x8_msa),
1498                       VarianceParams(2, 2, &vpx_variance4x4_msa)));
1499
1500 INSTANTIATE_TEST_CASE_P(
1501     MSA, VpxSubpelVarianceTest,
1502     ::testing::Values(
1503         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_msa, 0),
1504         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_msa, 0),
1505         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_msa, 0),
1506         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_msa, 0),
1507         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_msa, 0),
1508         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_msa, 0),
1509         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_msa, 0),
1510         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_msa, 0),
1511         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_msa, 0),
1512         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_msa, 0),
1513         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_msa, 0),
1514         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_msa, 0),
1515         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_msa, 0)));
1516
1517 INSTANTIATE_TEST_CASE_P(
1518     MSA, VpxSubpelAvgVarianceTest,
1519     ::testing::Values(
1520         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0),
1521         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0),
1522         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0),
1523         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0),
1524         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0),
1525         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0),
1526         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0),
1527         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0),
1528         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0),
1529         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0),
1530         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0),
1531         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0),
1532         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0)));
1533 #endif  // HAVE_MSA
1534
1535 #if HAVE_VSX
1536 INSTANTIATE_TEST_CASE_P(VSX, SumOfSquaresTest,
1537                         ::testing::Values(vpx_get_mb_ss_vsx));
1538
1539 INSTANTIATE_TEST_CASE_P(VSX, VpxSseTest,
1540                         ::testing::Values(SseParams(2, 2,
1541                                                     &vpx_get4x4sse_cs_vsx)));
1542 #endif  // HAVE_VSX
1543
1544 #if HAVE_MMI
1545 INSTANTIATE_TEST_CASE_P(MMI, VpxMseTest,
1546                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_mmi),
1547                                           MseParams(4, 3, &vpx_mse16x8_mmi),
1548                                           MseParams(3, 4, &vpx_mse8x16_mmi),
1549                                           MseParams(3, 3, &vpx_mse8x8_mmi)));
1550
1551 INSTANTIATE_TEST_CASE_P(
1552     MMI, VpxVarianceTest,
1553     ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_mmi),
1554                       VarianceParams(6, 5, &vpx_variance64x32_mmi),
1555                       VarianceParams(5, 6, &vpx_variance32x64_mmi),
1556                       VarianceParams(5, 5, &vpx_variance32x32_mmi),
1557                       VarianceParams(5, 4, &vpx_variance32x16_mmi),
1558                       VarianceParams(4, 5, &vpx_variance16x32_mmi),
1559                       VarianceParams(4, 4, &vpx_variance16x16_mmi),
1560                       VarianceParams(4, 3, &vpx_variance16x8_mmi),
1561                       VarianceParams(3, 4, &vpx_variance8x16_mmi),
1562                       VarianceParams(3, 3, &vpx_variance8x8_mmi),
1563                       VarianceParams(3, 2, &vpx_variance8x4_mmi),
1564                       VarianceParams(2, 3, &vpx_variance4x8_mmi),
1565                       VarianceParams(2, 2, &vpx_variance4x4_mmi)));
1566
1567 INSTANTIATE_TEST_CASE_P(
1568     MMI, VpxSubpelVarianceTest,
1569     ::testing::Values(
1570         SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_mmi, 0),
1571         SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_mmi, 0),
1572         SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_mmi, 0),
1573         SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_mmi, 0),
1574         SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_mmi, 0),
1575         SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_mmi, 0),
1576         SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_mmi, 0),
1577         SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_mmi, 0),
1578         SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_mmi, 0),
1579         SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_mmi, 0),
1580         SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_mmi, 0),
1581         SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_mmi, 0),
1582         SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_mmi, 0)));
1583
1584 INSTANTIATE_TEST_CASE_P(
1585     MMI, VpxSubpelAvgVarianceTest,
1586     ::testing::Values(
1587         SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_mmi, 0),
1588         SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_mmi, 0),
1589         SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_mmi, 0),
1590         SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_mmi, 0),
1591         SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_mmi, 0),
1592         SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_mmi, 0),
1593         SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_mmi, 0),
1594         SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_mmi, 0),
1595         SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_mmi, 0),
1596         SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_mmi, 0),
1597         SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_mmi, 0),
1598         SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_mmi, 0),
1599         SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_mmi, 0)));
1600 #endif  // HAVE_MMI
1601 }  // namespace