third_party/aom/test/variance_test.cc

   1 /*
   2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11
  12 #include <cstdlib>
  13 #include <new>
  14
  15 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  16
  17 #include "config/aom_config.h"
  18 #include "config/aom_dsp_rtcd.h"
  19
  20 #include "test/acm_random.h"
  21 #include "test/clear_system_state.h"
  22 #include "test/register_state_check.h"
  23 #include "aom/aom_codec.h"
  24 #include "aom/aom_integer.h"
  25 #include "aom_mem/aom_mem.h"
  26 #include "aom_ports/aom_timer.h"
  27 #include "aom_ports/mem.h"
  28
  29 namespace {
  30
  31 typedef unsigned int (*VarianceMxNFunc)(const uint8_t *a, int a_stride,
  32                                         const uint8_t *b, int b_stride,
  33                                         unsigned int *sse);
  34 typedef unsigned int (*SubpixVarMxNFunc)(const uint8_t *a, int a_stride,
  35                                          int xoffset, int yoffset,
  36                                          const uint8_t *b, int b_stride,
  37                                          unsigned int *sse);
  38 typedef unsigned int (*SubpixAvgVarMxNFunc)(const uint8_t *a, int a_stride,
  39                                             int xoffset, int yoffset,
  40                                             const uint8_t *b, int b_stride,
  41                                             uint32_t *sse,
  42                                             const uint8_t *second_pred);
  43 typedef unsigned int (*Get4x4SseFunc)(const uint8_t *a, int a_stride,
  44                                       const uint8_t *b, int b_stride);
  45 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src);
  46 typedef unsigned int (*JntSubpixAvgVarMxNFunc)(
  47     const uint8_t *a, int a_stride, int xoffset, int yoffset, const uint8_t *b,
  48     int b_stride, uint32_t *sse, const uint8_t *second_pred,
  49     const JNT_COMP_PARAMS *jcp_param);
  50 typedef uint32_t (*ObmcSubpelVarFunc)(const uint8_t *pre, int pre_stride,
  51                                       int xoffset, int yoffset,
  52                                       const int32_t *wsrc, const int32_t *mask,
  53                                       unsigned int *sse);
  54
  55 using libaom_test::ACMRandom;
  56
  57 // Truncate high bit depth results by downshifting (with rounding) by:
  58 // 2 * (bit_depth - 8) for sse
  59 // (bit_depth - 8) for se
  60 static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
  61   switch (bit_depth) {
  62     case AOM_BITS_12:
  63       *sse = (*sse + 128) >> 8;
  64       *se = (*se + 8) >> 4;
  65       break;
  66     case AOM_BITS_10:
  67       *sse = (*sse + 8) >> 4;
  68       *se = (*se + 2) >> 2;
  69       break;
  70     case AOM_BITS_8:
  71     default: break;
  72   }
  73 }
  74
  75 static unsigned int mb_ss_ref(const int16_t *src) {
  76   unsigned int res = 0;
  77   for (int i = 0; i < 256; ++i) {
  78     res += src[i] * src[i];
  79   }
  80   return res;
  81 }
  82
  83 /* Note:
  84  *  Our codebase calculates the "diff" value in the variance algorithm by
  85  *  (src - ref).
  86  */
  87 static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w,
  88                              int l2h, int src_stride, int ref_stride,
  89                              uint32_t *sse_ptr, bool use_high_bit_depth_,
  90                              aom_bit_depth_t bit_depth) {
  91   int64_t se = 0;
  92   uint64_t sse = 0;
  93   const int w = 1 << l2w;
  94   const int h = 1 << l2h;
  95   for (int y = 0; y < h; y++) {
  96     for (int x = 0; x < w; x++) {
  97       int diff;
  98       if (!use_high_bit_depth_) {
  99         diff = src[y * src_stride + x] - ref[y * ref_stride + x];
 100         se += diff;
 101         sse += diff * diff;
 102       } else {
 103         diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] -
 104                CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x];
 105         se += diff;
 106         sse += diff * diff;
 107       }
 108     }
 109   }
 110   RoundHighBitDepth(bit_depth, &se, &sse);
 111   *sse_ptr = static_cast<uint32_t>(sse);
 112   return static_cast<uint32_t>(sse - ((se * se) >> (l2w + l2h)));
 113 }
 114
 115 /* The subpel reference functions differ from the codec version in one aspect:
 116  * they calculate the bilinear factors directly instead of using a lookup table
 117  * and therefore upshift xoff and yoff by 1. Only every other calculated value
 118  * is used so the codec version shrinks the table to save space and maintain
 119  * compatibility with vp8.
 120  */
 121 static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
 122                                     int l2w, int l2h, int xoff, int yoff,
 123                                     uint32_t *sse_ptr, bool use_high_bit_depth_,
 124                                     aom_bit_depth_t bit_depth) {
 125   int64_t se = 0;
 126   uint64_t sse = 0;
 127   const int w = 1 << l2w;
 128   const int h = 1 << l2h;
 129
 130   xoff <<= 1;
 131   yoff <<= 1;
 132
 133   for (int y = 0; y < h; y++) {
 134     for (int x = 0; x < w; x++) {
 135       // Bilinear interpolation at a 16th pel step.
 136       if (!use_high_bit_depth_) {
 137         const int a1 = ref[(w + 1) * (y + 0) + x + 0];
 138         const int a2 = ref[(w + 1) * (y + 0) + x + 1];
 139         const int b1 = ref[(w + 1) * (y + 1) + x + 0];
 140         const int b2 = ref[(w + 1) * (y + 1) + x + 1];
 141         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 142         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 143         const int r = a + (((b - a) * yoff + 8) >> 4);
 144         const int diff = r - src[w * y + x];
 145         se += diff;
 146         sse += diff * diff;
 147       } else {
 148         uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
 149         uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
 150         const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
 151         const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
 152         const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
 153         const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
 154         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 155         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 156         const int r = a + (((b - a) * yoff + 8) >> 4);
 157         const int diff = r - src16[w * y + x];
 158         se += diff;
 159         sse += diff * diff;
 160       }
 161     }
 162   }
 163   RoundHighBitDepth(bit_depth, &se, &sse);
 164   *sse_ptr = static_cast<uint32_t>(sse);
 165   return static_cast<uint32_t>(sse - ((se * se) >> (l2w + l2h)));
 166 }
 167
 168 static uint32_t subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src,
 169                                         const uint8_t *second_pred, int l2w,
 170                                         int l2h, int xoff, int yoff,
 171                                         uint32_t *sse_ptr,
 172                                         bool use_high_bit_depth,
 173                                         aom_bit_depth_t bit_depth) {
 174   int64_t se = 0;
 175   uint64_t sse = 0;
 176   const int w = 1 << l2w;
 177   const int h = 1 << l2h;
 178
 179   xoff <<= 1;
 180   yoff <<= 1;
 181
 182   for (int y = 0; y < h; y++) {
 183     for (int x = 0; x < w; x++) {
 184       // bilinear interpolation at a 16th pel step
 185       if (!use_high_bit_depth) {
 186         const int a1 = ref[(w + 1) * (y + 0) + x + 0];
 187         const int a2 = ref[(w + 1) * (y + 0) + x + 1];
 188         const int b1 = ref[(w + 1) * (y + 1) + x + 0];
 189         const int b2 = ref[(w + 1) * (y + 1) + x + 1];
 190         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 191         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 192         const int r = a + (((b - a) * yoff + 8) >> 4);
 193         const int diff =
 194             ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x];
 195         se += diff;
 196         sse += diff * diff;
 197       } else {
 198         const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
 199         const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
 200         const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred);
 201         const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
 202         const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
 203         const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
 204         const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
 205         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 206         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 207         const int r = a + (((b - a) * yoff + 8) >> 4);
 208         const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x];
 209         se += diff;
 210         sse += diff * diff;
 211       }
 212     }
 213   }
 214   RoundHighBitDepth(bit_depth, &se, &sse);
 215   *sse_ptr = static_cast<uint32_t>(sse);
 216   return static_cast<uint32_t>(sse - ((se * se) >> (l2w + l2h)));
 217 }
 218
 219 static uint32_t jnt_subpel_avg_variance_ref(
 220     const uint8_t *ref, const uint8_t *src, const uint8_t *second_pred, int l2w,
 221     int l2h, int xoff, int yoff, uint32_t *sse_ptr, bool use_high_bit_depth,
 222     aom_bit_depth_t bit_depth, JNT_COMP_PARAMS *jcp_param) {
 223   int64_t se = 0;
 224   uint64_t sse = 0;
 225   const int w = 1 << l2w;
 226   const int h = 1 << l2h;
 227
 228   xoff <<= 1;
 229   yoff <<= 1;
 230
 231   for (int y = 0; y < h; y++) {
 232     for (int x = 0; x < w; x++) {
 233       // bilinear interpolation at a 16th pel step
 234       if (!use_high_bit_depth) {
 235         const int a1 = ref[(w + 0) * (y + 0) + x + 0];
 236         const int a2 = ref[(w + 0) * (y + 0) + x + 1];
 237         const int b1 = ref[(w + 0) * (y + 1) + x + 0];
 238         const int b2 = ref[(w + 0) * (y + 1) + x + 1];
 239         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 240         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 241         const int r = a + (((b - a) * yoff + 8) >> 4);
 242         const int avg = ROUND_POWER_OF_TWO(
 243             r * jcp_param->fwd_offset +
 244                 second_pred[w * y + x] * jcp_param->bck_offset,
 245             DIST_PRECISION_BITS);
 246         const int diff = avg - src[w * y + x];
 247
 248         se += diff;
 249         sse += diff * diff;
 250       } else {
 251         const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
 252         const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
 253         const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred);
 254         const int a1 = ref16[(w + 0) * (y + 0) + x + 0];
 255         const int a2 = ref16[(w + 0) * (y + 0) + x + 1];
 256         const int b1 = ref16[(w + 0) * (y + 1) + x + 0];
 257         const int b2 = ref16[(w + 0) * (y + 1) + x + 1];
 258         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 259         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 260         const int r = a + (((b - a) * yoff + 8) >> 4);
 261         const int avg =
 262             ROUND_POWER_OF_TWO(r * jcp_param->fwd_offset +
 263                                    sec16[w * y + x] * jcp_param->bck_offset,
 264                                DIST_PRECISION_BITS);
 265         const int diff = avg - src16[w * y + x];
 266
 267         se += diff;
 268         sse += diff * diff;
 269       }
 270     }
 271   }
 272   RoundHighBitDepth(bit_depth, &se, &sse);
 273   *sse_ptr = static_cast<uint32_t>(sse);
 274   return static_cast<uint32_t>(sse - ((se * se) >> (l2w + l2h)));
 275 }
 276
 277 static uint32_t obmc_subpel_variance_ref(const uint8_t *pre, int l2w, int l2h,
 278                                          int xoff, int yoff,
 279                                          const int32_t *wsrc,
 280                                          const int32_t *mask, uint32_t *sse_ptr,
 281                                          bool use_high_bit_depth_,
 282                                          aom_bit_depth_t bit_depth) {
 283   int64_t se = 0;
 284   uint64_t sse = 0;
 285   const int w = 1 << l2w;
 286   const int h = 1 << l2h;
 287
 288   xoff <<= 1;
 289   yoff <<= 1;
 290
 291   for (int y = 0; y < h; y++) {
 292     for (int x = 0; x < w; x++) {
 293       // Bilinear interpolation at a 16th pel step.
 294       if (!use_high_bit_depth_) {
 295         const int a1 = pre[(w + 1) * (y + 0) + x + 0];
 296         const int a2 = pre[(w + 1) * (y + 0) + x + 1];
 297         const int b1 = pre[(w + 1) * (y + 1) + x + 0];
 298         const int b2 = pre[(w + 1) * (y + 1) + x + 1];
 299         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 300         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 301         const int r = a + (((b - a) * yoff + 8) >> 4);
 302         const int diff = ROUND_POWER_OF_TWO_SIGNED(
 303             wsrc[w * y + x] - r * mask[w * y + x], 12);
 304         se += diff;
 305         sse += diff * diff;
 306       } else {
 307         uint16_t *pre16 = CONVERT_TO_SHORTPTR(pre);
 308         const int a1 = pre16[(w + 1) * (y + 0) + x + 0];
 309         const int a2 = pre16[(w + 1) * (y + 0) + x + 1];
 310         const int b1 = pre16[(w + 1) * (y + 1) + x + 0];
 311         const int b2 = pre16[(w + 1) * (y + 1) + x + 1];
 312         const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
 313         const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
 314         const int r = a + (((b - a) * yoff + 8) >> 4);
 315         const int diff = ROUND_POWER_OF_TWO_SIGNED(
 316             wsrc[w * y + x] - r * mask[w * y + x], 12);
 317         se += diff;
 318         sse += diff * diff;
 319       }
 320     }
 321   }
 322   RoundHighBitDepth(bit_depth, &se, &sse);
 323   *sse_ptr = static_cast<uint32_t>(sse);
 324   return static_cast<uint32_t>(sse - ((se * se) >> (l2w + l2h)));
 325 }
 326
 327 ////////////////////////////////////////////////////////////////////////////////
 328
 329 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> {
 330  public:
 331   SumOfSquaresTest() : func_(GetParam()) {}
 332
 333   virtual ~SumOfSquaresTest() { libaom_test::ClearSystemState(); }
 334
 335  protected:
 336   void ConstTest();
 337   void RefTest();
 338
 339   SumOfSquaresFunction func_;
 340   ACMRandom rnd_;
 341 };
 342
 343 void SumOfSquaresTest::ConstTest() {
 344   int16_t mem[256];
 345   unsigned int res;
 346   for (int v = 0; v < 256; ++v) {
 347     for (int i = 0; i < 256; ++i) {
 348       mem[i] = v;
 349     }
 350     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 351     EXPECT_EQ(256u * (v * v), res);
 352   }
 353 }
 354
 355 void SumOfSquaresTest::RefTest() {
 356   int16_t mem[256];
 357   for (int i = 0; i < 100; ++i) {
 358     for (int j = 0; j < 256; ++j) {
 359       mem[j] = rnd_.Rand8() - rnd_.Rand8();
 360     }
 361
 362     const unsigned int expected = mb_ss_ref(mem);
 363     unsigned int res;
 364     ASM_REGISTER_STATE_CHECK(res = func_(mem));
 365     EXPECT_EQ(expected, res);
 366   }
 367 }
 368
 369 ////////////////////////////////////////////////////////////////////////////////
 370 // Encapsulating struct to store the function to test along with
 371 // some testing context.
 372 // Can be used for MSE, SSE, Variance, etc.
 373
 374 template <typename Func>
 375 struct TestParams {
 376   TestParams(int log2w = 0, int log2h = 0, Func function = NULL,
 377              int bit_depth_value = 0)
 378       : log2width(log2w), log2height(log2h), func(function) {
 379     use_high_bit_depth = (bit_depth_value > 0);
 380     if (use_high_bit_depth) {
 381       bit_depth = static_cast<aom_bit_depth_t>(bit_depth_value);
 382     } else {
 383       bit_depth = AOM_BITS_8;
 384     }
 385     width = 1 << log2width;
 386     height = 1 << log2height;
 387     block_size = width * height;
 388     mask = (1u << bit_depth) - 1;
 389   }
 390
 391   int log2width, log2height;
 392   int width, height;
 393   int block_size;
 394   Func func;
 395   aom_bit_depth_t bit_depth;
 396   bool use_high_bit_depth;
 397   uint32_t mask;
 398 };
 399
 400 template <typename Func>
 401 std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) {
 402   return os << "width/height:" << p.width << "/" << p.height
 403             << " function:" << reinterpret_cast<const void *>(p.func)
 404             << " bit-depth:" << p.bit_depth;
 405 }
 406
 407 // Main class for testing a function type
 408 template <typename FunctionType>
 409 class MainTestClass
 410     : public ::testing::TestWithParam<TestParams<FunctionType> > {
 411  public:
 412   virtual void SetUp() {
 413     params_ = this->GetParam();
 414
 415     rnd_.Reset(ACMRandom::DeterministicSeed());
 416     const size_t unit =
 417         use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
 418     src_ = reinterpret_cast<uint8_t *>(aom_memalign(16, block_size() * unit));
 419     ref_ = new uint8_t[block_size() * unit];
 420     ASSERT_TRUE(src_ != NULL);
 421     ASSERT_TRUE(ref_ != NULL);
 422     if (use_high_bit_depth()) {
 423       // TODO(skal): remove!
 424       src_ = CONVERT_TO_BYTEPTR(src_);
 425       ref_ = CONVERT_TO_BYTEPTR(ref_);
 426     }
 427   }
 428
 429   virtual void TearDown() {
 430     if (use_high_bit_depth()) {
 431       // TODO(skal): remove!
 432       src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
 433       ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_));
 434     }
 435
 436     aom_free(src_);
 437     delete[] ref_;
 438     src_ = NULL;
 439     ref_ = NULL;
 440     libaom_test::ClearSystemState();
 441   }
 442
 443  protected:
 444   // We could sub-class MainTestClass into dedicated class for Variance
 445   // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing
 446   // to access top class fields xxx. That's cumbersome, so for now we'll just
 447   // implement the testing methods here:
 448
 449   // Variance tests
 450   void ZeroTest();
 451   void RefTest();
 452   void RefStrideTest();
 453   void OneQuarterTest();
 454   void SpeedTest();
 455
 456   // MSE/SSE tests
 457   void RefTestMse();
 458   void RefTestSse();
 459   void MaxTestMse();
 460   void MaxTestSse();
 461
 462  protected:
 463   ACMRandom rnd_;
 464   uint8_t *src_;
 465   uint8_t *ref_;
 466   TestParams<FunctionType> params_;
 467
 468   // some relay helpers
 469   bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
 470   int byte_shift() const { return params_.bit_depth - 8; }
 471   int block_size() const { return params_.block_size; }
 472   int width() const { return params_.width; }
 473   int height() const { return params_.height; }
 474   uint32_t mask() const { return params_.mask; }
 475 };
 476
 477 ////////////////////////////////////////////////////////////////////////////////
 478 // Tests related to variance.
 479
 480 template <typename VarianceFunctionType>
 481 void MainTestClass<VarianceFunctionType>::ZeroTest() {
 482   for (int i = 0; i <= 255; ++i) {
 483     if (!use_high_bit_depth()) {
 484       memset(src_, i, block_size());
 485     } else {
 486       uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_);
 487       for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift();
 488     }
 489     for (int j = 0; j <= 255; ++j) {
 490       if (!use_high_bit_depth()) {
 491         memset(ref_, j, block_size());
 492       } else {
 493         uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_);
 494         for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift();
 495       }
 496       unsigned int sse, var;
 497       ASM_REGISTER_STATE_CHECK(
 498           var = params_.func(src_, width(), ref_, width(), &sse));
 499       EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j;
 500     }
 501   }
 502 }
 503
 504 template <typename VarianceFunctionType>
 505 void MainTestClass<VarianceFunctionType>::RefTest() {
 506   for (int i = 0; i < 10; ++i) {
 507     for (int j = 0; j < block_size(); j++) {
 508       if (!use_high_bit_depth()) {
 509         src_[j] = rnd_.Rand8();
 510         ref_[j] = rnd_.Rand8();
 511       } else {
 512         CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 513         CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 514       }
 515     }
 516     unsigned int sse1, sse2, var1, var2;
 517     const int stride = width();
 518     ASM_REGISTER_STATE_CHECK(
 519         var1 = params_.func(src_, stride, ref_, stride, &sse1));
 520     var2 =
 521         variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 522                      stride, &sse2, use_high_bit_depth(), params_.bit_depth);
 523     EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
 524     EXPECT_EQ(var1, var2) << "Error at test index: " << i;
 525   }
 526 }
 527
 528 template <typename VarianceFunctionType>
 529 void MainTestClass<VarianceFunctionType>::RefStrideTest() {
 530   for (int i = 0; i < 10; ++i) {
 531     const int ref_stride = (i & 1) * width();
 532     const int src_stride = ((i >> 1) & 1) * width();
 533     for (int j = 0; j < block_size(); j++) {
 534       const int ref_ind = (j / width()) * ref_stride + j % width();
 535       const int src_ind = (j / width()) * src_stride + j % width();
 536       if (!use_high_bit_depth()) {
 537         src_[src_ind] = rnd_.Rand8();
 538         ref_[ref_ind] = rnd_.Rand8();
 539       } else {
 540         CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() & mask();
 541         CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() & mask();
 542       }
 543     }
 544     unsigned int sse1, sse2;
 545     unsigned int var1, var2;
 546
 547     ASM_REGISTER_STATE_CHECK(
 548         var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1));
 549     var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height,
 550                         src_stride, ref_stride, &sse2, use_high_bit_depth(),
 551                         params_.bit_depth);
 552     EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
 553     EXPECT_EQ(var1, var2) << "Error at test index: " << i;
 554   }
 555 }
 556
 557 template <typename VarianceFunctionType>
 558 void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
 559   const int half = block_size() / 2;
 560   if (!use_high_bit_depth()) {
 561     memset(src_, 255, block_size());
 562     memset(ref_, 255, half);
 563     memset(ref_ + half, 0, half);
 564   } else {
 565     aom_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
 566     aom_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
 567     aom_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
 568   }
 569   unsigned int sse, var, expected;
 570   ASM_REGISTER_STATE_CHECK(
 571       var = params_.func(src_, width(), ref_, width(), &sse));
 572   expected = block_size() * 255 * 255 / 4;
 573   EXPECT_EQ(expected, var);
 574 }
 575
 576 template <typename VarianceFunctionType>
 577 void MainTestClass<VarianceFunctionType>::SpeedTest() {
 578   for (int j = 0; j < block_size(); j++) {
 579     if (!use_high_bit_depth()) {
 580       src_[j] = rnd_.Rand8();
 581       ref_[j] = rnd_.Rand8();
 582     } else {
 583       CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 584       CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 585     }
 586   }
 587   unsigned int sse;
 588   const int stride = width();
 589   int run_time = 1000000000 / block_size();
 590   aom_usec_timer timer;
 591   aom_usec_timer_start(&timer);
 592   for (int i = 0; i < run_time; ++i) {
 593     params_.func(src_, stride, ref_, stride, &sse);
 594   }
 595
 596   aom_usec_timer_mark(&timer);
 597   const double elapsed_time =
 598       static_cast<double>(aom_usec_timer_elapsed(&timer));
 599   printf("Variance %dx%d : %7.2fns\n", width(), height(), elapsed_time);
 600 }
 601
 602 ////////////////////////////////////////////////////////////////////////////////
 603 // Tests related to MSE / SSE.
 604
 605 template <typename FunctionType>
 606 void MainTestClass<FunctionType>::RefTestMse() {
 607   for (int i = 0; i < 10; ++i) {
 608     for (int j = 0; j < block_size(); ++j) {
 609       src_[j] = rnd_.Rand8();
 610       ref_[j] = rnd_.Rand8();
 611     }
 612     unsigned int sse1, sse2;
 613     const int stride = width();
 614     ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
 615     variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 616                  stride, &sse2, false, AOM_BITS_8);
 617     EXPECT_EQ(sse1, sse2);
 618   }
 619 }
 620
 621 template <typename FunctionType>
 622 void MainTestClass<FunctionType>::RefTestSse() {
 623   for (int i = 0; i < 10; ++i) {
 624     for (int j = 0; j < block_size(); ++j) {
 625       src_[j] = rnd_.Rand8();
 626       ref_[j] = rnd_.Rand8();
 627     }
 628     unsigned int sse2;
 629     unsigned int var1;
 630     const int stride = width();
 631     ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride));
 632     variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
 633                  stride, &sse2, false, AOM_BITS_8);
 634     EXPECT_EQ(var1, sse2);
 635   }
 636 }
 637
 638 template <typename FunctionType>
 639 void MainTestClass<FunctionType>::MaxTestMse() {
 640   memset(src_, 255, block_size());
 641   memset(ref_, 0, block_size());
 642   unsigned int sse;
 643   ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse));
 644   const unsigned int expected = block_size() * 255 * 255;
 645   EXPECT_EQ(expected, sse);
 646 }
 647
 648 template <typename FunctionType>
 649 void MainTestClass<FunctionType>::MaxTestSse() {
 650   memset(src_, 255, block_size());
 651   memset(ref_, 0, block_size());
 652   unsigned int var;
 653   ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_, width()));
 654   const unsigned int expected = block_size() * 255 * 255;
 655   EXPECT_EQ(expected, var);
 656 }
 657
 658 ////////////////////////////////////////////////////////////////////////////////
 659
 660 using ::testing::get;
 661 using ::testing::make_tuple;
 662 using ::testing::tuple;
 663
 664 template <typename FunctionType>
 665 class SubpelVarianceTest
 666     : public ::testing::TestWithParam<TestParams<FunctionType> > {
 667  public:
 668   virtual void SetUp() {
 669     params_ = this->GetParam();
 670
 671     rnd_.Reset(ACMRandom::DeterministicSeed());
 672     if (!use_high_bit_depth()) {
 673       src_ = reinterpret_cast<uint8_t *>(aom_memalign(32, block_size()));
 674       sec_ = reinterpret_cast<uint8_t *>(aom_memalign(32, block_size()));
 675       ref_ = reinterpret_cast<uint8_t *>(
 676           aom_memalign(32, block_size() + width() + height() + 1));
 677     } else {
 678       src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
 679           aom_memalign(32, block_size() * sizeof(uint16_t))));
 680       sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
 681           aom_memalign(32, block_size() * sizeof(uint16_t))));
 682       ref_ = CONVERT_TO_BYTEPTR(aom_memalign(
 683           32, (block_size() + width() + height() + 1) * sizeof(uint16_t)));
 684     }
 685     ASSERT_TRUE(src_ != NULL);
 686     ASSERT_TRUE(sec_ != NULL);
 687     ASSERT_TRUE(ref_ != NULL);
 688   }
 689
 690   virtual void TearDown() {
 691     if (!use_high_bit_depth()) {
 692       aom_free(src_);
 693       aom_free(ref_);
 694       aom_free(sec_);
 695     } else {
 696       aom_free(CONVERT_TO_SHORTPTR(src_));
 697       aom_free(CONVERT_TO_SHORTPTR(ref_));
 698       aom_free(CONVERT_TO_SHORTPTR(sec_));
 699     }
 700     libaom_test::ClearSystemState();
 701   }
 702
 703  protected:
 704   void RefTest();
 705   void ExtremeRefTest();
 706
 707   ACMRandom rnd_;
 708   uint8_t *src_;
 709   uint8_t *ref_;
 710   uint8_t *sec_;
 711   TestParams<FunctionType> params_;
 712   JNT_COMP_PARAMS jcp_param_;
 713
 714   // some relay helpers
 715   bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
 716   int byte_shift() const { return params_.bit_depth - 8; }
 717   int block_size() const { return params_.block_size; }
 718   int width() const { return params_.width; }
 719   int height() const { return params_.height; }
 720   uint32_t mask() const { return params_.mask; }
 721 };
 722
 723 template <typename SubpelVarianceFunctionType>
 724 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
 725   for (int x = 0; x < 8; ++x) {
 726     for (int y = 0; y < 8; ++y) {
 727       if (!use_high_bit_depth()) {
 728         for (int j = 0; j < block_size(); j++) {
 729           src_[j] = rnd_.Rand8();
 730         }
 731         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 732           ref_[j] = rnd_.Rand8();
 733         }
 734       } else {
 735         for (int j = 0; j < block_size(); j++) {
 736           CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 737         }
 738         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 739           CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 740         }
 741       }
 742       unsigned int sse1, sse2;
 743       unsigned int var1;
 744       ASM_REGISTER_STATE_CHECK(
 745           var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
 746       const unsigned int var2 = subpel_variance_ref(
 747           ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
 748           use_high_bit_depth(), params_.bit_depth);
 749       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 750       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 751     }
 752   }
 753 }
 754
 755 template <typename SubpelVarianceFunctionType>
 756 void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() {
 757   // Compare against reference.
 758   // Src: Set the first half of values to 0, the second half to the maximum.
 759   // Ref: Set the first half of values to the maximum, the second half to 0.
 760   for (int x = 0; x < 8; ++x) {
 761     for (int y = 0; y < 8; ++y) {
 762       const int half = block_size() / 2;
 763       if (!use_high_bit_depth()) {
 764         memset(src_, 0, half);
 765         memset(src_ + half, 255, half);
 766         memset(ref_, 255, half);
 767         memset(ref_ + half, 0, half + width() + height() + 1);
 768       } else {
 769         aom_memset16(CONVERT_TO_SHORTPTR(src_), mask(), half);
 770         aom_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half);
 771         aom_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half);
 772         aom_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask(),
 773                      half + width() + height() + 1);
 774       }
 775       unsigned int sse1, sse2;
 776       unsigned int var1;
 777       ASM_REGISTER_STATE_CHECK(
 778           var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
 779       const unsigned int var2 = subpel_variance_ref(
 780           ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
 781           use_high_bit_depth(), params_.bit_depth);
 782       EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
 783       EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
 784     }
 785   }
 786 }
 787
 788 template <>
 789 void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() {
 790   for (int x = 0; x < 8; ++x) {
 791     for (int y = 0; y < 8; ++y) {
 792       if (!use_high_bit_depth()) {
 793         for (int j = 0; j < block_size(); j++) {
 794           src_[j] = rnd_.Rand8();
 795           sec_[j] = rnd_.Rand8();
 796         }
 797         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 798           ref_[j] = rnd_.Rand8();
 799         }
 800       } else {
 801         for (int j = 0; j < block_size(); j++) {
 802           CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 803           CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask();
 804         }
 805         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 806           CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 807         }
 808       }
 809       uint32_t sse1, sse2;
 810       uint32_t var1, var2;
 811       ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 1, x, y,
 812                                                    src_, width(), &sse1, sec_));
 813       var2 = subpel_avg_variance_ref(ref_, src_, sec_, params_.log2width,
 814                                      params_.log2height, x, y, &sse2,
 815                                      use_high_bit_depth(), params_.bit_depth);
 816       EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 817       EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 818     }
 819   }
 820 }
 821
 822 template <>
 823 void SubpelVarianceTest<JntSubpixAvgVarMxNFunc>::RefTest() {
 824   for (int x = 0; x < 8; ++x) {
 825     for (int y = 0; y < 8; ++y) {
 826       if (!use_high_bit_depth()) {
 827         for (int j = 0; j < block_size(); j++) {
 828           src_[j] = rnd_.Rand8();
 829           sec_[j] = rnd_.Rand8();
 830         }
 831         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 832           ref_[j] = rnd_.Rand8();
 833         }
 834       } else {
 835         for (int j = 0; j < block_size(); j++) {
 836           CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
 837           CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask();
 838         }
 839         for (int j = 0; j < block_size() + width() + height() + 1; j++) {
 840           CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
 841         }
 842       }
 843       for (int x0 = 0; x0 < 2; ++x0) {
 844         for (int y0 = 0; y0 < 4; ++y0) {
 845           uint32_t sse1, sse2;
 846           uint32_t var1, var2;
 847           jcp_param_.fwd_offset = quant_dist_lookup_table[x0][y0][0];
 848           jcp_param_.bck_offset = quant_dist_lookup_table[x0][y0][1];
 849           ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 0, x, y,
 850                                                        src_, width(), &sse1,
 851                                                        sec_, &jcp_param_));
 852           var2 = jnt_subpel_avg_variance_ref(
 853               ref_, src_, sec_, params_.log2width, params_.log2height, x, y,
 854               &sse2, use_high_bit_depth(), params_.bit_depth, &jcp_param_);
 855           EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
 856           EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
 857         }
 858       }
 859     }
 860   }
 861 }
 862
 863 ////////////////////////////////////////////////////////////////////////////////
 864
 865 static const int kMaskMax = 64;
 866
 867 typedef TestParams<ObmcSubpelVarFunc> ObmcSubpelVarianceParams;
 868
 869 template <typename FunctionType>
 870 class ObmcVarianceTest
 871     : public ::testing::TestWithParam<TestParams<FunctionType> > {
 872  public:
 873   virtual void SetUp() {
 874     params_ = this->GetParam();
 875
 876     rnd_.Reset(ACMRandom::DeterministicSeed());
 877     if (!use_high_bit_depth()) {
 878       pre_ = reinterpret_cast<uint8_t *>(
 879           aom_memalign(32, block_size() + width() + height() + 1));
 880     } else {
 881       pre_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(aom_memalign(
 882           32, block_size() + width() + height() + 1 * sizeof(uint16_t))));
 883     }
 884     wsrc_ = reinterpret_cast<int32_t *>(
 885         aom_memalign(32, block_size() * sizeof(uint32_t)));
 886     mask_ = reinterpret_cast<int32_t *>(
 887         aom_memalign(32, block_size() * sizeof(uint32_t)));
 888     ASSERT_TRUE(pre_ != NULL);
 889     ASSERT_TRUE(wsrc_ != NULL);
 890     ASSERT_TRUE(mask_ != NULL);
 891   }
 892
 893   virtual void TearDown() {
 894     if (!use_high_bit_depth()) {
 895       aom_free(pre_);
 896     } else {
 897       aom_free(CONVERT_TO_SHORTPTR(pre_));
 898     }
 899     aom_free(wsrc_);
 900     aom_free(mask_);
 901     libaom_test::ClearSystemState();
 902   }
 903
 904  protected:
 905   void RefTest();
 906   void ExtremeRefTest();
 907   void SpeedTest();
 908
 909   ACMRandom rnd_;
 910   uint8_t *pre_;
 911   int32_t *wsrc_;
 912   int32_t *mask_;
 913   TestParams<FunctionType> params_;
 914
 915   // some relay helpers
 916   bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
 917   int byte_shift() const { return params_.bit_depth - 8; }
 918   int block_size() const { return params_.block_size; }
 919   int width() const { return params_.width; }
 920   int height() const { return params_.height; }
 921   uint32_t bd_mask() const { return params_.mask; }
 922 };
 923
 924 template <>
 925 void ObmcVarianceTest<ObmcSubpelVarFunc>::RefTest() {
 926   for (int x = 0; x < 8; ++x) {
 927     for (int y = 0; y < 8; ++y) {
 928       if (!use_high_bit_depth())
 929         for (int j = 0; j < block_size() + width() + height() + 1; j++)
 930           pre_[j] = rnd_.Rand8();
 931       else
 932         for (int j = 0; j < block_size() + width() + height() + 1; j++)
 933           CONVERT_TO_SHORTPTR(pre_)[j] = rnd_.Rand16() & bd_mask();
 934       for (int j = 0; j < block_size(); j++) {
 935         wsrc_[j] = (rnd_.Rand16() & bd_mask()) * rnd_(kMaskMax * kMaskMax + 1);
 936         mask_[j] = rnd_(kMaskMax * kMaskMax + 1);
 937       }
 938
 939       uint32_t sse1, sse2;
 940       uint32_t var1, var2;
 941       ASM_REGISTER_STATE_CHECK(
 942           var1 = params_.func(pre_, width() + 1, x, y, wsrc_, mask_, &sse1));
 943       var2 = obmc_subpel_variance_ref(
 944           pre_, params_.log2width, params_.log2height, x, y, wsrc_, mask_,
 945           &sse2, use_high_bit_depth(), params_.bit_depth);
 946       EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
 947       EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
 948     }
 949   }
 950 }
 951
 952 template <>
 953 void ObmcVarianceTest<ObmcSubpelVarFunc>::ExtremeRefTest() {
 954   // Pre: Set the first half of values to the maximum, the second half to 0.
 955   // Mask: same as above
 956   // WSrc: Set the first half of values to 0, the second half to the maximum.
 957   for (int x = 0; x < 8; ++x) {
 958     for (int y = 0; y < 8; ++y) {
 959       const int half = block_size() / 2;
 960       if (!use_high_bit_depth()) {
 961         memset(pre_, 255, half);
 962         memset(pre_ + half, 0, half + width() + height() + 1);
 963       } else {
 964         aom_memset16(CONVERT_TO_SHORTPTR(pre_), bd_mask(), half);
 965         aom_memset16(CONVERT_TO_SHORTPTR(pre_) + half, 0, half);
 966       }
 967       for (int j = 0; j < half; j++) {
 968         wsrc_[j] = bd_mask() * kMaskMax * kMaskMax;
 969         mask_[j] = 0;
 970       }
 971       for (int j = half; j < block_size(); j++) {
 972         wsrc_[j] = 0;
 973         mask_[j] = kMaskMax * kMaskMax;
 974       }
 975
 976       uint32_t sse1, sse2;
 977       uint32_t var1, var2;
 978       ASM_REGISTER_STATE_CHECK(
 979           var1 = params_.func(pre_, width() + 1, x, y, wsrc_, mask_, &sse1));
 980       var2 = obmc_subpel_variance_ref(
 981           pre_, params_.log2width, params_.log2height, x, y, wsrc_, mask_,
 982           &sse2, use_high_bit_depth(), params_.bit_depth);
 983       EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
 984       EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
 985     }
 986   }
 987 }
 988
 989 template <>
 990 void ObmcVarianceTest<ObmcSubpelVarFunc>::SpeedTest() {
 991   if (!use_high_bit_depth())
 992     for (int j = 0; j < block_size() + width() + height() + 1; j++)
 993       pre_[j] = rnd_.Rand8();
 994   else
 995     for (int j = 0; j < block_size() + width() + height() + 1; j++)
 996       CONVERT_TO_SHORTPTR(pre_)[j] = rnd_.Rand16() & bd_mask();
 997   for (int j = 0; j < block_size(); j++) {
 998     wsrc_[j] = (rnd_.Rand16() & bd_mask()) * rnd_(kMaskMax * kMaskMax + 1);
 999     mask_[j] = rnd_(kMaskMax * kMaskMax + 1);
1000   }
1001   unsigned int sse1;
1002   const int stride = width() + 1;
1003   int run_time = 1000000000 / block_size();
1004   aom_usec_timer timer;
1005
1006   aom_usec_timer_start(&timer);
1007   for (int i = 0; i < run_time; ++i) {
1008     int x = rnd_(8);
1009     int y = rnd_(8);
1010     ASM_REGISTER_STATE_CHECK(
1011         params_.func(pre_, stride, x, y, wsrc_, mask_, &sse1));
1012   }
1013   aom_usec_timer_mark(&timer);
1014
1015   const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
1016   printf("obmc_sub_pixel_variance_%dx%d_%d: %d us\n", width(), height(),
1017          params_.bit_depth, elapsed_time);
1018 }
1019
1020 typedef MainTestClass<Get4x4SseFunc> AvxSseTest;
1021 typedef MainTestClass<VarianceMxNFunc> AvxMseTest;
1022 typedef MainTestClass<VarianceMxNFunc> AvxVarianceTest;
1023 typedef SubpelVarianceTest<SubpixVarMxNFunc> AvxSubpelVarianceTest;
1024 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> AvxSubpelAvgVarianceTest;
1025 typedef SubpelVarianceTest<JntSubpixAvgVarMxNFunc> AvxJntSubpelAvgVarianceTest;
1026 typedef ObmcVarianceTest<ObmcSubpelVarFunc> AvxObmcSubpelVarianceTest;
1027
1028 TEST_P(AvxSseTest, RefSse) { RefTestSse(); }
1029 TEST_P(AvxSseTest, MaxSse) { MaxTestSse(); }
1030 TEST_P(AvxMseTest, RefMse) { RefTestMse(); }
1031 TEST_P(AvxMseTest, MaxMse) { MaxTestMse(); }
1032 TEST_P(AvxVarianceTest, Zero) { ZeroTest(); }
1033 TEST_P(AvxVarianceTest, Ref) { RefTest(); }
1034 TEST_P(AvxVarianceTest, RefStride) { RefStrideTest(); }
1035 TEST_P(AvxVarianceTest, OneQuarter) { OneQuarterTest(); }
1036 TEST_P(AvxVarianceTest, DISABLED_Speed) { SpeedTest(); }
1037 TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
1038 TEST_P(SumOfSquaresTest, Ref) { RefTest(); }
1039 TEST_P(AvxSubpelVarianceTest, Ref) { RefTest(); }
1040 TEST_P(AvxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
1041 TEST_P(AvxSubpelAvgVarianceTest, Ref) { RefTest(); }
1042 TEST_P(AvxJntSubpelAvgVarianceTest, Ref) { RefTest(); }
1043 TEST_P(AvxObmcSubpelVarianceTest, Ref) { RefTest(); }
1044 TEST_P(AvxObmcSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
1045 TEST_P(AvxObmcSubpelVarianceTest, DISABLED_Speed) { SpeedTest(); }
1046
1047 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
1048                         ::testing::Values(aom_get_mb_ss_c));
1049
1050 typedef TestParams<Get4x4SseFunc> SseParams;
1051 INSTANTIATE_TEST_CASE_P(C, AvxSseTest,
1052                         ::testing::Values(SseParams(2, 2,
1053                                                     &aom_get4x4sse_cs_c)));
1054
1055 typedef TestParams<VarianceMxNFunc> MseParams;
1056 INSTANTIATE_TEST_CASE_P(C, AvxMseTest,
1057                         ::testing::Values(MseParams(4, 4, &aom_mse16x16_c),
1058                                           MseParams(4, 3, &aom_mse16x8_c),
1059                                           MseParams(3, 4, &aom_mse8x16_c),
1060                                           MseParams(3, 3, &aom_mse8x8_c)));
1061
1062 typedef TestParams<VarianceMxNFunc> VarianceParams;
1063 INSTANTIATE_TEST_CASE_P(
1064     C, AvxVarianceTest,
1065     ::testing::Values(VarianceParams(7, 7, &aom_variance128x128_c),
1066                       VarianceParams(7, 6, &aom_variance128x64_c),
1067                       VarianceParams(6, 7, &aom_variance64x128_c),
1068                       VarianceParams(6, 6, &aom_variance64x64_c),
1069                       VarianceParams(6, 5, &aom_variance64x32_c),
1070                       VarianceParams(5, 6, &aom_variance32x64_c),
1071                       VarianceParams(5, 5, &aom_variance32x32_c),
1072                       VarianceParams(5, 4, &aom_variance32x16_c),
1073                       VarianceParams(4, 5, &aom_variance16x32_c),
1074                       VarianceParams(4, 4, &aom_variance16x16_c),
1075                       VarianceParams(4, 3, &aom_variance16x8_c),
1076                       VarianceParams(3, 4, &aom_variance8x16_c),
1077                       VarianceParams(3, 3, &aom_variance8x8_c),
1078                       VarianceParams(3, 2, &aom_variance8x4_c),
1079                       VarianceParams(2, 3, &aom_variance4x8_c),
1080                       VarianceParams(2, 2, &aom_variance4x4_c)));
1081
1082 typedef TestParams<SubpixVarMxNFunc> SubpelVarianceParams;
1083 INSTANTIATE_TEST_CASE_P(
1084     C, AvxSubpelVarianceTest,
1085     ::testing::Values(
1086         SubpelVarianceParams(7, 7, &aom_sub_pixel_variance128x128_c, 0),
1087         SubpelVarianceParams(7, 6, &aom_sub_pixel_variance128x64_c, 0),
1088         SubpelVarianceParams(6, 7, &aom_sub_pixel_variance64x128_c, 0),
1089         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_c, 0),
1090         SubpelVarianceParams(6, 5, &aom_sub_pixel_variance64x32_c, 0),
1091         SubpelVarianceParams(5, 6, &aom_sub_pixel_variance32x64_c, 0),
1092         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_c, 0),
1093         SubpelVarianceParams(5, 4, &aom_sub_pixel_variance32x16_c, 0),
1094         SubpelVarianceParams(4, 5, &aom_sub_pixel_variance16x32_c, 0),
1095         SubpelVarianceParams(4, 4, &aom_sub_pixel_variance16x16_c, 0),
1096         SubpelVarianceParams(4, 3, &aom_sub_pixel_variance16x8_c, 0),
1097         SubpelVarianceParams(3, 4, &aom_sub_pixel_variance8x16_c, 0),
1098         SubpelVarianceParams(3, 3, &aom_sub_pixel_variance8x8_c, 0),
1099         SubpelVarianceParams(3, 2, &aom_sub_pixel_variance8x4_c, 0),
1100         SubpelVarianceParams(2, 3, &aom_sub_pixel_variance4x8_c, 0),
1101         SubpelVarianceParams(2, 2, &aom_sub_pixel_variance4x4_c, 0)));
1102
1103 typedef TestParams<SubpixAvgVarMxNFunc> SubpelAvgVarianceParams;
1104 INSTANTIATE_TEST_CASE_P(
1105     C, AvxSubpelAvgVarianceTest,
1106     ::testing::Values(
1107         SubpelAvgVarianceParams(7, 7, &aom_sub_pixel_avg_variance128x128_c, 0),
1108         SubpelAvgVarianceParams(7, 6, &aom_sub_pixel_avg_variance128x64_c, 0),
1109         SubpelAvgVarianceParams(6, 7, &aom_sub_pixel_avg_variance64x128_c, 0),
1110         SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_c, 0),
1111         SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_c, 0),
1112         SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_c, 0),
1113         SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_c, 0),
1114         SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_c, 0),
1115         SubpelAvgVarianceParams(4, 5, &aom_sub_pixel_avg_variance16x32_c, 0),
1116         SubpelAvgVarianceParams(4, 4, &aom_sub_pixel_avg_variance16x16_c, 0),
1117         SubpelAvgVarianceParams(4, 3, &aom_sub_pixel_avg_variance16x8_c, 0),
1118         SubpelAvgVarianceParams(3, 4, &aom_sub_pixel_avg_variance8x16_c, 0),
1119         SubpelAvgVarianceParams(3, 3, &aom_sub_pixel_avg_variance8x8_c, 0),
1120         SubpelAvgVarianceParams(3, 2, &aom_sub_pixel_avg_variance8x4_c, 0),
1121         SubpelAvgVarianceParams(2, 3, &aom_sub_pixel_avg_variance4x8_c, 0),
1122         SubpelAvgVarianceParams(2, 2, &aom_sub_pixel_avg_variance4x4_c, 0)));
1123
1124 typedef TestParams<JntSubpixAvgVarMxNFunc> JntSubpelAvgVarianceParams;
1125 INSTANTIATE_TEST_CASE_P(
1126     C, AvxJntSubpelAvgVarianceTest,
1127     ::testing::Values(
1128         JntSubpelAvgVarianceParams(6, 6, &aom_jnt_sub_pixel_avg_variance64x64_c,
1129                                    0),
1130         JntSubpelAvgVarianceParams(6, 5, &aom_jnt_sub_pixel_avg_variance64x32_c,
1131                                    0),
1132         JntSubpelAvgVarianceParams(5, 6, &aom_jnt_sub_pixel_avg_variance32x64_c,
1133                                    0),
1134         JntSubpelAvgVarianceParams(5, 5, &aom_jnt_sub_pixel_avg_variance32x32_c,
1135                                    0),
1136         JntSubpelAvgVarianceParams(5, 4, &aom_jnt_sub_pixel_avg_variance32x16_c,
1137                                    0),
1138         JntSubpelAvgVarianceParams(4, 5, &aom_jnt_sub_pixel_avg_variance16x32_c,
1139                                    0),
1140         JntSubpelAvgVarianceParams(4, 4, &aom_jnt_sub_pixel_avg_variance16x16_c,
1141                                    0),
1142         JntSubpelAvgVarianceParams(4, 3, &aom_jnt_sub_pixel_avg_variance16x8_c,
1143                                    0),
1144         JntSubpelAvgVarianceParams(3, 4, &aom_jnt_sub_pixel_avg_variance8x16_c,
1145                                    0),
1146         JntSubpelAvgVarianceParams(3, 3, &aom_jnt_sub_pixel_avg_variance8x8_c,
1147                                    0),
1148         JntSubpelAvgVarianceParams(3, 2, &aom_jnt_sub_pixel_avg_variance8x4_c,
1149                                    0),
1150         JntSubpelAvgVarianceParams(2, 3, &aom_jnt_sub_pixel_avg_variance4x8_c,
1151                                    0),
1152         JntSubpelAvgVarianceParams(2, 2, &aom_jnt_sub_pixel_avg_variance4x4_c,
1153                                    0)));
1154
1155 INSTANTIATE_TEST_CASE_P(
1156     C, AvxObmcSubpelVarianceTest,
1157     ::testing::Values(
1158         ObmcSubpelVarianceParams(7, 7, &aom_obmc_sub_pixel_variance128x128_c,
1159                                  0),
1160         ObmcSubpelVarianceParams(7, 6, &aom_obmc_sub_pixel_variance128x64_c, 0),
1161         ObmcSubpelVarianceParams(6, 7, &aom_obmc_sub_pixel_variance64x128_c, 0),
1162         ObmcSubpelVarianceParams(6, 6, &aom_obmc_sub_pixel_variance64x64_c, 0),
1163         ObmcSubpelVarianceParams(6, 5, &aom_obmc_sub_pixel_variance64x32_c, 0),
1164         ObmcSubpelVarianceParams(5, 6, &aom_obmc_sub_pixel_variance32x64_c, 0),
1165         ObmcSubpelVarianceParams(5, 5, &aom_obmc_sub_pixel_variance32x32_c, 0),
1166         ObmcSubpelVarianceParams(5, 4, &aom_obmc_sub_pixel_variance32x16_c, 0),
1167         ObmcSubpelVarianceParams(4, 5, &aom_obmc_sub_pixel_variance16x32_c, 0),
1168         ObmcSubpelVarianceParams(4, 4, &aom_obmc_sub_pixel_variance16x16_c, 0),
1169         ObmcSubpelVarianceParams(4, 3, &aom_obmc_sub_pixel_variance16x8_c, 0),
1170         ObmcSubpelVarianceParams(3, 4, &aom_obmc_sub_pixel_variance8x16_c, 0),
1171         ObmcSubpelVarianceParams(3, 3, &aom_obmc_sub_pixel_variance8x8_c, 0),
1172         ObmcSubpelVarianceParams(3, 2, &aom_obmc_sub_pixel_variance8x4_c, 0),
1173         ObmcSubpelVarianceParams(2, 3, &aom_obmc_sub_pixel_variance4x8_c, 0),
1174         ObmcSubpelVarianceParams(2, 2, &aom_obmc_sub_pixel_variance4x4_c, 0)));
1175
1176 typedef MainTestClass<VarianceMxNFunc> AvxHBDMseTest;
1177 typedef MainTestClass<VarianceMxNFunc> AvxHBDVarianceTest;
1178 typedef SubpelVarianceTest<SubpixVarMxNFunc> AvxHBDSubpelVarianceTest;
1179 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> AvxHBDSubpelAvgVarianceTest;
1180 typedef ObmcVarianceTest<ObmcSubpelVarFunc> AvxHBDObmcSubpelVarianceTest;
1181
1182 TEST_P(AvxHBDMseTest, RefMse) { RefTestMse(); }
1183 TEST_P(AvxHBDMseTest, MaxMse) { MaxTestMse(); }
1184 TEST_P(AvxHBDVarianceTest, Zero) { ZeroTest(); }
1185 TEST_P(AvxHBDVarianceTest, Ref) { RefTest(); }
1186 TEST_P(AvxHBDVarianceTest, RefStride) { RefStrideTest(); }
1187 TEST_P(AvxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
1188 TEST_P(AvxHBDVarianceTest, DISABLED_Speed) { SpeedTest(); }
1189 TEST_P(AvxHBDSubpelVarianceTest, Ref) { RefTest(); }
1190 TEST_P(AvxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
1191 TEST_P(AvxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
1192
1193 /* TODO(debargha): This test does not support the highbd version
1194 INSTANTIATE_TEST_CASE_P(
1195     C, AvxHBDMseTest,
1196     ::testing::Values(make_tuple(4, 4, &aom_highbd_12_mse16x16_c),
1197                       make_tuple(4, 4, &aom_highbd_12_mse16x8_c),
1198                       make_tuple(4, 4, &aom_highbd_12_mse8x16_c),
1199                       make_tuple(4, 4, &aom_highbd_12_mse8x8_c),
1200                       make_tuple(4, 4, &aom_highbd_10_mse16x16_c),
1201                       make_tuple(4, 4, &aom_highbd_10_mse16x8_c),
1202                       make_tuple(4, 4, &aom_highbd_10_mse8x16_c),
1203                       make_tuple(4, 4, &aom_highbd_10_mse8x8_c),
1204                       make_tuple(4, 4, &aom_highbd_8_mse16x16_c),
1205                       make_tuple(4, 4, &aom_highbd_8_mse16x8_c),
1206                       make_tuple(4, 4, &aom_highbd_8_mse8x16_c),
1207                       make_tuple(4, 4, &aom_highbd_8_mse8x8_c)));
1208 */
1209
1210 const VarianceParams kArrayHBDVariance_c[] = {
1211   VarianceParams(7, 7, &aom_highbd_12_variance128x128_c, 12),
1212   VarianceParams(7, 6, &aom_highbd_12_variance128x64_c, 12),
1213   VarianceParams(6, 7, &aom_highbd_12_variance64x128_c, 12),
1214   VarianceParams(6, 6, &aom_highbd_12_variance64x64_c, 12),
1215   VarianceParams(6, 5, &aom_highbd_12_variance64x32_c, 12),
1216   VarianceParams(5, 6, &aom_highbd_12_variance32x64_c, 12),
1217   VarianceParams(5, 5, &aom_highbd_12_variance32x32_c, 12),
1218   VarianceParams(5, 4, &aom_highbd_12_variance32x16_c, 12),
1219   VarianceParams(4, 5, &aom_highbd_12_variance16x32_c, 12),
1220   VarianceParams(4, 4, &aom_highbd_12_variance16x16_c, 12),
1221   VarianceParams(4, 3, &aom_highbd_12_variance16x8_c, 12),
1222   VarianceParams(3, 4, &aom_highbd_12_variance8x16_c, 12),
1223   VarianceParams(3, 3, &aom_highbd_12_variance8x8_c, 12),
1224   VarianceParams(3, 2, &aom_highbd_12_variance8x4_c, 12),
1225   VarianceParams(2, 3, &aom_highbd_12_variance4x8_c, 12),
1226   VarianceParams(2, 2, &aom_highbd_12_variance4x4_c, 12),
1227   VarianceParams(7, 7, &aom_highbd_10_variance128x128_c, 10),
1228   VarianceParams(7, 6, &aom_highbd_10_variance128x64_c, 10),
1229   VarianceParams(6, 7, &aom_highbd_10_variance64x128_c, 10),
1230   VarianceParams(6, 6, &aom_highbd_10_variance64x64_c, 10),
1231   VarianceParams(6, 5, &aom_highbd_10_variance64x32_c, 10),
1232   VarianceParams(5, 6, &aom_highbd_10_variance32x64_c, 10),
1233   VarianceParams(5, 5, &aom_highbd_10_variance32x32_c, 10),
1234   VarianceParams(5, 4, &aom_highbd_10_variance32x16_c, 10),
1235   VarianceParams(4, 5, &aom_highbd_10_variance16x32_c, 10),
1236   VarianceParams(4, 4, &aom_highbd_10_variance16x16_c, 10),
1237   VarianceParams(4, 3, &aom_highbd_10_variance16x8_c, 10),
1238   VarianceParams(3, 4, &aom_highbd_10_variance8x16_c, 10),
1239   VarianceParams(3, 3, &aom_highbd_10_variance8x8_c, 10),
1240   VarianceParams(3, 2, &aom_highbd_10_variance8x4_c, 10),
1241   VarianceParams(2, 3, &aom_highbd_10_variance4x8_c, 10),
1242   VarianceParams(2, 2, &aom_highbd_10_variance4x4_c, 10),
1243   VarianceParams(7, 7, &aom_highbd_8_variance128x128_c, 8),
1244   VarianceParams(7, 6, &aom_highbd_8_variance128x64_c, 8),
1245   VarianceParams(6, 7, &aom_highbd_8_variance64x128_c, 8),
1246   VarianceParams(6, 6, &aom_highbd_8_variance64x64_c, 8),
1247   VarianceParams(6, 5, &aom_highbd_8_variance64x32_c, 8),
1248   VarianceParams(5, 6, &aom_highbd_8_variance32x64_c, 8),
1249   VarianceParams(5, 5, &aom_highbd_8_variance32x32_c, 8),
1250   VarianceParams(5, 4, &aom_highbd_8_variance32x16_c, 8),
1251   VarianceParams(4, 5, &aom_highbd_8_variance16x32_c, 8),
1252   VarianceParams(4, 4, &aom_highbd_8_variance16x16_c, 8),
1253   VarianceParams(4, 3, &aom_highbd_8_variance16x8_c, 8),
1254   VarianceParams(3, 4, &aom_highbd_8_variance8x16_c, 8),
1255   VarianceParams(3, 3, &aom_highbd_8_variance8x8_c, 8),
1256   VarianceParams(3, 2, &aom_highbd_8_variance8x4_c, 8),
1257   VarianceParams(2, 3, &aom_highbd_8_variance4x8_c, 8),
1258   VarianceParams(2, 2, &aom_highbd_8_variance4x4_c, 8)
1259 };
1260 INSTANTIATE_TEST_CASE_P(C, AvxHBDVarianceTest,
1261                         ::testing::ValuesIn(kArrayHBDVariance_c));
1262
1263 #if HAVE_SSE4_1
1264 INSTANTIATE_TEST_CASE_P(
1265     SSE4_1, AvxHBDVarianceTest,
1266     ::testing::Values(
1267         VarianceParams(2, 2, &aom_highbd_8_variance4x4_sse4_1, 8),
1268         VarianceParams(2, 2, &aom_highbd_10_variance4x4_sse4_1, 10),
1269         VarianceParams(2, 2, &aom_highbd_12_variance4x4_sse4_1, 12)));
1270 #endif  // HAVE_SSE4_1
1271
1272 const SubpelVarianceParams kArrayHBDSubpelVariance_c[] = {
1273   SubpelVarianceParams(7, 7, &aom_highbd_8_sub_pixel_variance128x128_c, 8),
1274   SubpelVarianceParams(7, 6, &aom_highbd_8_sub_pixel_variance128x64_c, 8),
1275   SubpelVarianceParams(6, 7, &aom_highbd_8_sub_pixel_variance64x128_c, 8),
1276   SubpelVarianceParams(6, 6, &aom_highbd_8_sub_pixel_variance64x64_c, 8),
1277   SubpelVarianceParams(6, 5, &aom_highbd_8_sub_pixel_variance64x32_c, 8),
1278   SubpelVarianceParams(5, 6, &aom_highbd_8_sub_pixel_variance32x64_c, 8),
1279   SubpelVarianceParams(5, 5, &aom_highbd_8_sub_pixel_variance32x32_c, 8),
1280   SubpelVarianceParams(5, 4, &aom_highbd_8_sub_pixel_variance32x16_c, 8),
1281   SubpelVarianceParams(4, 5, &aom_highbd_8_sub_pixel_variance16x32_c, 8),
1282   SubpelVarianceParams(4, 4, &aom_highbd_8_sub_pixel_variance16x16_c, 8),
1283   SubpelVarianceParams(4, 3, &aom_highbd_8_sub_pixel_variance16x8_c, 8),
1284   SubpelVarianceParams(3, 4, &aom_highbd_8_sub_pixel_variance8x16_c, 8),
1285   SubpelVarianceParams(3, 3, &aom_highbd_8_sub_pixel_variance8x8_c, 8),
1286   SubpelVarianceParams(3, 2, &aom_highbd_8_sub_pixel_variance8x4_c, 8),
1287   SubpelVarianceParams(2, 3, &aom_highbd_8_sub_pixel_variance4x8_c, 8),
1288   SubpelVarianceParams(2, 2, &aom_highbd_8_sub_pixel_variance4x4_c, 8),
1289   SubpelVarianceParams(7, 7, &aom_highbd_10_sub_pixel_variance128x128_c, 10),
1290   SubpelVarianceParams(7, 6, &aom_highbd_10_sub_pixel_variance128x64_c, 10),
1291   SubpelVarianceParams(6, 7, &aom_highbd_10_sub_pixel_variance64x128_c, 10),
1292   SubpelVarianceParams(6, 6, &aom_highbd_10_sub_pixel_variance64x64_c, 10),
1293   SubpelVarianceParams(6, 5, &aom_highbd_10_sub_pixel_variance64x32_c, 10),
1294   SubpelVarianceParams(5, 6, &aom_highbd_10_sub_pixel_variance32x64_c, 10),
1295   SubpelVarianceParams(5, 5, &aom_highbd_10_sub_pixel_variance32x32_c, 10),
1296   SubpelVarianceParams(5, 4, &aom_highbd_10_sub_pixel_variance32x16_c, 10),
1297   SubpelVarianceParams(4, 5, &aom_highbd_10_sub_pixel_variance16x32_c, 10),
1298   SubpelVarianceParams(4, 4, &aom_highbd_10_sub_pixel_variance16x16_c, 10),
1299   SubpelVarianceParams(4, 3, &aom_highbd_10_sub_pixel_variance16x8_c, 10),
1300   SubpelVarianceParams(3, 4, &aom_highbd_10_sub_pixel_variance8x16_c, 10),
1301   SubpelVarianceParams(3, 3, &aom_highbd_10_sub_pixel_variance8x8_c, 10),
1302   SubpelVarianceParams(3, 2, &aom_highbd_10_sub_pixel_variance8x4_c, 10),
1303   SubpelVarianceParams(2, 3, &aom_highbd_10_sub_pixel_variance4x8_c, 10),
1304   SubpelVarianceParams(2, 2, &aom_highbd_10_sub_pixel_variance4x4_c, 10),
1305   SubpelVarianceParams(7, 7, &aom_highbd_12_sub_pixel_variance128x128_c, 12),
1306   SubpelVarianceParams(7, 6, &aom_highbd_12_sub_pixel_variance128x64_c, 12),
1307   SubpelVarianceParams(6, 7, &aom_highbd_12_sub_pixel_variance64x128_c, 12),
1308   SubpelVarianceParams(6, 6, &aom_highbd_12_sub_pixel_variance64x64_c, 12),
1309   SubpelVarianceParams(6, 5, &aom_highbd_12_sub_pixel_variance64x32_c, 12),
1310   SubpelVarianceParams(5, 6, &aom_highbd_12_sub_pixel_variance32x64_c, 12),
1311   SubpelVarianceParams(5, 5, &aom_highbd_12_sub_pixel_variance32x32_c, 12),
1312   SubpelVarianceParams(5, 4, &aom_highbd_12_sub_pixel_variance32x16_c, 12),
1313   SubpelVarianceParams(4, 5, &aom_highbd_12_sub_pixel_variance16x32_c, 12),
1314   SubpelVarianceParams(4, 4, &aom_highbd_12_sub_pixel_variance16x16_c, 12),
1315   SubpelVarianceParams(4, 3, &aom_highbd_12_sub_pixel_variance16x8_c, 12),
1316   SubpelVarianceParams(3, 4, &aom_highbd_12_sub_pixel_variance8x16_c, 12),
1317   SubpelVarianceParams(3, 3, &aom_highbd_12_sub_pixel_variance8x8_c, 12),
1318   SubpelVarianceParams(3, 2, &aom_highbd_12_sub_pixel_variance8x4_c, 12),
1319   SubpelVarianceParams(2, 3, &aom_highbd_12_sub_pixel_variance4x8_c, 12),
1320   SubpelVarianceParams(2, 2, &aom_highbd_12_sub_pixel_variance4x4_c, 12),
1321 };
1322 INSTANTIATE_TEST_CASE_P(C, AvxHBDSubpelVarianceTest,
1323                         ::testing::ValuesIn(kArrayHBDSubpelVariance_c));
1324
1325 const SubpelAvgVarianceParams kArrayHBDSubpelAvgVariance_c[] = {
1326   SubpelAvgVarianceParams(7, 7, &aom_highbd_8_sub_pixel_avg_variance128x128_c,
1327                           8),
1328   SubpelAvgVarianceParams(7, 6, &aom_highbd_8_sub_pixel_avg_variance128x64_c,
1329                           8),
1330   SubpelAvgVarianceParams(6, 7, &aom_highbd_8_sub_pixel_avg_variance64x128_c,
1331                           8),
1332   SubpelAvgVarianceParams(6, 6, &aom_highbd_8_sub_pixel_avg_variance64x64_c, 8),
1333   SubpelAvgVarianceParams(6, 5, &aom_highbd_8_sub_pixel_avg_variance64x32_c, 8),
1334   SubpelAvgVarianceParams(5, 6, &aom_highbd_8_sub_pixel_avg_variance32x64_c, 8),
1335   SubpelAvgVarianceParams(5, 5, &aom_highbd_8_sub_pixel_avg_variance32x32_c, 8),
1336   SubpelAvgVarianceParams(5, 4, &aom_highbd_8_sub_pixel_avg_variance32x16_c, 8),
1337   SubpelAvgVarianceParams(4, 5, &aom_highbd_8_sub_pixel_avg_variance16x32_c, 8),
1338   SubpelAvgVarianceParams(4, 4, &aom_highbd_8_sub_pixel_avg_variance16x16_c, 8),
1339   SubpelAvgVarianceParams(4, 3, &aom_highbd_8_sub_pixel_avg_variance16x8_c, 8),
1340   SubpelAvgVarianceParams(3, 4, &aom_highbd_8_sub_pixel_avg_variance8x16_c, 8),
1341   SubpelAvgVarianceParams(3, 3, &aom_highbd_8_sub_pixel_avg_variance8x8_c, 8),
1342   SubpelAvgVarianceParams(3, 2, &aom_highbd_8_sub_pixel_avg_variance8x4_c, 8),
1343   SubpelAvgVarianceParams(2, 3, &aom_highbd_8_sub_pixel_avg_variance4x8_c, 8),
1344   SubpelAvgVarianceParams(2, 2, &aom_highbd_8_sub_pixel_avg_variance4x4_c, 8),
1345   SubpelAvgVarianceParams(7, 7, &aom_highbd_10_sub_pixel_avg_variance128x128_c,
1346                           10),
1347   SubpelAvgVarianceParams(7, 6, &aom_highbd_10_sub_pixel_avg_variance128x64_c,
1348                           10),
1349   SubpelAvgVarianceParams(6, 7, &aom_highbd_10_sub_pixel_avg_variance64x128_c,
1350                           10),
1351   SubpelAvgVarianceParams(6, 6, &aom_highbd_10_sub_pixel_avg_variance64x64_c,
1352                           10),
1353   SubpelAvgVarianceParams(6, 5, &aom_highbd_10_sub_pixel_avg_variance64x32_c,
1354                           10),
1355   SubpelAvgVarianceParams(5, 6, &aom_highbd_10_sub_pixel_avg_variance32x64_c,
1356                           10),
1357   SubpelAvgVarianceParams(5, 5, &aom_highbd_10_sub_pixel_avg_variance32x32_c,
1358                           10),
1359   SubpelAvgVarianceParams(5, 4, &aom_highbd_10_sub_pixel_avg_variance32x16_c,
1360                           10),
1361   SubpelAvgVarianceParams(4, 5, &aom_highbd_10_sub_pixel_avg_variance16x32_c,
1362                           10),
1363   SubpelAvgVarianceParams(4, 4, &aom_highbd_10_sub_pixel_avg_variance16x16_c,
1364                           10),
1365   SubpelAvgVarianceParams(4, 3, &aom_highbd_10_sub_pixel_avg_variance16x8_c,
1366                           10),
1367   SubpelAvgVarianceParams(3, 4, &aom_highbd_10_sub_pixel_avg_variance8x16_c,
1368                           10),
1369   SubpelAvgVarianceParams(3, 3, &aom_highbd_10_sub_pixel_avg_variance8x8_c, 10),
1370   SubpelAvgVarianceParams(3, 2, &aom_highbd_10_sub_pixel_avg_variance8x4_c, 10),
1371   SubpelAvgVarianceParams(2, 3, &aom_highbd_10_sub_pixel_avg_variance4x8_c, 10),
1372   SubpelAvgVarianceParams(2, 2, &aom_highbd_10_sub_pixel_avg_variance4x4_c, 10),
1373   SubpelAvgVarianceParams(7, 7, &aom_highbd_12_sub_pixel_avg_variance128x128_c,
1374                           12),
1375   SubpelAvgVarianceParams(7, 6, &aom_highbd_12_sub_pixel_avg_variance128x64_c,
1376                           12),
1377   SubpelAvgVarianceParams(6, 7, &aom_highbd_12_sub_pixel_avg_variance64x128_c,
1378                           12),
1379   SubpelAvgVarianceParams(6, 6, &aom_highbd_12_sub_pixel_avg_variance64x64_c,
1380                           12),
1381   SubpelAvgVarianceParams(6, 5, &aom_highbd_12_sub_pixel_avg_variance64x32_c,
1382                           12),
1383   SubpelAvgVarianceParams(5, 6, &aom_highbd_12_sub_pixel_avg_variance32x64_c,
1384                           12),
1385   SubpelAvgVarianceParams(5, 5, &aom_highbd_12_sub_pixel_avg_variance32x32_c,
1386                           12),
1387   SubpelAvgVarianceParams(5, 4, &aom_highbd_12_sub_pixel_avg_variance32x16_c,
1388                           12),
1389   SubpelAvgVarianceParams(4, 5, &aom_highbd_12_sub_pixel_avg_variance16x32_c,
1390                           12),
1391   SubpelAvgVarianceParams(4, 4, &aom_highbd_12_sub_pixel_avg_variance16x16_c,
1392                           12),
1393   SubpelAvgVarianceParams(4, 3, &aom_highbd_12_sub_pixel_avg_variance16x8_c,
1394                           12),
1395   SubpelAvgVarianceParams(3, 4, &aom_highbd_12_sub_pixel_avg_variance8x16_c,
1396                           12),
1397   SubpelAvgVarianceParams(3, 3, &aom_highbd_12_sub_pixel_avg_variance8x8_c, 12),
1398   SubpelAvgVarianceParams(3, 2, &aom_highbd_12_sub_pixel_avg_variance8x4_c, 12),
1399   SubpelAvgVarianceParams(2, 3, &aom_highbd_12_sub_pixel_avg_variance4x8_c, 12),
1400   SubpelAvgVarianceParams(2, 2, &aom_highbd_12_sub_pixel_avg_variance4x4_c, 12)
1401 };
1402 INSTANTIATE_TEST_CASE_P(C, AvxHBDSubpelAvgVarianceTest,
1403                         ::testing::ValuesIn(kArrayHBDSubpelAvgVariance_c));
1404
1405 const ObmcSubpelVarianceParams kArrayHBDObmcSubpelVariance_c[] = {
1406   ObmcSubpelVarianceParams(7, 7, &aom_highbd_obmc_sub_pixel_variance128x128_c,
1407                            8),
1408   ObmcSubpelVarianceParams(7, 6, &aom_highbd_obmc_sub_pixel_variance128x64_c,
1409                            8),
1410   ObmcSubpelVarianceParams(6, 7, &aom_highbd_obmc_sub_pixel_variance64x128_c,
1411                            8),
1412   ObmcSubpelVarianceParams(6, 6, &aom_highbd_obmc_sub_pixel_variance64x64_c, 8),
1413   ObmcSubpelVarianceParams(6, 5, &aom_highbd_obmc_sub_pixel_variance64x32_c, 8),
1414   ObmcSubpelVarianceParams(5, 6, &aom_highbd_obmc_sub_pixel_variance32x64_c, 8),
1415   ObmcSubpelVarianceParams(5, 5, &aom_highbd_obmc_sub_pixel_variance32x32_c, 8),
1416   ObmcSubpelVarianceParams(5, 4, &aom_highbd_obmc_sub_pixel_variance32x16_c, 8),
1417   ObmcSubpelVarianceParams(4, 5, &aom_highbd_obmc_sub_pixel_variance16x32_c, 8),
1418   ObmcSubpelVarianceParams(4, 4, &aom_highbd_obmc_sub_pixel_variance16x16_c, 8),
1419   ObmcSubpelVarianceParams(4, 3, &aom_highbd_obmc_sub_pixel_variance16x8_c, 8),
1420   ObmcSubpelVarianceParams(3, 4, &aom_highbd_obmc_sub_pixel_variance8x16_c, 8),
1421   ObmcSubpelVarianceParams(3, 3, &aom_highbd_obmc_sub_pixel_variance8x8_c, 8),
1422   ObmcSubpelVarianceParams(3, 2, &aom_highbd_obmc_sub_pixel_variance8x4_c, 8),
1423   ObmcSubpelVarianceParams(2, 3, &aom_highbd_obmc_sub_pixel_variance4x8_c, 8),
1424   ObmcSubpelVarianceParams(2, 2, &aom_highbd_obmc_sub_pixel_variance4x4_c, 8),
1425   ObmcSubpelVarianceParams(7, 7,
1426                            &aom_highbd_10_obmc_sub_pixel_variance128x128_c, 10),
1427   ObmcSubpelVarianceParams(7, 6, &aom_highbd_10_obmc_sub_pixel_variance128x64_c,
1428                            10),
1429   ObmcSubpelVarianceParams(6, 7, &aom_highbd_10_obmc_sub_pixel_variance64x128_c,
1430                            10),
1431   ObmcSubpelVarianceParams(6, 6, &aom_highbd_10_obmc_sub_pixel_variance64x64_c,
1432                            10),
1433   ObmcSubpelVarianceParams(6, 5, &aom_highbd_10_obmc_sub_pixel_variance64x32_c,
1434                            10),
1435   ObmcSubpelVarianceParams(5, 6, &aom_highbd_10_obmc_sub_pixel_variance32x64_c,
1436                            10),
1437   ObmcSubpelVarianceParams(5, 5, &aom_highbd_10_obmc_sub_pixel_variance32x32_c,
1438                            10),
1439   ObmcSubpelVarianceParams(5, 4, &aom_highbd_10_obmc_sub_pixel_variance32x16_c,
1440                            10),
1441   ObmcSubpelVarianceParams(4, 5, &aom_highbd_10_obmc_sub_pixel_variance16x32_c,
1442                            10),
1443   ObmcSubpelVarianceParams(4, 4, &aom_highbd_10_obmc_sub_pixel_variance16x16_c,
1444                            10),
1445   ObmcSubpelVarianceParams(4, 3, &aom_highbd_10_obmc_sub_pixel_variance16x8_c,
1446                            10),
1447   ObmcSubpelVarianceParams(3, 4, &aom_highbd_10_obmc_sub_pixel_variance8x16_c,
1448                            10),
1449   ObmcSubpelVarianceParams(3, 3, &aom_highbd_10_obmc_sub_pixel_variance8x8_c,
1450                            10),
1451   ObmcSubpelVarianceParams(3, 2, &aom_highbd_10_obmc_sub_pixel_variance8x4_c,
1452                            10),
1453   ObmcSubpelVarianceParams(2, 3, &aom_highbd_10_obmc_sub_pixel_variance4x8_c,
1454                            10),
1455   ObmcSubpelVarianceParams(2, 2, &aom_highbd_10_obmc_sub_pixel_variance4x4_c,
1456                            10),
1457   ObmcSubpelVarianceParams(7, 7,
1458                            &aom_highbd_12_obmc_sub_pixel_variance128x128_c, 12),
1459   ObmcSubpelVarianceParams(7, 6, &aom_highbd_12_obmc_sub_pixel_variance128x64_c,
1460                            12),
1461   ObmcSubpelVarianceParams(6, 7, &aom_highbd_12_obmc_sub_pixel_variance64x128_c,
1462                            12),
1463   ObmcSubpelVarianceParams(6, 6, &aom_highbd_12_obmc_sub_pixel_variance64x64_c,
1464                            12),
1465   ObmcSubpelVarianceParams(6, 5, &aom_highbd_12_obmc_sub_pixel_variance64x32_c,
1466                            12),
1467   ObmcSubpelVarianceParams(5, 6, &aom_highbd_12_obmc_sub_pixel_variance32x64_c,
1468                            12),
1469   ObmcSubpelVarianceParams(5, 5, &aom_highbd_12_obmc_sub_pixel_variance32x32_c,
1470                            12),
1471   ObmcSubpelVarianceParams(5, 4, &aom_highbd_12_obmc_sub_pixel_variance32x16_c,
1472                            12),
1473   ObmcSubpelVarianceParams(4, 5, &aom_highbd_12_obmc_sub_pixel_variance16x32_c,
1474                            12),
1475   ObmcSubpelVarianceParams(4, 4, &aom_highbd_12_obmc_sub_pixel_variance16x16_c,
1476                            12),
1477   ObmcSubpelVarianceParams(4, 3, &aom_highbd_12_obmc_sub_pixel_variance16x8_c,
1478                            12),
1479   ObmcSubpelVarianceParams(3, 4, &aom_highbd_12_obmc_sub_pixel_variance8x16_c,
1480                            12),
1481   ObmcSubpelVarianceParams(3, 3, &aom_highbd_12_obmc_sub_pixel_variance8x8_c,
1482                            12),
1483   ObmcSubpelVarianceParams(3, 2, &aom_highbd_12_obmc_sub_pixel_variance8x4_c,
1484                            12),
1485   ObmcSubpelVarianceParams(2, 3, &aom_highbd_12_obmc_sub_pixel_variance4x8_c,
1486                            12),
1487   ObmcSubpelVarianceParams(2, 2, &aom_highbd_12_obmc_sub_pixel_variance4x4_c,
1488                            12)
1489 };
1490 INSTANTIATE_TEST_CASE_P(C, AvxHBDObmcSubpelVarianceTest,
1491                         ::testing::ValuesIn(kArrayHBDObmcSubpelVariance_c));
1492
1493 #if HAVE_SSE2
1494 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
1495                         ::testing::Values(aom_get_mb_ss_sse2));
1496
1497 INSTANTIATE_TEST_CASE_P(SSE2, AvxMseTest,
1498                         ::testing::Values(MseParams(4, 4, &aom_mse16x16_sse2),
1499                                           MseParams(4, 3, &aom_mse16x8_sse2),
1500                                           MseParams(3, 4, &aom_mse8x16_sse2),
1501                                           MseParams(3, 3, &aom_mse8x8_sse2)));
1502
1503 INSTANTIATE_TEST_CASE_P(
1504     SSE2, AvxVarianceTest,
1505     ::testing::Values(VarianceParams(7, 7, &aom_variance128x128_sse2),
1506                       VarianceParams(7, 6, &aom_variance128x64_sse2),
1507                       VarianceParams(6, 7, &aom_variance64x128_sse2),
1508                       VarianceParams(6, 6, &aom_variance64x64_sse2),
1509                       VarianceParams(6, 5, &aom_variance64x32_sse2),
1510                       VarianceParams(6, 4, &aom_variance64x16_sse2),
1511                       VarianceParams(5, 6, &aom_variance32x64_sse2),
1512                       VarianceParams(5, 5, &aom_variance32x32_sse2),
1513                       VarianceParams(5, 4, &aom_variance32x16_sse2),
1514                       VarianceParams(5, 3, &aom_variance32x8_sse2),
1515                       VarianceParams(4, 6, &aom_variance16x64_sse2),
1516                       VarianceParams(4, 5, &aom_variance16x32_sse2),
1517                       VarianceParams(4, 4, &aom_variance16x16_sse2),
1518                       VarianceParams(4, 3, &aom_variance16x8_sse2),
1519                       VarianceParams(4, 2, &aom_variance16x4_sse2),
1520                       VarianceParams(3, 5, &aom_variance8x32_sse2),
1521                       VarianceParams(3, 4, &aom_variance8x16_sse2),
1522                       VarianceParams(3, 3, &aom_variance8x8_sse2),
1523                       VarianceParams(3, 2, &aom_variance8x4_sse2),
1524                       VarianceParams(2, 4, &aom_variance4x16_sse2),
1525                       VarianceParams(2, 3, &aom_variance4x8_sse2),
1526                       VarianceParams(2, 2, &aom_variance4x4_sse2)));
1527
1528 INSTANTIATE_TEST_CASE_P(
1529     SSE2, AvxSubpelVarianceTest,
1530     ::testing::Values(
1531         SubpelVarianceParams(7, 7, &aom_sub_pixel_variance128x128_sse2, 0),
1532         SubpelVarianceParams(7, 6, &aom_sub_pixel_variance128x64_sse2, 0),
1533         SubpelVarianceParams(6, 7, &aom_sub_pixel_variance64x128_sse2, 0),
1534         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_sse2, 0),
1535         SubpelVarianceParams(6, 5, &aom_sub_pixel_variance64x32_sse2, 0),
1536         SubpelVarianceParams(5, 6, &aom_sub_pixel_variance32x64_sse2, 0),
1537         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_sse2, 0),
1538         SubpelVarianceParams(5, 4, &aom_sub_pixel_variance32x16_sse2, 0),
1539         SubpelVarianceParams(4, 5, &aom_sub_pixel_variance16x32_sse2, 0),
1540         SubpelVarianceParams(4, 4, &aom_sub_pixel_variance16x16_sse2, 0),
1541         SubpelVarianceParams(4, 3, &aom_sub_pixel_variance16x8_sse2, 0),
1542         SubpelVarianceParams(3, 4, &aom_sub_pixel_variance8x16_sse2, 0),
1543         SubpelVarianceParams(3, 3, &aom_sub_pixel_variance8x8_sse2, 0),
1544         SubpelVarianceParams(3, 2, &aom_sub_pixel_variance8x4_sse2, 0),
1545         SubpelVarianceParams(2, 3, &aom_sub_pixel_variance4x8_sse2, 0),
1546         SubpelVarianceParams(2, 2, &aom_sub_pixel_variance4x4_sse2, 0)));
1547
1548 INSTANTIATE_TEST_CASE_P(
1549     SSE2, AvxSubpelAvgVarianceTest,
1550     ::testing::Values(
1551         SubpelAvgVarianceParams(7, 7, &aom_sub_pixel_avg_variance128x128_sse2,
1552                                 0),
1553         SubpelAvgVarianceParams(7, 6, &aom_sub_pixel_avg_variance128x64_sse2,
1554                                 0),
1555         SubpelAvgVarianceParams(6, 7, &aom_sub_pixel_avg_variance64x128_sse2,
1556                                 0),
1557         SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_sse2, 0),
1558         SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_sse2, 0),
1559         SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_sse2, 0),
1560         SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_sse2, 0),
1561         SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_sse2, 0),
1562         SubpelAvgVarianceParams(4, 5, &aom_sub_pixel_avg_variance16x32_sse2, 0),
1563         SubpelAvgVarianceParams(4, 4, &aom_sub_pixel_avg_variance16x16_sse2, 0),
1564         SubpelAvgVarianceParams(4, 3, &aom_sub_pixel_avg_variance16x8_sse2, 0),
1565         SubpelAvgVarianceParams(3, 4, &aom_sub_pixel_avg_variance8x16_sse2, 0),
1566         SubpelAvgVarianceParams(3, 3, &aom_sub_pixel_avg_variance8x8_sse2, 0),
1567         SubpelAvgVarianceParams(3, 2, &aom_sub_pixel_avg_variance8x4_sse2, 0),
1568         SubpelAvgVarianceParams(2, 3, &aom_sub_pixel_avg_variance4x8_sse2, 0),
1569         SubpelAvgVarianceParams(2, 2, &aom_sub_pixel_avg_variance4x4_sse2, 0)));
1570
1571 #if HAVE_SSE4_1
1572 INSTANTIATE_TEST_CASE_P(
1573     SSE4_1, AvxSubpelVarianceTest,
1574     ::testing::Values(
1575         SubpelVarianceParams(2, 2, &aom_highbd_8_sub_pixel_variance4x4_sse4_1,
1576                              8),
1577         SubpelVarianceParams(2, 2, &aom_highbd_10_sub_pixel_variance4x4_sse4_1,
1578                              10),
1579         SubpelVarianceParams(2, 2, &aom_highbd_12_sub_pixel_variance4x4_sse4_1,
1580                              12)));
1581
1582 INSTANTIATE_TEST_CASE_P(
1583     SSE4_1, AvxSubpelAvgVarianceTest,
1584     ::testing::Values(
1585         SubpelAvgVarianceParams(2, 2,
1586                                 &aom_highbd_8_sub_pixel_avg_variance4x4_sse4_1,
1587                                 8),
1588         SubpelAvgVarianceParams(2, 2,
1589                                 &aom_highbd_10_sub_pixel_avg_variance4x4_sse4_1,
1590                                 10),
1591         SubpelAvgVarianceParams(2, 2,
1592                                 &aom_highbd_12_sub_pixel_avg_variance4x4_sse4_1,
1593                                 12)));
1594 #endif  // HAVE_SSE4_1
1595
1596 /* TODO(debargha): This test does not support the highbd version
1597 INSTANTIATE_TEST_CASE_P(
1598     SSE2, AvxHBDMseTest,
1599     ::testing::Values(MseParams(4, 4, &aom_highbd_12_mse16x16_sse2),
1600                       MseParams(4, 3, &aom_highbd_12_mse16x8_sse2),
1601                       MseParams(3, 4, &aom_highbd_12_mse8x16_sse2),
1602                       MseParams(3, 3, &aom_highbd_12_mse8x8_sse2),
1603                       MseParams(4, 4, &aom_highbd_10_mse16x16_sse2),
1604                       MseParams(4, 3, &aom_highbd_10_mse16x8_sse2),
1605                       MseParams(3, 4, &aom_highbd_10_mse8x16_sse2),
1606                       MseParams(3, 3, &aom_highbd_10_mse8x8_sse2),
1607                       MseParams(4, 4, &aom_highbd_8_mse16x16_sse2),
1608                       MseParams(4, 3, &aom_highbd_8_mse16x8_sse2),
1609                       MseParams(3, 4, &aom_highbd_8_mse8x16_sse2),
1610                       MseParams(3, 3, &aom_highbd_8_mse8x8_sse2)));
1611 */
1612
1613 const VarianceParams kArrayHBDVariance_sse2[] = {
1614   VarianceParams(7, 7, &aom_highbd_12_variance128x128_sse2, 12),
1615   VarianceParams(7, 6, &aom_highbd_12_variance128x64_sse2, 12),
1616   VarianceParams(6, 7, &aom_highbd_12_variance64x128_sse2, 12),
1617   VarianceParams(6, 6, &aom_highbd_12_variance64x64_sse2, 12),
1618   VarianceParams(6, 5, &aom_highbd_12_variance64x32_sse2, 12),
1619   VarianceParams(5, 6, &aom_highbd_12_variance32x64_sse2, 12),
1620   VarianceParams(5, 5, &aom_highbd_12_variance32x32_sse2, 12),
1621   VarianceParams(5, 4, &aom_highbd_12_variance32x16_sse2, 12),
1622   VarianceParams(4, 5, &aom_highbd_12_variance16x32_sse2, 12),
1623   VarianceParams(4, 4, &aom_highbd_12_variance16x16_sse2, 12),
1624   VarianceParams(4, 3, &aom_highbd_12_variance16x8_sse2, 12),
1625   VarianceParams(3, 4, &aom_highbd_12_variance8x16_sse2, 12),
1626   VarianceParams(3, 3, &aom_highbd_12_variance8x8_sse2, 12),
1627   VarianceParams(7, 7, &aom_highbd_10_variance128x128_sse2, 10),
1628   VarianceParams(7, 6, &aom_highbd_10_variance128x64_sse2, 10),
1629   VarianceParams(6, 7, &aom_highbd_10_variance64x128_sse2, 10),
1630   VarianceParams(6, 6, &aom_highbd_10_variance64x64_sse2, 10),
1631   VarianceParams(6, 5, &aom_highbd_10_variance64x32_sse2, 10),
1632   VarianceParams(5, 6, &aom_highbd_10_variance32x64_sse2, 10),
1633   VarianceParams(5, 5, &aom_highbd_10_variance32x32_sse2, 10),
1634   VarianceParams(5, 4, &aom_highbd_10_variance32x16_sse2, 10),
1635   VarianceParams(4, 5, &aom_highbd_10_variance16x32_sse2, 10),
1636   VarianceParams(4, 4, &aom_highbd_10_variance16x16_sse2, 10),
1637   VarianceParams(4, 3, &aom_highbd_10_variance16x8_sse2, 10),
1638   VarianceParams(3, 4, &aom_highbd_10_variance8x16_sse2, 10),
1639   VarianceParams(3, 3, &aom_highbd_10_variance8x8_sse2, 10),
1640   VarianceParams(7, 7, &aom_highbd_8_variance128x128_sse2, 8),
1641   VarianceParams(7, 6, &aom_highbd_8_variance128x64_sse2, 8),
1642   VarianceParams(6, 7, &aom_highbd_8_variance64x128_sse2, 8),
1643   VarianceParams(6, 6, &aom_highbd_8_variance64x64_sse2, 8),
1644   VarianceParams(6, 5, &aom_highbd_8_variance64x32_sse2, 8),
1645   VarianceParams(5, 6, &aom_highbd_8_variance32x64_sse2, 8),
1646   VarianceParams(5, 5, &aom_highbd_8_variance32x32_sse2, 8),
1647   VarianceParams(5, 4, &aom_highbd_8_variance32x16_sse2, 8),
1648   VarianceParams(4, 5, &aom_highbd_8_variance16x32_sse2, 8),
1649   VarianceParams(4, 4, &aom_highbd_8_variance16x16_sse2, 8),
1650   VarianceParams(4, 3, &aom_highbd_8_variance16x8_sse2, 8),
1651   VarianceParams(3, 4, &aom_highbd_8_variance8x16_sse2, 8),
1652   VarianceParams(3, 3, &aom_highbd_8_variance8x8_sse2, 8)
1653 };
1654 INSTANTIATE_TEST_CASE_P(SSE2, AvxHBDVarianceTest,
1655                         ::testing::ValuesIn(kArrayHBDVariance_sse2));
1656
1657 #if HAVE_AVX2
1658
1659 const VarianceParams kArrayHBDVariance_avx2[] = {
1660   VarianceParams(7, 7, &aom_highbd_10_variance128x128_avx2, 10),
1661   VarianceParams(7, 6, &aom_highbd_10_variance128x64_avx2, 10),
1662   VarianceParams(6, 7, &aom_highbd_10_variance64x128_avx2, 10),
1663   VarianceParams(6, 6, &aom_highbd_10_variance64x64_avx2, 10),
1664   VarianceParams(6, 5, &aom_highbd_10_variance64x32_avx2, 10),
1665   VarianceParams(5, 6, &aom_highbd_10_variance32x64_avx2, 10),
1666   VarianceParams(5, 5, &aom_highbd_10_variance32x32_avx2, 10),
1667   VarianceParams(5, 4, &aom_highbd_10_variance32x16_avx2, 10),
1668   VarianceParams(4, 5, &aom_highbd_10_variance16x32_avx2, 10),
1669   VarianceParams(4, 4, &aom_highbd_10_variance16x16_avx2, 10),
1670   VarianceParams(4, 3, &aom_highbd_10_variance16x8_avx2, 10),
1671   VarianceParams(3, 4, &aom_highbd_10_variance8x16_avx2, 10),
1672   VarianceParams(3, 3, &aom_highbd_10_variance8x8_avx2, 10)
1673 };
1674
1675 INSTANTIATE_TEST_CASE_P(AVX2, AvxHBDVarianceTest,
1676                         ::testing::ValuesIn(kArrayHBDVariance_avx2));
1677 #endif  // HAVE_AVX2
1678
1679 const SubpelVarianceParams kArrayHBDSubpelVariance_sse2[] = {
1680   SubpelVarianceParams(6, 6, &aom_highbd_12_sub_pixel_variance64x64_sse2, 12),
1681   SubpelVarianceParams(6, 5, &aom_highbd_12_sub_pixel_variance64x32_sse2, 12),
1682   SubpelVarianceParams(5, 6, &aom_highbd_12_sub_pixel_variance32x64_sse2, 12),
1683   SubpelVarianceParams(5, 5, &aom_highbd_12_sub_pixel_variance32x32_sse2, 12),
1684   SubpelVarianceParams(5, 4, &aom_highbd_12_sub_pixel_variance32x16_sse2, 12),
1685   SubpelVarianceParams(4, 5, &aom_highbd_12_sub_pixel_variance16x32_sse2, 12),
1686   SubpelVarianceParams(4, 4, &aom_highbd_12_sub_pixel_variance16x16_sse2, 12),
1687   SubpelVarianceParams(4, 3, &aom_highbd_12_sub_pixel_variance16x8_sse2, 12),
1688   SubpelVarianceParams(3, 4, &aom_highbd_12_sub_pixel_variance8x16_sse2, 12),
1689   SubpelVarianceParams(3, 3, &aom_highbd_12_sub_pixel_variance8x8_sse2, 12),
1690   SubpelVarianceParams(3, 2, &aom_highbd_12_sub_pixel_variance8x4_sse2, 12),
1691   SubpelVarianceParams(6, 6, &aom_highbd_10_sub_pixel_variance64x64_sse2, 10),
1692   SubpelVarianceParams(6, 5, &aom_highbd_10_sub_pixel_variance64x32_sse2, 10),
1693   SubpelVarianceParams(5, 6, &aom_highbd_10_sub_pixel_variance32x64_sse2, 10),
1694   SubpelVarianceParams(5, 5, &aom_highbd_10_sub_pixel_variance32x32_sse2, 10),
1695   SubpelVarianceParams(5, 4, &aom_highbd_10_sub_pixel_variance32x16_sse2, 10),
1696   SubpelVarianceParams(4, 5, &aom_highbd_10_sub_pixel_variance16x32_sse2, 10),
1697   SubpelVarianceParams(4, 4, &aom_highbd_10_sub_pixel_variance16x16_sse2, 10),
1698   SubpelVarianceParams(4, 3, &aom_highbd_10_sub_pixel_variance16x8_sse2, 10),
1699   SubpelVarianceParams(3, 4, &aom_highbd_10_sub_pixel_variance8x16_sse2, 10),
1700   SubpelVarianceParams(3, 3, &aom_highbd_10_sub_pixel_variance8x8_sse2, 10),
1701   SubpelVarianceParams(3, 2, &aom_highbd_10_sub_pixel_variance8x4_sse2, 10),
1702   SubpelVarianceParams(6, 6, &aom_highbd_8_sub_pixel_variance64x64_sse2, 8),
1703   SubpelVarianceParams(6, 5, &aom_highbd_8_sub_pixel_variance64x32_sse2, 8),
1704   SubpelVarianceParams(5, 6, &aom_highbd_8_sub_pixel_variance32x64_sse2, 8),
1705   SubpelVarianceParams(5, 5, &aom_highbd_8_sub_pixel_variance32x32_sse2, 8),
1706   SubpelVarianceParams(5, 4, &aom_highbd_8_sub_pixel_variance32x16_sse2, 8),
1707   SubpelVarianceParams(4, 5, &aom_highbd_8_sub_pixel_variance16x32_sse2, 8),
1708   SubpelVarianceParams(4, 4, &aom_highbd_8_sub_pixel_variance16x16_sse2, 8),
1709   SubpelVarianceParams(4, 3, &aom_highbd_8_sub_pixel_variance16x8_sse2, 8),
1710   SubpelVarianceParams(3, 4, &aom_highbd_8_sub_pixel_variance8x16_sse2, 8),
1711   SubpelVarianceParams(3, 3, &aom_highbd_8_sub_pixel_variance8x8_sse2, 8),
1712   SubpelVarianceParams(3, 2, &aom_highbd_8_sub_pixel_variance8x4_sse2, 8)
1713 };
1714
1715 INSTANTIATE_TEST_CASE_P(SSE2, AvxHBDSubpelVarianceTest,
1716                         ::testing::ValuesIn(kArrayHBDSubpelVariance_sse2));
1717
1718 const SubpelAvgVarianceParams kArrayHBDSubpelAvgVariance_sse2[] = {
1719   SubpelAvgVarianceParams(6, 6, &aom_highbd_12_sub_pixel_avg_variance64x64_sse2,
1720                           12),
1721   SubpelAvgVarianceParams(6, 5, &aom_highbd_12_sub_pixel_avg_variance64x32_sse2,
1722                           12),
1723   SubpelAvgVarianceParams(5, 6, &aom_highbd_12_sub_pixel_avg_variance32x64_sse2,
1724                           12),
1725   SubpelAvgVarianceParams(5, 5, &aom_highbd_12_sub_pixel_avg_variance32x32_sse2,
1726                           12),
1727   SubpelAvgVarianceParams(5, 4, &aom_highbd_12_sub_pixel_avg_variance32x16_sse2,
1728                           12),
1729   SubpelAvgVarianceParams(4, 5, &aom_highbd_12_sub_pixel_avg_variance16x32_sse2,
1730                           12),
1731   SubpelAvgVarianceParams(4, 4, &aom_highbd_12_sub_pixel_avg_variance16x16_sse2,
1732                           12),
1733   SubpelAvgVarianceParams(4, 3, &aom_highbd_12_sub_pixel_avg_variance16x8_sse2,
1734                           12),
1735   SubpelAvgVarianceParams(3, 4, &aom_highbd_12_sub_pixel_avg_variance8x16_sse2,
1736                           12),
1737   SubpelAvgVarianceParams(3, 3, &aom_highbd_12_sub_pixel_avg_variance8x8_sse2,
1738                           12),
1739   SubpelAvgVarianceParams(3, 2, &aom_highbd_12_sub_pixel_avg_variance8x4_sse2,
1740                           12),
1741   SubpelAvgVarianceParams(6, 6, &aom_highbd_10_sub_pixel_avg_variance64x64_sse2,
1742                           10),
1743   SubpelAvgVarianceParams(6, 5, &aom_highbd_10_sub_pixel_avg_variance64x32_sse2,
1744                           10),
1745   SubpelAvgVarianceParams(5, 6, &aom_highbd_10_sub_pixel_avg_variance32x64_sse2,
1746                           10),
1747   SubpelAvgVarianceParams(5, 5, &aom_highbd_10_sub_pixel_avg_variance32x32_sse2,
1748                           10),
1749   SubpelAvgVarianceParams(5, 4, &aom_highbd_10_sub_pixel_avg_variance32x16_sse2,
1750                           10),
1751   SubpelAvgVarianceParams(4, 5, &aom_highbd_10_sub_pixel_avg_variance16x32_sse2,
1752                           10),
1753   SubpelAvgVarianceParams(4, 4, &aom_highbd_10_sub_pixel_avg_variance16x16_sse2,
1754                           10),
1755   SubpelAvgVarianceParams(4, 3, &aom_highbd_10_sub_pixel_avg_variance16x8_sse2,
1756                           10),
1757   SubpelAvgVarianceParams(3, 4, &aom_highbd_10_sub_pixel_avg_variance8x16_sse2,
1758                           10),
1759   SubpelAvgVarianceParams(3, 3, &aom_highbd_10_sub_pixel_avg_variance8x8_sse2,
1760                           10),
1761   SubpelAvgVarianceParams(3, 2, &aom_highbd_10_sub_pixel_avg_variance8x4_sse2,
1762                           10),
1763   SubpelAvgVarianceParams(6, 6, &aom_highbd_8_sub_pixel_avg_variance64x64_sse2,
1764                           8),
1765   SubpelAvgVarianceParams(6, 5, &aom_highbd_8_sub_pixel_avg_variance64x32_sse2,
1766                           8),
1767   SubpelAvgVarianceParams(5, 6, &aom_highbd_8_sub_pixel_avg_variance32x64_sse2,
1768                           8),
1769   SubpelAvgVarianceParams(5, 5, &aom_highbd_8_sub_pixel_avg_variance32x32_sse2,
1770                           8),
1771   SubpelAvgVarianceParams(5, 4, &aom_highbd_8_sub_pixel_avg_variance32x16_sse2,
1772                           8),
1773   SubpelAvgVarianceParams(4, 5, &aom_highbd_8_sub_pixel_avg_variance16x32_sse2,
1774                           8),
1775   SubpelAvgVarianceParams(4, 4, &aom_highbd_8_sub_pixel_avg_variance16x16_sse2,
1776                           8),
1777   SubpelAvgVarianceParams(4, 3, &aom_highbd_8_sub_pixel_avg_variance16x8_sse2,
1778                           8),
1779   SubpelAvgVarianceParams(3, 4, &aom_highbd_8_sub_pixel_avg_variance8x16_sse2,
1780                           8),
1781   SubpelAvgVarianceParams(3, 3, &aom_highbd_8_sub_pixel_avg_variance8x8_sse2,
1782                           8),
1783   SubpelAvgVarianceParams(3, 2, &aom_highbd_8_sub_pixel_avg_variance8x4_sse2, 8)
1784 };
1785
1786 INSTANTIATE_TEST_CASE_P(SSE2, AvxHBDSubpelAvgVarianceTest,
1787                         ::testing::ValuesIn(kArrayHBDSubpelAvgVariance_sse2));
1788 #endif  // HAVE_SSE2
1789
1790 #if HAVE_SSSE3
1791 INSTANTIATE_TEST_CASE_P(
1792     SSSE3, AvxSubpelVarianceTest,
1793     ::testing::Values(
1794         SubpelVarianceParams(7, 7, &aom_sub_pixel_variance128x128_ssse3, 0),
1795         SubpelVarianceParams(7, 6, &aom_sub_pixel_variance128x64_ssse3, 0),
1796         SubpelVarianceParams(6, 7, &aom_sub_pixel_variance64x128_ssse3, 0),
1797         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_ssse3, 0),
1798         SubpelVarianceParams(6, 5, &aom_sub_pixel_variance64x32_ssse3, 0),
1799         SubpelVarianceParams(5, 6, &aom_sub_pixel_variance32x64_ssse3, 0),
1800         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_ssse3, 0),
1801         SubpelVarianceParams(5, 4, &aom_sub_pixel_variance32x16_ssse3, 0),
1802         SubpelVarianceParams(4, 5, &aom_sub_pixel_variance16x32_ssse3, 0),
1803         SubpelVarianceParams(4, 4, &aom_sub_pixel_variance16x16_ssse3, 0),
1804         SubpelVarianceParams(4, 3, &aom_sub_pixel_variance16x8_ssse3, 0),
1805         SubpelVarianceParams(3, 4, &aom_sub_pixel_variance8x16_ssse3, 0),
1806         SubpelVarianceParams(3, 3, &aom_sub_pixel_variance8x8_ssse3, 0),
1807         SubpelVarianceParams(3, 2, &aom_sub_pixel_variance8x4_ssse3, 0),
1808         SubpelVarianceParams(2, 3, &aom_sub_pixel_variance4x8_ssse3, 0),
1809         SubpelVarianceParams(2, 2, &aom_sub_pixel_variance4x4_ssse3, 0)));
1810
1811 INSTANTIATE_TEST_CASE_P(
1812     SSSE3, AvxSubpelAvgVarianceTest,
1813     ::testing::Values(
1814         SubpelAvgVarianceParams(7, 7, &aom_sub_pixel_avg_variance128x128_ssse3,
1815                                 0),
1816         SubpelAvgVarianceParams(7, 6, &aom_sub_pixel_avg_variance128x64_ssse3,
1817                                 0),
1818         SubpelAvgVarianceParams(6, 7, &aom_sub_pixel_avg_variance64x128_ssse3,
1819                                 0),
1820         SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_ssse3,
1821                                 0),
1822         SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_ssse3,
1823                                 0),
1824         SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_ssse3,
1825                                 0),
1826         SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_ssse3,
1827                                 0),
1828         SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_ssse3,
1829                                 0),
1830         SubpelAvgVarianceParams(4, 5, &aom_sub_pixel_avg_variance16x32_ssse3,
1831                                 0),
1832         SubpelAvgVarianceParams(4, 4, &aom_sub_pixel_avg_variance16x16_ssse3,
1833                                 0),
1834         SubpelAvgVarianceParams(4, 3, &aom_sub_pixel_avg_variance16x8_ssse3, 0),
1835         SubpelAvgVarianceParams(3, 4, &aom_sub_pixel_avg_variance8x16_ssse3, 0),
1836         SubpelAvgVarianceParams(3, 3, &aom_sub_pixel_avg_variance8x8_ssse3, 0),
1837         SubpelAvgVarianceParams(3, 2, &aom_sub_pixel_avg_variance8x4_ssse3, 0),
1838         SubpelAvgVarianceParams(2, 3, &aom_sub_pixel_avg_variance4x8_ssse3, 0),
1839         SubpelAvgVarianceParams(2, 2, &aom_sub_pixel_avg_variance4x4_ssse3,
1840                                 0)));
1841
1842 INSTANTIATE_TEST_CASE_P(
1843     SSSE3, AvxJntSubpelAvgVarianceTest,
1844     ::testing::Values(
1845         JntSubpelAvgVarianceParams(6, 6,
1846                                    &aom_jnt_sub_pixel_avg_variance64x64_ssse3,
1847                                    0),
1848         JntSubpelAvgVarianceParams(6, 5,
1849                                    &aom_jnt_sub_pixel_avg_variance64x32_ssse3,
1850                                    0),
1851         JntSubpelAvgVarianceParams(5, 6,
1852                                    &aom_jnt_sub_pixel_avg_variance32x64_ssse3,
1853                                    0),
1854         JntSubpelAvgVarianceParams(5, 5,
1855                                    &aom_jnt_sub_pixel_avg_variance32x32_ssse3,
1856                                    0),
1857         JntSubpelAvgVarianceParams(5, 4,
1858                                    &aom_jnt_sub_pixel_avg_variance32x16_ssse3,
1859                                    0),
1860         JntSubpelAvgVarianceParams(4, 5,
1861                                    &aom_jnt_sub_pixel_avg_variance16x32_ssse3,
1862                                    0),
1863         JntSubpelAvgVarianceParams(4, 4,
1864                                    &aom_jnt_sub_pixel_avg_variance16x16_ssse3,
1865                                    0),
1866         JntSubpelAvgVarianceParams(4, 3,
1867                                    &aom_jnt_sub_pixel_avg_variance16x8_ssse3,
1868                                    0),
1869         JntSubpelAvgVarianceParams(3, 4,
1870                                    &aom_jnt_sub_pixel_avg_variance8x16_ssse3,
1871                                    0),
1872         JntSubpelAvgVarianceParams(3, 3,
1873                                    &aom_jnt_sub_pixel_avg_variance8x8_ssse3, 0),
1874         JntSubpelAvgVarianceParams(3, 2,
1875                                    &aom_jnt_sub_pixel_avg_variance8x4_ssse3, 0),
1876         JntSubpelAvgVarianceParams(2, 3,
1877                                    &aom_jnt_sub_pixel_avg_variance4x8_ssse3, 0),
1878         JntSubpelAvgVarianceParams(2, 2,
1879                                    &aom_jnt_sub_pixel_avg_variance4x4_ssse3,
1880                                    0)));
1881 #endif  // HAVE_SSSE3
1882
1883 #if HAVE_SSE4_1
1884 INSTANTIATE_TEST_CASE_P(
1885     SSE4_1, AvxObmcSubpelVarianceTest,
1886     ::testing::Values(
1887         ObmcSubpelVarianceParams(7, 7,
1888                                  &aom_obmc_sub_pixel_variance128x128_sse4_1, 0),
1889         ObmcSubpelVarianceParams(7, 6,
1890                                  &aom_obmc_sub_pixel_variance128x64_sse4_1, 0),
1891         ObmcSubpelVarianceParams(6, 7,
1892                                  &aom_obmc_sub_pixel_variance64x128_sse4_1, 0),
1893         ObmcSubpelVarianceParams(6, 6, &aom_obmc_sub_pixel_variance64x64_sse4_1,
1894                                  0),
1895         ObmcSubpelVarianceParams(6, 5, &aom_obmc_sub_pixel_variance64x32_sse4_1,
1896                                  0),
1897         ObmcSubpelVarianceParams(5, 6, &aom_obmc_sub_pixel_variance32x64_sse4_1,
1898                                  0),
1899         ObmcSubpelVarianceParams(5, 5, &aom_obmc_sub_pixel_variance32x32_sse4_1,
1900                                  0),
1901         ObmcSubpelVarianceParams(5, 4, &aom_obmc_sub_pixel_variance32x16_sse4_1,
1902                                  0),
1903         ObmcSubpelVarianceParams(4, 5, &aom_obmc_sub_pixel_variance16x32_sse4_1,
1904                                  0),
1905         ObmcSubpelVarianceParams(4, 4, &aom_obmc_sub_pixel_variance16x16_sse4_1,
1906                                  0),
1907         ObmcSubpelVarianceParams(4, 3, &aom_obmc_sub_pixel_variance16x8_sse4_1,
1908                                  0),
1909         ObmcSubpelVarianceParams(3, 4, &aom_obmc_sub_pixel_variance8x16_sse4_1,
1910                                  0),
1911         ObmcSubpelVarianceParams(3, 3, &aom_obmc_sub_pixel_variance8x8_sse4_1,
1912                                  0),
1913         ObmcSubpelVarianceParams(3, 2, &aom_obmc_sub_pixel_variance8x4_sse4_1,
1914                                  0),
1915         ObmcSubpelVarianceParams(2, 3, &aom_obmc_sub_pixel_variance4x8_sse4_1,
1916                                  0),
1917         ObmcSubpelVarianceParams(2, 2, &aom_obmc_sub_pixel_variance4x4_sse4_1,
1918                                  0)));
1919 #endif  // HAVE_SSE4_1
1920
1921 #if HAVE_AVX2
1922 INSTANTIATE_TEST_CASE_P(AVX2, AvxMseTest,
1923                         ::testing::Values(MseParams(4, 4, &aom_mse16x16_avx2)));
1924
1925 INSTANTIATE_TEST_CASE_P(
1926     AVX2, AvxVarianceTest,
1927     ::testing::Values(VarianceParams(7, 7, &aom_variance128x128_avx2),
1928                       VarianceParams(7, 6, &aom_variance128x64_avx2),
1929                       VarianceParams(6, 7, &aom_variance64x128_avx2),
1930                       VarianceParams(6, 6, &aom_variance64x64_avx2),
1931                       VarianceParams(6, 5, &aom_variance64x32_avx2),
1932                       VarianceParams(6, 4, &aom_variance64x16_avx2),
1933                       VarianceParams(5, 6, &aom_variance32x64_avx2),
1934                       VarianceParams(5, 5, &aom_variance32x32_avx2),
1935                       VarianceParams(5, 4, &aom_variance32x16_avx2),
1936                       VarianceParams(5, 3, &aom_variance32x8_avx2),
1937                       VarianceParams(4, 6, &aom_variance16x64_avx2),
1938                       VarianceParams(4, 5, &aom_variance16x32_avx2),
1939                       VarianceParams(4, 4, &aom_variance16x16_avx2),
1940                       VarianceParams(4, 3, &aom_variance16x8_avx2),
1941                       VarianceParams(4, 2, &aom_variance16x4_avx2)));
1942
1943 INSTANTIATE_TEST_CASE_P(
1944     AVX2, AvxSubpelVarianceTest,
1945     ::testing::Values(
1946         SubpelVarianceParams(7, 7, &aom_sub_pixel_variance128x128_avx2, 0),
1947         SubpelVarianceParams(7, 6, &aom_sub_pixel_variance128x64_avx2, 0),
1948         SubpelVarianceParams(6, 7, &aom_sub_pixel_variance64x128_avx2, 0),
1949         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_avx2, 0),
1950         SubpelVarianceParams(6, 5, &aom_sub_pixel_variance64x32_avx2, 0),
1951         SubpelVarianceParams(5, 6, &aom_sub_pixel_variance32x64_avx2, 0),
1952         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_avx2, 0),
1953         SubpelVarianceParams(5, 4, &aom_sub_pixel_variance32x16_avx2, 0)));
1954
1955 INSTANTIATE_TEST_CASE_P(
1956     AVX2, AvxSubpelAvgVarianceTest,
1957     ::testing::Values(
1958         SubpelAvgVarianceParams(7, 7, &aom_sub_pixel_avg_variance128x128_avx2,
1959                                 0),
1960         SubpelAvgVarianceParams(7, 6, &aom_sub_pixel_avg_variance128x64_avx2,
1961                                 0),
1962         SubpelAvgVarianceParams(6, 7, &aom_sub_pixel_avg_variance64x128_avx2,
1963                                 0),
1964         SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_avx2, 0),
1965         SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_avx2, 0),
1966         SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_avx2, 0),
1967         SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_avx2, 0),
1968         SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_avx2,
1969                                 0)));
1970 #endif  // HAVE_AVX2
1971
1972 #if HAVE_NEON
1973 INSTANTIATE_TEST_CASE_P(NEON, AvxSseTest,
1974                         ::testing::Values(SseParams(2, 2,
1975                                                     &aom_get4x4sse_cs_neon)));
1976
1977 INSTANTIATE_TEST_CASE_P(NEON, AvxMseTest,
1978                         ::testing::Values(MseParams(4, 4, &aom_mse16x16_neon)));
1979
1980 INSTANTIATE_TEST_CASE_P(
1981     NEON, AvxVarianceTest,
1982     ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_neon),
1983                       VarianceParams(6, 5, &aom_variance64x32_neon),
1984                       VarianceParams(5, 6, &aom_variance32x64_neon),
1985                       VarianceParams(5, 5, &aom_variance32x32_neon),
1986                       VarianceParams(4, 4, &aom_variance16x16_neon),
1987                       VarianceParams(4, 3, &aom_variance16x8_neon),
1988                       VarianceParams(3, 4, &aom_variance8x16_neon),
1989                       VarianceParams(3, 3, &aom_variance8x8_neon)));
1990
1991 INSTANTIATE_TEST_CASE_P(
1992     NEON, AvxSubpelVarianceTest,
1993     ::testing::Values(
1994         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_neon, 0),
1995         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_neon, 0),
1996         SubpelVarianceParams(4, 4, &aom_sub_pixel_variance16x16_neon, 0),
1997         SubpelVarianceParams(3, 3, &aom_sub_pixel_variance8x8_neon, 0)));
1998 #endif  // HAVE_NEON
1999
2000 #if HAVE_MSA
2001 INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest,
2002                         ::testing::Values(aom_get_mb_ss_msa));
2003
2004 INSTANTIATE_TEST_CASE_P(MSA, AvxSseTest,
2005                         ::testing::Values(SseParams(2, 2,
2006                                                     &aom_get4x4sse_cs_msa)));
2007
2008 INSTANTIATE_TEST_CASE_P(MSA, AvxMseTest,
2009                         ::testing::Values(MseParams(4, 4, &aom_mse16x16_msa),
2010                                           MseParams(4, 3, &aom_mse16x8_msa),
2011                                           MseParams(3, 4, &aom_mse8x16_msa),
2012                                           MseParams(3, 3, &aom_mse8x8_msa)));
2013
2014 INSTANTIATE_TEST_CASE_P(
2015     MSA, AvxVarianceTest,
2016     ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_msa),
2017                       VarianceParams(6, 5, &aom_variance64x32_msa),
2018                       VarianceParams(5, 6, &aom_variance32x64_msa),
2019                       VarianceParams(5, 5, &aom_variance32x32_msa),
2020                       VarianceParams(5, 4, &aom_variance32x16_msa),
2021                       VarianceParams(4, 5, &aom_variance16x32_msa),
2022                       VarianceParams(4, 4, &aom_variance16x16_msa),
2023                       VarianceParams(4, 3, &aom_variance16x8_msa),
2024                       VarianceParams(3, 4, &aom_variance8x16_msa),
2025                       VarianceParams(3, 3, &aom_variance8x8_msa),
2026                       VarianceParams(3, 2, &aom_variance8x4_msa),
2027                       VarianceParams(2, 3, &aom_variance4x8_msa),
2028                       VarianceParams(2, 2, &aom_variance4x4_msa)));
2029
2030 INSTANTIATE_TEST_CASE_P(
2031     MSA, AvxSubpelVarianceTest,
2032     ::testing::Values(
2033         SubpelVarianceParams(2, 2, &aom_sub_pixel_variance4x4_msa, 0),
2034         SubpelVarianceParams(2, 3, &aom_sub_pixel_variance4x8_msa, 0),
2035         SubpelVarianceParams(3, 2, &aom_sub_pixel_variance8x4_msa, 0),
2036         SubpelVarianceParams(3, 3, &aom_sub_pixel_variance8x8_msa, 0),
2037         SubpelVarianceParams(3, 4, &aom_sub_pixel_variance8x16_msa, 0),
2038         SubpelVarianceParams(4, 3, &aom_sub_pixel_variance16x8_msa, 0),
2039         SubpelVarianceParams(4, 4, &aom_sub_pixel_variance16x16_msa, 0),
2040         SubpelVarianceParams(4, 5, &aom_sub_pixel_variance16x32_msa, 0),
2041         SubpelVarianceParams(5, 4, &aom_sub_pixel_variance32x16_msa, 0),
2042         SubpelVarianceParams(5, 5, &aom_sub_pixel_variance32x32_msa, 0),
2043         SubpelVarianceParams(5, 6, &aom_sub_pixel_variance32x64_msa, 0),
2044         SubpelVarianceParams(6, 5, &aom_sub_pixel_variance64x32_msa, 0),
2045         SubpelVarianceParams(6, 6, &aom_sub_pixel_variance64x64_msa, 0)));
2046
2047 INSTANTIATE_TEST_CASE_P(
2048     MSA, AvxSubpelAvgVarianceTest,
2049     ::testing::Values(
2050         SubpelAvgVarianceParams(6, 6, &aom_sub_pixel_avg_variance64x64_msa, 0),
2051         SubpelAvgVarianceParams(6, 5, &aom_sub_pixel_avg_variance64x32_msa, 0),
2052         SubpelAvgVarianceParams(5, 6, &aom_sub_pixel_avg_variance32x64_msa, 0),
2053         SubpelAvgVarianceParams(5, 5, &aom_sub_pixel_avg_variance32x32_msa, 0),
2054         SubpelAvgVarianceParams(5, 4, &aom_sub_pixel_avg_variance32x16_msa, 0),
2055         SubpelAvgVarianceParams(4, 5, &aom_sub_pixel_avg_variance16x32_msa, 0),
2056         SubpelAvgVarianceParams(4, 4, &aom_sub_pixel_avg_variance16x16_msa, 0),
2057         SubpelAvgVarianceParams(4, 3, &aom_sub_pixel_avg_variance16x8_msa, 0),
2058         SubpelAvgVarianceParams(3, 4, &aom_sub_pixel_avg_variance8x16_msa, 0),
2059         SubpelAvgVarianceParams(3, 3, &aom_sub_pixel_avg_variance8x8_msa, 0),
2060         SubpelAvgVarianceParams(3, 2, &aom_sub_pixel_avg_variance8x4_msa, 0),
2061         SubpelAvgVarianceParams(2, 3, &aom_sub_pixel_avg_variance4x8_msa, 0),
2062         SubpelAvgVarianceParams(2, 2, &aom_sub_pixel_avg_variance4x4_msa, 0)));
2063 #endif  // HAVE_MSA
2064 }  // namespace