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