granicus.if.org Git - libvpx/blob - test/sad_test.cc

   1 /*
   2  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <string.h>
  12 #include <limits.h>
  13
  14 #include "third_party/googletest/src/include/gtest/gtest.h"
  15
  16 #include "./vpx_config.h"
  17 #include "./vpx_dsp_rtcd.h"
  18 #include "test/acm_random.h"
  19 #include "test/bench.h"
  20 #include "test/clear_system_state.h"
  21 #include "test/register_state_check.h"
  22 #include "test/util.h"
  23 #include "vpx/vpx_codec.h"
  24 #include "vpx_mem/vpx_mem.h"
  25 #include "vpx_ports/mem.h"
  26 #include "vpx_ports/msvc.h"
  27 #include "vpx_ports/vpx_timer.h"
  28
  29 template <typename Function>
  30 struct TestParams {
  31   TestParams(int w, int h, Function f, int bd = -1)
  32       : width(w), height(h), bit_depth(bd), func(f) {}
  33   int width, height, bit_depth;
  34   Function func;
  35 };
  36
  37 typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
  38                                    const uint8_t *ref_ptr, int ref_stride);
  39 typedef TestParams<SadMxNFunc> SadMxNParam;
  40
  41 typedef unsigned int (*SadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
  42                                       const uint8_t *ref_ptr, int ref_stride,
  43                                       const uint8_t *second_pred);
  44 typedef TestParams<SadMxNAvgFunc> SadMxNAvgParam;
  45
  46 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, int src_stride,
  47                              const uint8_t *const ref_ptr[], int ref_stride,
  48                              unsigned int *sad_array);
  49 typedef TestParams<SadMxNx4Func> SadMxNx4Param;
  50
  51 using libvpx_test::ACMRandom;
  52
  53 namespace {
  54 template <typename ParamType>
  55 class SADTestBase : public ::testing::TestWithParam<ParamType> {
  56  public:
  57   explicit SADTestBase(const ParamType &params) : params_(params) {}
  58
  59   virtual void SetUp() {
  60     source_data8_ = reinterpret_cast<uint8_t *>(
  61         vpx_memalign(kDataAlignment, kDataBlockSize));
  62     reference_data8_ = reinterpret_cast<uint8_t *>(
  63         vpx_memalign(kDataAlignment, kDataBufferSize));
  64     second_pred8_ =
  65         reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, 64 * 64));
  66     source_data16_ = reinterpret_cast<uint16_t *>(
  67         vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
  68     reference_data16_ = reinterpret_cast<uint16_t *>(
  69         vpx_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
  70     second_pred16_ = reinterpret_cast<uint16_t *>(
  71         vpx_memalign(kDataAlignment, 64 * 64 * sizeof(uint16_t)));
  72
  73     if (params_.bit_depth == -1) {
  74       use_high_bit_depth_ = false;
  75       bit_depth_ = VPX_BITS_8;
  76       source_data_ = source_data8_;
  77       reference_data_ = reference_data8_;
  78       second_pred_ = second_pred8_;
  79 #if CONFIG_VP9_HIGHBITDEPTH
  80     } else {
  81       use_high_bit_depth_ = true;
  82       bit_depth_ = static_cast<vpx_bit_depth_t>(params_.bit_depth);
  83       source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
  84       reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
  85       second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
  86 #endif  // CONFIG_VP9_HIGHBITDEPTH
  87     }
  88     mask_ = (1 << bit_depth_) - 1;
  89     source_stride_ = (params_.width + 63) & ~63;
  90     reference_stride_ = params_.width * 2;
  91     rnd_.Reset(ACMRandom::DeterministicSeed());
  92   }
  93
  94   virtual void TearDown() {
  95     vpx_free(source_data8_);
  96     source_data8_ = NULL;
  97     vpx_free(reference_data8_);
  98     reference_data8_ = NULL;
  99     vpx_free(second_pred8_);
 100     second_pred8_ = NULL;
 101     vpx_free(source_data16_);
 102     source_data16_ = NULL;
 103     vpx_free(reference_data16_);
 104     reference_data16_ = NULL;
 105     vpx_free(second_pred16_);
 106     second_pred16_ = NULL;
 107
 108     libvpx_test::ClearSystemState();
 109   }
 110
 111  protected:
 112   // Handle blocks up to 4 blocks 64x64 with stride up to 128
 113   static const int kDataAlignment = 32;
 114   static const int kDataBlockSize = 64 * 128;
 115   static const int kDataBufferSize = 4 * kDataBlockSize;
 116
 117   uint8_t *GetReference(int block_idx) const {
 118 #if CONFIG_VP9_HIGHBITDEPTH
 119     if (use_high_bit_depth_) {
 120       return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
 121                                 block_idx * kDataBlockSize);
 122     }
 123 #endif  // CONFIG_VP9_HIGHBITDEPTH
 124     return reference_data_ + block_idx * kDataBlockSize;
 125   }
 126
 127   // Sum of Absolute Differences. Given two blocks, calculate the absolute
 128   // difference between two pixels in the same relative location; accumulate.
 129   uint32_t ReferenceSAD(int block_idx) const {
 130     uint32_t sad = 0;
 131     const uint8_t *const reference8 = GetReference(block_idx);
 132     const uint8_t *const source8 = source_data_;
 133 #if CONFIG_VP9_HIGHBITDEPTH
 134     const uint16_t *const reference16 =
 135         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 136     const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 137 #endif  // CONFIG_VP9_HIGHBITDEPTH
 138     for (int h = 0; h < params_.height; ++h) {
 139       for (int w = 0; w < params_.width; ++w) {
 140         if (!use_high_bit_depth_) {
 141           sad += abs(source8[h * source_stride_ + w] -
 142                      reference8[h * reference_stride_ + w]);
 143 #if CONFIG_VP9_HIGHBITDEPTH
 144         } else {
 145           sad += abs(source16[h * source_stride_ + w] -
 146                      reference16[h * reference_stride_ + w]);
 147 #endif  // CONFIG_VP9_HIGHBITDEPTH
 148         }
 149       }
 150     }
 151     return sad;
 152   }
 153
 154   // Sum of Absolute Differences Average. Given two blocks, and a prediction
 155   // calculate the absolute difference between one pixel and average of the
 156   // corresponding and predicted pixels; accumulate.
 157   unsigned int ReferenceSADavg(int block_idx) const {
 158     unsigned int sad = 0;
 159     const uint8_t *const reference8 = GetReference(block_idx);
 160     const uint8_t *const source8 = source_data_;
 161     const uint8_t *const second_pred8 = second_pred_;
 162 #if CONFIG_VP9_HIGHBITDEPTH
 163     const uint16_t *const reference16 =
 164         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 165     const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 166     const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
 167 #endif  // CONFIG_VP9_HIGHBITDEPTH
 168     for (int h = 0; h < params_.height; ++h) {
 169       for (int w = 0; w < params_.width; ++w) {
 170         if (!use_high_bit_depth_) {
 171           const int tmp = second_pred8[h * params_.width + w] +
 172                           reference8[h * reference_stride_ + w];
 173           const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
 174           sad += abs(source8[h * source_stride_ + w] - comp_pred);
 175 #if CONFIG_VP9_HIGHBITDEPTH
 176         } else {
 177           const int tmp = second_pred16[h * params_.width + w] +
 178                           reference16[h * reference_stride_ + w];
 179           const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
 180           sad += abs(source16[h * source_stride_ + w] - comp_pred);
 181 #endif  // CONFIG_VP9_HIGHBITDEPTH
 182         }
 183       }
 184     }
 185     return sad;
 186   }
 187
 188   void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) const {
 189     uint8_t *data8 = data;
 190 #if CONFIG_VP9_HIGHBITDEPTH
 191     uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
 192 #endif  // CONFIG_VP9_HIGHBITDEPTH
 193     for (int h = 0; h < params_.height; ++h) {
 194       for (int w = 0; w < params_.width; ++w) {
 195         if (!use_high_bit_depth_) {
 196           data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
 197 #if CONFIG_VP9_HIGHBITDEPTH
 198         } else {
 199           data16[h * stride + w] = fill_constant;
 200 #endif  // CONFIG_VP9_HIGHBITDEPTH
 201         }
 202       }
 203     }
 204   }
 205
 206   void FillRandom(uint8_t *data, int stride) {
 207     uint8_t *data8 = data;
 208 #if CONFIG_VP9_HIGHBITDEPTH
 209     uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
 210 #endif  // CONFIG_VP9_HIGHBITDEPTH
 211     for (int h = 0; h < params_.height; ++h) {
 212       for (int w = 0; w < params_.width; ++w) {
 213         if (!use_high_bit_depth_) {
 214           data8[h * stride + w] = rnd_.Rand8();
 215 #if CONFIG_VP9_HIGHBITDEPTH
 216         } else {
 217           data16[h * stride + w] = rnd_.Rand16() & mask_;
 218 #endif  // CONFIG_VP9_HIGHBITDEPTH
 219         }
 220       }
 221     }
 222   }
 223
 224   uint32_t mask_;
 225   vpx_bit_depth_t bit_depth_;
 226   int source_stride_;
 227   int reference_stride_;
 228   bool use_high_bit_depth_;
 229
 230   uint8_t *source_data_;
 231   uint8_t *reference_data_;
 232   uint8_t *second_pred_;
 233   uint8_t *source_data8_;
 234   uint8_t *reference_data8_;
 235   uint8_t *second_pred8_;
 236   uint16_t *source_data16_;
 237   uint16_t *reference_data16_;
 238   uint16_t *second_pred16_;
 239
 240   ACMRandom rnd_;
 241   ParamType params_;
 242 };
 243
 244 class SADx4Test : public SADTestBase<SadMxNx4Param> {
 245  public:
 246   SADx4Test() : SADTestBase(GetParam()) {}
 247
 248  protected:
 249   void SADs(unsigned int *results) const {
 250     const uint8_t *references[] = { GetReference(0), GetReference(1),
 251                                     GetReference(2), GetReference(3) };
 252
 253     ASM_REGISTER_STATE_CHECK(params_.func(
 254         source_data_, source_stride_, references, reference_stride_, results));
 255   }
 256
 257   void CheckSADs() const {
 258     uint32_t reference_sad, exp_sad[4];
 259
 260     SADs(exp_sad);
 261     for (int block = 0; block < 4; ++block) {
 262       reference_sad = ReferenceSAD(block);
 263
 264       EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
 265     }
 266   }
 267 };
 268
 269 class SADTest : public AbstractBench, public SADTestBase<SadMxNParam> {
 270  public:
 271   SADTest() : SADTestBase(GetParam()) {}
 272
 273  protected:
 274   unsigned int SAD(int block_idx) const {
 275     unsigned int ret;
 276     const uint8_t *const reference = GetReference(block_idx);
 277
 278     ASM_REGISTER_STATE_CHECK(ret = params_.func(source_data_, source_stride_,
 279                                                 reference, reference_stride_));
 280     return ret;
 281   }
 282
 283   void CheckSAD() const {
 284     const unsigned int reference_sad = ReferenceSAD(0);
 285     const unsigned int exp_sad = SAD(0);
 286
 287     ASSERT_EQ(reference_sad, exp_sad);
 288   }
 289
 290   void Run() {
 291     params_.func(source_data_, source_stride_, reference_data_,
 292                  reference_stride_);
 293   }
 294 };
 295
 296 class SADavgTest : public SADTestBase<SadMxNAvgParam> {
 297  public:
 298   SADavgTest() : SADTestBase(GetParam()) {}
 299
 300  protected:
 301   unsigned int SAD_avg(int block_idx) const {
 302     unsigned int ret;
 303     const uint8_t *const reference = GetReference(block_idx);
 304
 305     ASM_REGISTER_STATE_CHECK(ret = params_.func(source_data_, source_stride_,
 306                                                 reference, reference_stride_,
 307                                                 second_pred_));
 308     return ret;
 309   }
 310
 311   void CheckSAD() const {
 312     const unsigned int reference_sad = ReferenceSADavg(0);
 313     const unsigned int exp_sad = SAD_avg(0);
 314
 315     ASSERT_EQ(reference_sad, exp_sad);
 316   }
 317 };
 318
 319 TEST_P(SADTest, MaxRef) {
 320   FillConstant(source_data_, source_stride_, 0);
 321   FillConstant(reference_data_, reference_stride_, mask_);
 322   CheckSAD();
 323 }
 324
 325 TEST_P(SADTest, MaxSrc) {
 326   FillConstant(source_data_, source_stride_, mask_);
 327   FillConstant(reference_data_, reference_stride_, 0);
 328   CheckSAD();
 329 }
 330
 331 TEST_P(SADTest, ShortRef) {
 332   const int tmp_stride = reference_stride_;
 333   reference_stride_ >>= 1;
 334   FillRandom(source_data_, source_stride_);
 335   FillRandom(reference_data_, reference_stride_);
 336   CheckSAD();
 337   reference_stride_ = tmp_stride;
 338 }
 339
 340 TEST_P(SADTest, UnalignedRef) {
 341   // The reference frame, but not the source frame, may be unaligned for
 342   // certain types of searches.
 343   const int tmp_stride = reference_stride_;
 344   reference_stride_ -= 1;
 345   FillRandom(source_data_, source_stride_);
 346   FillRandom(reference_data_, reference_stride_);
 347   CheckSAD();
 348   reference_stride_ = tmp_stride;
 349 }
 350
 351 TEST_P(SADTest, ShortSrc) {
 352   const int tmp_stride = source_stride_;
 353   source_stride_ >>= 1;
 354   FillRandom(source_data_, source_stride_);
 355   FillRandom(reference_data_, reference_stride_);
 356   CheckSAD();
 357   source_stride_ = tmp_stride;
 358 }
 359
 360 TEST_P(SADTest, DISABLED_Speed) {
 361   const int kCountSpeedTestBlock = 50000000 / (params_.width * params_.height);
 362   FillRandom(source_data_, source_stride_);
 363
 364   RunNTimes(kCountSpeedTestBlock);
 365
 366   char title[16];
 367   snprintf(title, sizeof(title), "%dx%d", params_.width, params_.height);
 368   PrintMedian(title);
 369 }
 370
 371 TEST_P(SADavgTest, MaxRef) {
 372   FillConstant(source_data_, source_stride_, 0);
 373   FillConstant(reference_data_, reference_stride_, mask_);
 374   FillConstant(second_pred_, params_.width, 0);
 375   CheckSAD();
 376 }
 377 TEST_P(SADavgTest, MaxSrc) {
 378   FillConstant(source_data_, source_stride_, mask_);
 379   FillConstant(reference_data_, reference_stride_, 0);
 380   FillConstant(second_pred_, params_.width, 0);
 381   CheckSAD();
 382 }
 383
 384 TEST_P(SADavgTest, ShortRef) {
 385   const int tmp_stride = reference_stride_;
 386   reference_stride_ >>= 1;
 387   FillRandom(source_data_, source_stride_);
 388   FillRandom(reference_data_, reference_stride_);
 389   FillRandom(second_pred_, params_.width);
 390   CheckSAD();
 391   reference_stride_ = tmp_stride;
 392 }
 393
 394 TEST_P(SADavgTest, UnalignedRef) {
 395   // The reference frame, but not the source frame, may be unaligned for
 396   // certain types of searches.
 397   const int tmp_stride = reference_stride_;
 398   reference_stride_ -= 1;
 399   FillRandom(source_data_, source_stride_);
 400   FillRandom(reference_data_, reference_stride_);
 401   FillRandom(second_pred_, params_.width);
 402   CheckSAD();
 403   reference_stride_ = tmp_stride;
 404 }
 405
 406 TEST_P(SADavgTest, ShortSrc) {
 407   const int tmp_stride = source_stride_;
 408   source_stride_ >>= 1;
 409   FillRandom(source_data_, source_stride_);
 410   FillRandom(reference_data_, reference_stride_);
 411   FillRandom(second_pred_, params_.width);
 412   CheckSAD();
 413   source_stride_ = tmp_stride;
 414 }
 415
 416 TEST_P(SADx4Test, MaxRef) {
 417   FillConstant(source_data_, source_stride_, 0);
 418   FillConstant(GetReference(0), reference_stride_, mask_);
 419   FillConstant(GetReference(1), reference_stride_, mask_);
 420   FillConstant(GetReference(2), reference_stride_, mask_);
 421   FillConstant(GetReference(3), reference_stride_, mask_);
 422   CheckSADs();
 423 }
 424
 425 TEST_P(SADx4Test, MaxSrc) {
 426   FillConstant(source_data_, source_stride_, mask_);
 427   FillConstant(GetReference(0), reference_stride_, 0);
 428   FillConstant(GetReference(1), reference_stride_, 0);
 429   FillConstant(GetReference(2), reference_stride_, 0);
 430   FillConstant(GetReference(3), reference_stride_, 0);
 431   CheckSADs();
 432 }
 433
 434 TEST_P(SADx4Test, ShortRef) {
 435   int tmp_stride = reference_stride_;
 436   reference_stride_ >>= 1;
 437   FillRandom(source_data_, source_stride_);
 438   FillRandom(GetReference(0), reference_stride_);
 439   FillRandom(GetReference(1), reference_stride_);
 440   FillRandom(GetReference(2), reference_stride_);
 441   FillRandom(GetReference(3), reference_stride_);
 442   CheckSADs();
 443   reference_stride_ = tmp_stride;
 444 }
 445
 446 TEST_P(SADx4Test, UnalignedRef) {
 447   // The reference frame, but not the source frame, may be unaligned for
 448   // certain types of searches.
 449   int tmp_stride = reference_stride_;
 450   reference_stride_ -= 1;
 451   FillRandom(source_data_, source_stride_);
 452   FillRandom(GetReference(0), reference_stride_);
 453   FillRandom(GetReference(1), reference_stride_);
 454   FillRandom(GetReference(2), reference_stride_);
 455   FillRandom(GetReference(3), reference_stride_);
 456   CheckSADs();
 457   reference_stride_ = tmp_stride;
 458 }
 459
 460 TEST_P(SADx4Test, ShortSrc) {
 461   int tmp_stride = source_stride_;
 462   source_stride_ >>= 1;
 463   FillRandom(source_data_, source_stride_);
 464   FillRandom(GetReference(0), reference_stride_);
 465   FillRandom(GetReference(1), reference_stride_);
 466   FillRandom(GetReference(2), reference_stride_);
 467   FillRandom(GetReference(3), reference_stride_);
 468   CheckSADs();
 469   source_stride_ = tmp_stride;
 470 }
 471
 472 TEST_P(SADx4Test, SrcAlignedByWidth) {
 473   uint8_t *tmp_source_data = source_data_;
 474   source_data_ += params_.width;
 475   FillRandom(source_data_, source_stride_);
 476   FillRandom(GetReference(0), reference_stride_);
 477   FillRandom(GetReference(1), reference_stride_);
 478   FillRandom(GetReference(2), reference_stride_);
 479   FillRandom(GetReference(3), reference_stride_);
 480   CheckSADs();
 481   source_data_ = tmp_source_data;
 482 }
 483
 484 TEST_P(SADx4Test, DISABLED_Speed) {
 485   int tmp_stride = reference_stride_;
 486   reference_stride_ -= 1;
 487   FillRandom(source_data_, source_stride_);
 488   FillRandom(GetReference(0), reference_stride_);
 489   FillRandom(GetReference(1), reference_stride_);
 490   FillRandom(GetReference(2), reference_stride_);
 491   FillRandom(GetReference(3), reference_stride_);
 492   const int kCountSpeedTestBlock = 500000000 / (params_.width * params_.height);
 493   uint32_t reference_sad[4], exp_sad[4];
 494   vpx_usec_timer timer;
 495
 496   memset(reference_sad, 0, sizeof(reference_sad));
 497   SADs(exp_sad);
 498   vpx_usec_timer_start(&timer);
 499   for (int i = 0; i < kCountSpeedTestBlock; ++i) {
 500     for (int block = 0; block < 4; ++block) {
 501       reference_sad[block] = ReferenceSAD(block);
 502     }
 503   }
 504   vpx_usec_timer_mark(&timer);
 505   for (int block = 0; block < 4; ++block) {
 506     EXPECT_EQ(reference_sad[block], exp_sad[block]) << "block " << block;
 507   }
 508   const int elapsed_time =
 509       static_cast<int>(vpx_usec_timer_elapsed(&timer) / 1000);
 510   printf("sad%dx%dx4 (%2dbit) time: %5d ms\n", params_.width, params_.height,
 511          bit_depth_, elapsed_time);
 512
 513   reference_stride_ = tmp_stride;
 514 }
 515
 516 //------------------------------------------------------------------------------
 517 // C functions
 518 const SadMxNParam c_tests[] = {
 519   SadMxNParam(64, 64, &vpx_sad64x64_c),
 520   SadMxNParam(64, 32, &vpx_sad64x32_c),
 521   SadMxNParam(32, 64, &vpx_sad32x64_c),
 522   SadMxNParam(32, 32, &vpx_sad32x32_c),
 523   SadMxNParam(32, 16, &vpx_sad32x16_c),
 524   SadMxNParam(16, 32, &vpx_sad16x32_c),
 525   SadMxNParam(16, 16, &vpx_sad16x16_c),
 526   SadMxNParam(16, 8, &vpx_sad16x8_c),
 527   SadMxNParam(8, 16, &vpx_sad8x16_c),
 528   SadMxNParam(8, 8, &vpx_sad8x8_c),
 529   SadMxNParam(8, 4, &vpx_sad8x4_c),
 530   SadMxNParam(4, 8, &vpx_sad4x8_c),
 531   SadMxNParam(4, 4, &vpx_sad4x4_c),
 532 #if CONFIG_VP9_HIGHBITDEPTH
 533   SadMxNParam(64, 64, &vpx_highbd_sad64x64_c, 8),
 534   SadMxNParam(64, 32, &vpx_highbd_sad64x32_c, 8),
 535   SadMxNParam(32, 64, &vpx_highbd_sad32x64_c, 8),
 536   SadMxNParam(32, 32, &vpx_highbd_sad32x32_c, 8),
 537   SadMxNParam(32, 16, &vpx_highbd_sad32x16_c, 8),
 538   SadMxNParam(16, 32, &vpx_highbd_sad16x32_c, 8),
 539   SadMxNParam(16, 16, &vpx_highbd_sad16x16_c, 8),
 540   SadMxNParam(16, 8, &vpx_highbd_sad16x8_c, 8),
 541   SadMxNParam(8, 16, &vpx_highbd_sad8x16_c, 8),
 542   SadMxNParam(8, 8, &vpx_highbd_sad8x8_c, 8),
 543   SadMxNParam(8, 4, &vpx_highbd_sad8x4_c, 8),
 544   SadMxNParam(4, 8, &vpx_highbd_sad4x8_c, 8),
 545   SadMxNParam(4, 4, &vpx_highbd_sad4x4_c, 8),
 546   SadMxNParam(64, 64, &vpx_highbd_sad64x64_c, 10),
 547   SadMxNParam(64, 32, &vpx_highbd_sad64x32_c, 10),
 548   SadMxNParam(32, 64, &vpx_highbd_sad32x64_c, 10),
 549   SadMxNParam(32, 32, &vpx_highbd_sad32x32_c, 10),
 550   SadMxNParam(32, 16, &vpx_highbd_sad32x16_c, 10),
 551   SadMxNParam(16, 32, &vpx_highbd_sad16x32_c, 10),
 552   SadMxNParam(16, 16, &vpx_highbd_sad16x16_c, 10),
 553   SadMxNParam(16, 8, &vpx_highbd_sad16x8_c, 10),
 554   SadMxNParam(8, 16, &vpx_highbd_sad8x16_c, 10),
 555   SadMxNParam(8, 8, &vpx_highbd_sad8x8_c, 10),
 556   SadMxNParam(8, 4, &vpx_highbd_sad8x4_c, 10),
 557   SadMxNParam(4, 8, &vpx_highbd_sad4x8_c, 10),
 558   SadMxNParam(4, 4, &vpx_highbd_sad4x4_c, 10),
 559   SadMxNParam(64, 64, &vpx_highbd_sad64x64_c, 12),
 560   SadMxNParam(64, 32, &vpx_highbd_sad64x32_c, 12),
 561   SadMxNParam(32, 64, &vpx_highbd_sad32x64_c, 12),
 562   SadMxNParam(32, 32, &vpx_highbd_sad32x32_c, 12),
 563   SadMxNParam(32, 16, &vpx_highbd_sad32x16_c, 12),
 564   SadMxNParam(16, 32, &vpx_highbd_sad16x32_c, 12),
 565   SadMxNParam(16, 16, &vpx_highbd_sad16x16_c, 12),
 566   SadMxNParam(16, 8, &vpx_highbd_sad16x8_c, 12),
 567   SadMxNParam(8, 16, &vpx_highbd_sad8x16_c, 12),
 568   SadMxNParam(8, 8, &vpx_highbd_sad8x8_c, 12),
 569   SadMxNParam(8, 4, &vpx_highbd_sad8x4_c, 12),
 570   SadMxNParam(4, 8, &vpx_highbd_sad4x8_c, 12),
 571   SadMxNParam(4, 4, &vpx_highbd_sad4x4_c, 12),
 572 #endif  // CONFIG_VP9_HIGHBITDEPTH
 573 };
 574 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
 575
 576 const SadMxNAvgParam avg_c_tests[] = {
 577   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_c),
 578   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_c),
 579   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_c),
 580   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_c),
 581   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_c),
 582   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_c),
 583   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_c),
 584   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_c),
 585   SadMxNAvgParam(8, 16, &vpx_sad8x16_avg_c),
 586   SadMxNAvgParam(8, 8, &vpx_sad8x8_avg_c),
 587   SadMxNAvgParam(8, 4, &vpx_sad8x4_avg_c),
 588   SadMxNAvgParam(4, 8, &vpx_sad4x8_avg_c),
 589   SadMxNAvgParam(4, 4, &vpx_sad4x4_avg_c),
 590 #if CONFIG_VP9_HIGHBITDEPTH
 591   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_c, 8),
 592   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_c, 8),
 593   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_c, 8),
 594   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_c, 8),
 595   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_c, 8),
 596   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_c, 8),
 597   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_c, 8),
 598   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_c, 8),
 599   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_c, 8),
 600   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_c, 8),
 601   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_c, 8),
 602   SadMxNAvgParam(4, 8, &vpx_highbd_sad4x8_avg_c, 8),
 603   SadMxNAvgParam(4, 4, &vpx_highbd_sad4x4_avg_c, 8),
 604   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_c, 10),
 605   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_c, 10),
 606   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_c, 10),
 607   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_c, 10),
 608   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_c, 10),
 609   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_c, 10),
 610   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_c, 10),
 611   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_c, 10),
 612   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_c, 10),
 613   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_c, 10),
 614   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_c, 10),
 615   SadMxNAvgParam(4, 8, &vpx_highbd_sad4x8_avg_c, 10),
 616   SadMxNAvgParam(4, 4, &vpx_highbd_sad4x4_avg_c, 10),
 617   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_c, 12),
 618   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_c, 12),
 619   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_c, 12),
 620   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_c, 12),
 621   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_c, 12),
 622   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_c, 12),
 623   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_c, 12),
 624   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_c, 12),
 625   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_c, 12),
 626   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_c, 12),
 627   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_c, 12),
 628   SadMxNAvgParam(4, 8, &vpx_highbd_sad4x8_avg_c, 12),
 629   SadMxNAvgParam(4, 4, &vpx_highbd_sad4x4_avg_c, 12),
 630 #endif  // CONFIG_VP9_HIGHBITDEPTH
 631 };
 632 INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
 633
 634 const SadMxNx4Param x4d_c_tests[] = {
 635   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_c),
 636   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_c),
 637   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_c),
 638   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_c),
 639   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_c),
 640   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_c),
 641   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_c),
 642   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_c),
 643   SadMxNx4Param(8, 16, &vpx_sad8x16x4d_c),
 644   SadMxNx4Param(8, 8, &vpx_sad8x8x4d_c),
 645   SadMxNx4Param(8, 4, &vpx_sad8x4x4d_c),
 646   SadMxNx4Param(4, 8, &vpx_sad4x8x4d_c),
 647   SadMxNx4Param(4, 4, &vpx_sad4x4x4d_c),
 648 #if CONFIG_VP9_HIGHBITDEPTH
 649   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_c, 8),
 650   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_c, 8),
 651   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_c, 8),
 652   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_c, 8),
 653   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_c, 8),
 654   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_c, 8),
 655   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_c, 8),
 656   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_c, 8),
 657   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_c, 8),
 658   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_c, 8),
 659   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_c, 8),
 660   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_c, 8),
 661   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_c, 8),
 662   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_c, 10),
 663   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_c, 10),
 664   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_c, 10),
 665   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_c, 10),
 666   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_c, 10),
 667   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_c, 10),
 668   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_c, 10),
 669   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_c, 10),
 670   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_c, 10),
 671   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_c, 10),
 672   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_c, 10),
 673   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_c, 10),
 674   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_c, 10),
 675   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_c, 12),
 676   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_c, 12),
 677   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_c, 12),
 678   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_c, 12),
 679   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_c, 12),
 680   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_c, 12),
 681   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_c, 12),
 682   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_c, 12),
 683   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_c, 12),
 684   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_c, 12),
 685   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_c, 12),
 686   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_c, 12),
 687   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_c, 12),
 688 #endif  // CONFIG_VP9_HIGHBITDEPTH
 689 };
 690 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
 691
 692 //------------------------------------------------------------------------------
 693 // ARM functions
 694 #if HAVE_NEON
 695 const SadMxNParam neon_tests[] = {
 696   SadMxNParam(64, 64, &vpx_sad64x64_neon),
 697   SadMxNParam(64, 32, &vpx_sad64x32_neon),
 698   SadMxNParam(32, 32, &vpx_sad32x32_neon),
 699   SadMxNParam(16, 32, &vpx_sad16x32_neon),
 700   SadMxNParam(16, 16, &vpx_sad16x16_neon),
 701   SadMxNParam(16, 8, &vpx_sad16x8_neon),
 702   SadMxNParam(8, 16, &vpx_sad8x16_neon),
 703   SadMxNParam(8, 8, &vpx_sad8x8_neon),
 704   SadMxNParam(8, 4, &vpx_sad8x4_neon),
 705   SadMxNParam(4, 8, &vpx_sad4x8_neon),
 706   SadMxNParam(4, 4, &vpx_sad4x4_neon),
 707 };
 708 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
 709
 710 const SadMxNAvgParam avg_neon_tests[] = {
 711   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_neon),
 712   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_neon),
 713   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_neon),
 714   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_neon),
 715   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_neon),
 716   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_neon),
 717   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_neon),
 718   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_neon),
 719   SadMxNAvgParam(8, 16, &vpx_sad8x16_avg_neon),
 720   SadMxNAvgParam(8, 8, &vpx_sad8x8_avg_neon),
 721   SadMxNAvgParam(8, 4, &vpx_sad8x4_avg_neon),
 722   SadMxNAvgParam(4, 8, &vpx_sad4x8_avg_neon),
 723   SadMxNAvgParam(4, 4, &vpx_sad4x4_avg_neon),
 724 };
 725 INSTANTIATE_TEST_CASE_P(NEON, SADavgTest, ::testing::ValuesIn(avg_neon_tests));
 726
 727 const SadMxNx4Param x4d_neon_tests[] = {
 728   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_neon),
 729   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_neon),
 730   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_neon),
 731   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_neon),
 732   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_neon),
 733   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_neon),
 734   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_neon),
 735   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_neon),
 736   SadMxNx4Param(8, 16, &vpx_sad8x16x4d_neon),
 737   SadMxNx4Param(8, 8, &vpx_sad8x8x4d_neon),
 738   SadMxNx4Param(8, 4, &vpx_sad8x4x4d_neon),
 739   SadMxNx4Param(4, 8, &vpx_sad4x8x4d_neon),
 740   SadMxNx4Param(4, 4, &vpx_sad4x4x4d_neon),
 741 };
 742 INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
 743 #endif  // HAVE_NEON
 744
 745 //------------------------------------------------------------------------------
 746 // x86 functions
 747 #if HAVE_SSE2
 748 const SadMxNParam sse2_tests[] = {
 749   SadMxNParam(64, 64, &vpx_sad64x64_sse2),
 750   SadMxNParam(64, 32, &vpx_sad64x32_sse2),
 751   SadMxNParam(32, 64, &vpx_sad32x64_sse2),
 752   SadMxNParam(32, 32, &vpx_sad32x32_sse2),
 753   SadMxNParam(32, 16, &vpx_sad32x16_sse2),
 754   SadMxNParam(16, 32, &vpx_sad16x32_sse2),
 755   SadMxNParam(16, 16, &vpx_sad16x16_sse2),
 756   SadMxNParam(16, 8, &vpx_sad16x8_sse2),
 757   SadMxNParam(8, 16, &vpx_sad8x16_sse2),
 758   SadMxNParam(8, 8, &vpx_sad8x8_sse2),
 759   SadMxNParam(8, 4, &vpx_sad8x4_sse2),
 760   SadMxNParam(4, 8, &vpx_sad4x8_sse2),
 761   SadMxNParam(4, 4, &vpx_sad4x4_sse2),
 762 #if CONFIG_VP9_HIGHBITDEPTH
 763   SadMxNParam(64, 64, &vpx_highbd_sad64x64_sse2, 8),
 764   SadMxNParam(64, 32, &vpx_highbd_sad64x32_sse2, 8),
 765   SadMxNParam(32, 64, &vpx_highbd_sad32x64_sse2, 8),
 766   SadMxNParam(32, 32, &vpx_highbd_sad32x32_sse2, 8),
 767   SadMxNParam(32, 16, &vpx_highbd_sad32x16_sse2, 8),
 768   SadMxNParam(16, 32, &vpx_highbd_sad16x32_sse2, 8),
 769   SadMxNParam(16, 16, &vpx_highbd_sad16x16_sse2, 8),
 770   SadMxNParam(16, 8, &vpx_highbd_sad16x8_sse2, 8),
 771   SadMxNParam(8, 16, &vpx_highbd_sad8x16_sse2, 8),
 772   SadMxNParam(8, 8, &vpx_highbd_sad8x8_sse2, 8),
 773   SadMxNParam(8, 4, &vpx_highbd_sad8x4_sse2, 8),
 774   SadMxNParam(64, 64, &vpx_highbd_sad64x64_sse2, 10),
 775   SadMxNParam(64, 32, &vpx_highbd_sad64x32_sse2, 10),
 776   SadMxNParam(32, 64, &vpx_highbd_sad32x64_sse2, 10),
 777   SadMxNParam(32, 32, &vpx_highbd_sad32x32_sse2, 10),
 778   SadMxNParam(32, 16, &vpx_highbd_sad32x16_sse2, 10),
 779   SadMxNParam(16, 32, &vpx_highbd_sad16x32_sse2, 10),
 780   SadMxNParam(16, 16, &vpx_highbd_sad16x16_sse2, 10),
 781   SadMxNParam(16, 8, &vpx_highbd_sad16x8_sse2, 10),
 782   SadMxNParam(8, 16, &vpx_highbd_sad8x16_sse2, 10),
 783   SadMxNParam(8, 8, &vpx_highbd_sad8x8_sse2, 10),
 784   SadMxNParam(8, 4, &vpx_highbd_sad8x4_sse2, 10),
 785   SadMxNParam(64, 64, &vpx_highbd_sad64x64_sse2, 12),
 786   SadMxNParam(64, 32, &vpx_highbd_sad64x32_sse2, 12),
 787   SadMxNParam(32, 64, &vpx_highbd_sad32x64_sse2, 12),
 788   SadMxNParam(32, 32, &vpx_highbd_sad32x32_sse2, 12),
 789   SadMxNParam(32, 16, &vpx_highbd_sad32x16_sse2, 12),
 790   SadMxNParam(16, 32, &vpx_highbd_sad16x32_sse2, 12),
 791   SadMxNParam(16, 16, &vpx_highbd_sad16x16_sse2, 12),
 792   SadMxNParam(16, 8, &vpx_highbd_sad16x8_sse2, 12),
 793   SadMxNParam(8, 16, &vpx_highbd_sad8x16_sse2, 12),
 794   SadMxNParam(8, 8, &vpx_highbd_sad8x8_sse2, 12),
 795   SadMxNParam(8, 4, &vpx_highbd_sad8x4_sse2, 12),
 796 #endif  // CONFIG_VP9_HIGHBITDEPTH
 797 };
 798 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
 799
 800 const SadMxNAvgParam avg_sse2_tests[] = {
 801   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_sse2),
 802   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_sse2),
 803   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_sse2),
 804   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_sse2),
 805   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_sse2),
 806   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_sse2),
 807   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_sse2),
 808   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_sse2),
 809   SadMxNAvgParam(8, 16, &vpx_sad8x16_avg_sse2),
 810   SadMxNAvgParam(8, 8, &vpx_sad8x8_avg_sse2),
 811   SadMxNAvgParam(8, 4, &vpx_sad8x4_avg_sse2),
 812   SadMxNAvgParam(4, 8, &vpx_sad4x8_avg_sse2),
 813   SadMxNAvgParam(4, 4, &vpx_sad4x4_avg_sse2),
 814 #if CONFIG_VP9_HIGHBITDEPTH
 815   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_sse2, 8),
 816   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_sse2, 8),
 817   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_sse2, 8),
 818   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_sse2, 8),
 819   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_sse2, 8),
 820   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_sse2, 8),
 821   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_sse2, 8),
 822   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_sse2, 8),
 823   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_sse2, 8),
 824   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_sse2, 8),
 825   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_sse2, 8),
 826   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_sse2, 10),
 827   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_sse2, 10),
 828   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_sse2, 10),
 829   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_sse2, 10),
 830   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_sse2, 10),
 831   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_sse2, 10),
 832   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_sse2, 10),
 833   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_sse2, 10),
 834   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_sse2, 10),
 835   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_sse2, 10),
 836   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_sse2, 10),
 837   SadMxNAvgParam(64, 64, &vpx_highbd_sad64x64_avg_sse2, 12),
 838   SadMxNAvgParam(64, 32, &vpx_highbd_sad64x32_avg_sse2, 12),
 839   SadMxNAvgParam(32, 64, &vpx_highbd_sad32x64_avg_sse2, 12),
 840   SadMxNAvgParam(32, 32, &vpx_highbd_sad32x32_avg_sse2, 12),
 841   SadMxNAvgParam(32, 16, &vpx_highbd_sad32x16_avg_sse2, 12),
 842   SadMxNAvgParam(16, 32, &vpx_highbd_sad16x32_avg_sse2, 12),
 843   SadMxNAvgParam(16, 16, &vpx_highbd_sad16x16_avg_sse2, 12),
 844   SadMxNAvgParam(16, 8, &vpx_highbd_sad16x8_avg_sse2, 12),
 845   SadMxNAvgParam(8, 16, &vpx_highbd_sad8x16_avg_sse2, 12),
 846   SadMxNAvgParam(8, 8, &vpx_highbd_sad8x8_avg_sse2, 12),
 847   SadMxNAvgParam(8, 4, &vpx_highbd_sad8x4_avg_sse2, 12),
 848 #endif  // CONFIG_VP9_HIGHBITDEPTH
 849 };
 850 INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
 851
 852 const SadMxNx4Param x4d_sse2_tests[] = {
 853   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_sse2),
 854   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_sse2),
 855   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_sse2),
 856   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_sse2),
 857   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_sse2),
 858   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_sse2),
 859   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_sse2),
 860   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_sse2),
 861   SadMxNx4Param(8, 16, &vpx_sad8x16x4d_sse2),
 862   SadMxNx4Param(8, 8, &vpx_sad8x8x4d_sse2),
 863   SadMxNx4Param(8, 4, &vpx_sad8x4x4d_sse2),
 864   SadMxNx4Param(4, 8, &vpx_sad4x8x4d_sse2),
 865   SadMxNx4Param(4, 4, &vpx_sad4x4x4d_sse2),
 866 #if CONFIG_VP9_HIGHBITDEPTH
 867   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_sse2, 8),
 868   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_sse2, 8),
 869   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_sse2, 8),
 870   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_sse2, 8),
 871   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_sse2, 8),
 872   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_sse2, 8),
 873   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_sse2, 8),
 874   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_sse2, 8),
 875   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_sse2, 8),
 876   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_sse2, 8),
 877   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_sse2, 8),
 878   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_sse2, 8),
 879   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_sse2, 8),
 880   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_sse2, 10),
 881   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_sse2, 10),
 882   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_sse2, 10),
 883   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_sse2, 10),
 884   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_sse2, 10),
 885   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_sse2, 10),
 886   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_sse2, 10),
 887   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_sse2, 10),
 888   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_sse2, 10),
 889   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_sse2, 10),
 890   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_sse2, 10),
 891   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_sse2, 10),
 892   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_sse2, 10),
 893   SadMxNx4Param(64, 64, &vpx_highbd_sad64x64x4d_sse2, 12),
 894   SadMxNx4Param(64, 32, &vpx_highbd_sad64x32x4d_sse2, 12),
 895   SadMxNx4Param(32, 64, &vpx_highbd_sad32x64x4d_sse2, 12),
 896   SadMxNx4Param(32, 32, &vpx_highbd_sad32x32x4d_sse2, 12),
 897   SadMxNx4Param(32, 16, &vpx_highbd_sad32x16x4d_sse2, 12),
 898   SadMxNx4Param(16, 32, &vpx_highbd_sad16x32x4d_sse2, 12),
 899   SadMxNx4Param(16, 16, &vpx_highbd_sad16x16x4d_sse2, 12),
 900   SadMxNx4Param(16, 8, &vpx_highbd_sad16x8x4d_sse2, 12),
 901   SadMxNx4Param(8, 16, &vpx_highbd_sad8x16x4d_sse2, 12),
 902   SadMxNx4Param(8, 8, &vpx_highbd_sad8x8x4d_sse2, 12),
 903   SadMxNx4Param(8, 4, &vpx_highbd_sad8x4x4d_sse2, 12),
 904   SadMxNx4Param(4, 8, &vpx_highbd_sad4x8x4d_sse2, 12),
 905   SadMxNx4Param(4, 4, &vpx_highbd_sad4x4x4d_sse2, 12),
 906 #endif  // CONFIG_VP9_HIGHBITDEPTH
 907 };
 908 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
 909 #endif  // HAVE_SSE2
 910
 911 #if HAVE_SSE3
 912 // Only functions are x3, which do not have tests.
 913 #endif  // HAVE_SSE3
 914
 915 #if HAVE_SSSE3
 916 // Only functions are x3, which do not have tests.
 917 #endif  // HAVE_SSSE3
 918
 919 #if HAVE_SSE4_1
 920 // Only functions are x8, which do not have tests.
 921 #endif  // HAVE_SSE4_1
 922
 923 #if HAVE_AVX2
 924 const SadMxNParam avx2_tests[] = {
 925   SadMxNParam(64, 64, &vpx_sad64x64_avx2),
 926   SadMxNParam(64, 32, &vpx_sad64x32_avx2),
 927   SadMxNParam(32, 64, &vpx_sad32x64_avx2),
 928   SadMxNParam(32, 32, &vpx_sad32x32_avx2),
 929   SadMxNParam(32, 16, &vpx_sad32x16_avx2),
 930 };
 931 INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
 932
 933 const SadMxNAvgParam avg_avx2_tests[] = {
 934   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_avx2),
 935   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_avx2),
 936   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_avx2),
 937   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_avx2),
 938   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_avx2),
 939 };
 940 INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
 941
 942 const SadMxNx4Param x4d_avx2_tests[] = {
 943   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_avx2),
 944   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_avx2),
 945 };
 946 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
 947 #endif  // HAVE_AVX2
 948
 949 #if HAVE_AVX512
 950 const SadMxNx4Param x4d_avx512_tests[] = {
 951   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_avx512),
 952 };
 953 INSTANTIATE_TEST_CASE_P(AVX512, SADx4Test,
 954                         ::testing::ValuesIn(x4d_avx512_tests));
 955 #endif  // HAVE_AVX512
 956
 957 //------------------------------------------------------------------------------
 958 // MIPS functions
 959 #if HAVE_MSA
 960 const SadMxNParam msa_tests[] = {
 961   SadMxNParam(64, 64, &vpx_sad64x64_msa),
 962   SadMxNParam(64, 32, &vpx_sad64x32_msa),
 963   SadMxNParam(32, 64, &vpx_sad32x64_msa),
 964   SadMxNParam(32, 32, &vpx_sad32x32_msa),
 965   SadMxNParam(32, 16, &vpx_sad32x16_msa),
 966   SadMxNParam(16, 32, &vpx_sad16x32_msa),
 967   SadMxNParam(16, 16, &vpx_sad16x16_msa),
 968   SadMxNParam(16, 8, &vpx_sad16x8_msa),
 969   SadMxNParam(8, 16, &vpx_sad8x16_msa),
 970   SadMxNParam(8, 8, &vpx_sad8x8_msa),
 971   SadMxNParam(8, 4, &vpx_sad8x4_msa),
 972   SadMxNParam(4, 8, &vpx_sad4x8_msa),
 973   SadMxNParam(4, 4, &vpx_sad4x4_msa),
 974 };
 975 INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
 976
 977 const SadMxNAvgParam avg_msa_tests[] = {
 978   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_msa),
 979   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_msa),
 980   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_msa),
 981   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_msa),
 982   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_msa),
 983   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_msa),
 984   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_msa),
 985   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_msa),
 986   SadMxNAvgParam(8, 16, &vpx_sad8x16_avg_msa),
 987   SadMxNAvgParam(8, 8, &vpx_sad8x8_avg_msa),
 988   SadMxNAvgParam(8, 4, &vpx_sad8x4_avg_msa),
 989   SadMxNAvgParam(4, 8, &vpx_sad4x8_avg_msa),
 990   SadMxNAvgParam(4, 4, &vpx_sad4x4_avg_msa),
 991 };
 992 INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
 993
 994 const SadMxNx4Param x4d_msa_tests[] = {
 995   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_msa),
 996   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_msa),
 997   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_msa),
 998   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_msa),
 999   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_msa),
1000   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_msa),
1001   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_msa),
1002   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_msa),
1003   SadMxNx4Param(8, 16, &vpx_sad8x16x4d_msa),
1004   SadMxNx4Param(8, 8, &vpx_sad8x8x4d_msa),
1005   SadMxNx4Param(8, 4, &vpx_sad8x4x4d_msa),
1006   SadMxNx4Param(4, 8, &vpx_sad4x8x4d_msa),
1007   SadMxNx4Param(4, 4, &vpx_sad4x4x4d_msa),
1008 };
1009 INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
1010 #endif  // HAVE_MSA
1011
1012 //------------------------------------------------------------------------------
1013 // VSX functions
1014 #if HAVE_VSX
1015 const SadMxNParam vsx_tests[] = {
1016   SadMxNParam(64, 64, &vpx_sad64x64_vsx),
1017   SadMxNParam(64, 32, &vpx_sad64x32_vsx),
1018   SadMxNParam(32, 64, &vpx_sad32x64_vsx),
1019   SadMxNParam(32, 32, &vpx_sad32x32_vsx),
1020   SadMxNParam(32, 16, &vpx_sad32x16_vsx),
1021   SadMxNParam(16, 32, &vpx_sad16x32_vsx),
1022   SadMxNParam(16, 16, &vpx_sad16x16_vsx),
1023   SadMxNParam(16, 8, &vpx_sad16x8_vsx),
1024   SadMxNParam(8, 16, &vpx_sad8x16_vsx),
1025   SadMxNParam(8, 8, &vpx_sad8x8_vsx),
1026   SadMxNParam(8, 4, &vpx_sad8x4_vsx),
1027 };
1028 INSTANTIATE_TEST_CASE_P(VSX, SADTest, ::testing::ValuesIn(vsx_tests));
1029
1030 const SadMxNAvgParam avg_vsx_tests[] = {
1031   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_vsx),
1032   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_vsx),
1033   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_vsx),
1034   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_vsx),
1035   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_vsx),
1036   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_vsx),
1037   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_vsx),
1038   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_vsx),
1039 };
1040 INSTANTIATE_TEST_CASE_P(VSX, SADavgTest, ::testing::ValuesIn(avg_vsx_tests));
1041
1042 const SadMxNx4Param x4d_vsx_tests[] = {
1043   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_vsx),
1044   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_vsx),
1045   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_vsx),
1046   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_vsx),
1047   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_vsx),
1048   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_vsx),
1049   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_vsx),
1050   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_vsx),
1051 };
1052 INSTANTIATE_TEST_CASE_P(VSX, SADx4Test, ::testing::ValuesIn(x4d_vsx_tests));
1053 #endif  // HAVE_VSX
1054
1055 //------------------------------------------------------------------------------
1056 // Loongson functions
1057 #if HAVE_MMI
1058 const SadMxNParam mmi_tests[] = {
1059   SadMxNParam(64, 64, &vpx_sad64x64_mmi),
1060   SadMxNParam(64, 32, &vpx_sad64x32_mmi),
1061   SadMxNParam(32, 64, &vpx_sad32x64_mmi),
1062   SadMxNParam(32, 32, &vpx_sad32x32_mmi),
1063   SadMxNParam(32, 16, &vpx_sad32x16_mmi),
1064   SadMxNParam(16, 32, &vpx_sad16x32_mmi),
1065   SadMxNParam(16, 16, &vpx_sad16x16_mmi),
1066   SadMxNParam(16, 8, &vpx_sad16x8_mmi),
1067   SadMxNParam(8, 16, &vpx_sad8x16_mmi),
1068   SadMxNParam(8, 8, &vpx_sad8x8_mmi),
1069   SadMxNParam(8, 4, &vpx_sad8x4_mmi),
1070   SadMxNParam(4, 8, &vpx_sad4x8_mmi),
1071   SadMxNParam(4, 4, &vpx_sad4x4_mmi),
1072 };
1073 INSTANTIATE_TEST_CASE_P(MMI, SADTest, ::testing::ValuesIn(mmi_tests));
1074
1075 const SadMxNAvgParam avg_mmi_tests[] = {
1076   SadMxNAvgParam(64, 64, &vpx_sad64x64_avg_mmi),
1077   SadMxNAvgParam(64, 32, &vpx_sad64x32_avg_mmi),
1078   SadMxNAvgParam(32, 64, &vpx_sad32x64_avg_mmi),
1079   SadMxNAvgParam(32, 32, &vpx_sad32x32_avg_mmi),
1080   SadMxNAvgParam(32, 16, &vpx_sad32x16_avg_mmi),
1081   SadMxNAvgParam(16, 32, &vpx_sad16x32_avg_mmi),
1082   SadMxNAvgParam(16, 16, &vpx_sad16x16_avg_mmi),
1083   SadMxNAvgParam(16, 8, &vpx_sad16x8_avg_mmi),
1084   SadMxNAvgParam(8, 16, &vpx_sad8x16_avg_mmi),
1085   SadMxNAvgParam(8, 8, &vpx_sad8x8_avg_mmi),
1086   SadMxNAvgParam(8, 4, &vpx_sad8x4_avg_mmi),
1087   SadMxNAvgParam(4, 8, &vpx_sad4x8_avg_mmi),
1088   SadMxNAvgParam(4, 4, &vpx_sad4x4_avg_mmi),
1089 };
1090 INSTANTIATE_TEST_CASE_P(MMI, SADavgTest, ::testing::ValuesIn(avg_mmi_tests));
1091
1092 const SadMxNx4Param x4d_mmi_tests[] = {
1093   SadMxNx4Param(64, 64, &vpx_sad64x64x4d_mmi),
1094   SadMxNx4Param(64, 32, &vpx_sad64x32x4d_mmi),
1095   SadMxNx4Param(32, 64, &vpx_sad32x64x4d_mmi),
1096   SadMxNx4Param(32, 32, &vpx_sad32x32x4d_mmi),
1097   SadMxNx4Param(32, 16, &vpx_sad32x16x4d_mmi),
1098   SadMxNx4Param(16, 32, &vpx_sad16x32x4d_mmi),
1099   SadMxNx4Param(16, 16, &vpx_sad16x16x4d_mmi),
1100   SadMxNx4Param(16, 8, &vpx_sad16x8x4d_mmi),
1101   SadMxNx4Param(8, 16, &vpx_sad8x16x4d_mmi),
1102   SadMxNx4Param(8, 8, &vpx_sad8x8x4d_mmi),
1103   SadMxNx4Param(8, 4, &vpx_sad8x4x4d_mmi),
1104   SadMxNx4Param(4, 8, &vpx_sad4x8x4d_mmi),
1105   SadMxNx4Param(4, 4, &vpx_sad4x4x4d_mmi),
1106 };
1107 INSTANTIATE_TEST_CASE_P(MMI, SADx4Test, ::testing::ValuesIn(x4d_mmi_tests));
1108 #endif  // HAVE_MMI
1109 }  // namespace