test/masked_sad_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 #include <math.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <tuple>
  15
  16 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  17 #include "test/acm_random.h"
  18 #include "test/register_state_check.h"
  19 #include "test/util.h"
  20
  21 #include "config/aom_config.h"
  22 #include "config/aom_dsp_rtcd.h"
  23
  24 #include "aom/aom_integer.h"
  25
  26 using libaom_test::ACMRandom;
  27
  28 namespace {
  29 const int number_of_iterations = 200;
  30
  31 typedef unsigned int (*MaskedSADFunc)(const uint8_t *src, int src_stride,
  32                                       const uint8_t *ref, int ref_stride,
  33                                       const uint8_t *second_pred,
  34                                       const uint8_t *msk, int msk_stride,
  35                                       int invert_mask);
  36 typedef std::tuple<MaskedSADFunc, MaskedSADFunc> MaskedSADParam;
  37
  38 typedef void (*MaskedSADx4Func)(const uint8_t *src, int src_stride,
  39                                 const uint8_t *ref[], int ref_stride,
  40                                 const uint8_t *second_pred, const uint8_t *msk,
  41                                 int msk_stride, int invert_mask,
  42                                 unsigned sads[]);
  43
  44 typedef std::tuple<MaskedSADx4Func, MaskedSADx4Func> MaskedSADx4Param;
  45
  46 class MaskedSADTestBase : public ::testing::Test {
  47  public:
  48   virtual ~MaskedSADTestBase() {}
  49   virtual void SetUp() = 0;
  50   virtual void runRef(const uint8_t *src_ptr, int src_stride,
  51                       const uint8_t *ref_ptr[], int ref_stride,
  52                       const uint8_t *second_pred, const uint8_t *msk,
  53                       int msk_stride, int inv_mask, unsigned sads[],
  54                       int times) = 0;
  55   virtual void runTest(const uint8_t *src_ptr, int src_stride,
  56                        const uint8_t *ref_ptr[], int ref_stride,
  57                        const uint8_t *second_pred, const uint8_t *msk,
  58                        int msk_stride, int inv_mask, unsigned sads[],
  59                        int times) = 0;
  60
  61   virtual void TearDown() {}
  62   void runMaskedSADTest(int run_times);
  63 };
  64
  65 class MaskedSADTest : public MaskedSADTestBase,
  66                       public ::testing::WithParamInterface<MaskedSADParam> {
  67  public:
  68   virtual ~MaskedSADTest() {}
  69   virtual void SetUp() {
  70     maskedSAD_op_ = GET_PARAM(0);
  71     ref_maskedSAD_op_ = GET_PARAM(1);
  72   }
  73
  74   virtual void runRef(const uint8_t *src_ptr, int src_stride,
  75                       const uint8_t *ref_ptr[], int ref_stride,
  76                       const uint8_t *second_pred, const uint8_t *msk,
  77                       int msk_stride, int inv_mask, unsigned sads[], int times);
  78   virtual void runTest(const uint8_t *src_ptr, int src_stride,
  79                        const uint8_t *ref_ptr[], int ref_stride,
  80                        const uint8_t *second_pred, const uint8_t *msk,
  81                        int msk_stride, int inv_mask, unsigned sads[],
  82                        int times);
  83
  84  protected:
  85   MaskedSADFunc maskedSAD_op_;
  86   MaskedSADFunc ref_maskedSAD_op_;
  87 };
  88 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MaskedSADTest);
  89
  90 class MaskedSADx4Test : public MaskedSADTestBase,
  91                         public ::testing::WithParamInterface<MaskedSADx4Param> {
  92  public:
  93   virtual ~MaskedSADx4Test() {}
  94   virtual void SetUp() {
  95     maskedSAD_op_ = GET_PARAM(0);
  96     ref_maskedSAD_op_ = GET_PARAM(1);
  97   }
  98   virtual void runRef(const uint8_t *src_ptr, int src_stride,
  99                       const uint8_t *ref_ptr[], int ref_stride,
 100                       const uint8_t *second_pred, const uint8_t *msk,
 101                       int msk_stride, int inv_mask, unsigned sads[], int times);
 102   virtual void runTest(const uint8_t *src_ptr, int src_stride,
 103                        const uint8_t *ref_ptr[], int ref_stride,
 104                        const uint8_t *second_pred, const uint8_t *msk,
 105                        int msk_stride, int inv_mask, unsigned sads[],
 106                        int times);
 107
 108  protected:
 109   MaskedSADx4Func maskedSAD_op_;
 110   MaskedSADx4Func ref_maskedSAD_op_;
 111 };
 112 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MaskedSADx4Test);
 113
 114 void MaskedSADTest::runRef(const uint8_t *src_ptr, int src_stride,
 115                            const uint8_t *ref_ptr[], int ref_stride,
 116                            const uint8_t *second_pred, const uint8_t *msk,
 117                            int msk_stride, int invert_mask, unsigned sads[],
 118                            int times) {
 119   for (int repeat = 0; repeat < times; ++repeat) {
 120     sads[0] = ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
 121                                 second_pred, msk, msk_stride, invert_mask);
 122   }
 123 }
 124
 125 void MaskedSADTest::runTest(const uint8_t *src_ptr, int src_stride,
 126                             const uint8_t *ref_ptr[], int ref_stride,
 127                             const uint8_t *second_pred, const uint8_t *msk,
 128                             int msk_stride, int invert_mask, unsigned sads[],
 129                             int times) {
 130   if (times == 1) {
 131     sads[0] = maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
 132                             second_pred, msk, msk_stride, invert_mask);
 133   } else {
 134     for (int repeat = 0; repeat < times; ++repeat) {
 135       API_REGISTER_STATE_CHECK(
 136           sads[0] = maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
 137                                   second_pred, msk, msk_stride, invert_mask));
 138     }
 139   }
 140 }
 141
 142 void MaskedSADx4Test::runRef(const uint8_t *src_ptr, int src_stride,
 143                              const uint8_t *ref_ptr[], int ref_stride,
 144                              const uint8_t *second_pred, const uint8_t *msk,
 145                              int msk_stride, int invert_mask, unsigned sads[],
 146                              int times) {
 147   for (int repeat = 0; repeat < times; ++repeat) {
 148     ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride, second_pred,
 149                       msk, msk_stride, invert_mask, sads);
 150   }
 151 }
 152
 153 void MaskedSADx4Test::runTest(const uint8_t *src_ptr, int src_stride,
 154                               const uint8_t *ref_ptr[], int ref_stride,
 155                               const uint8_t *second_pred, const uint8_t *msk,
 156                               int msk_stride, int invert_mask, unsigned sads[],
 157                               int times) {
 158   if (times == 1) {
 159     API_REGISTER_STATE_CHECK(maskedSAD_op_(src_ptr, src_stride, ref_ptr,
 160                                            ref_stride, second_pred, msk,
 161                                            msk_stride, invert_mask, sads));
 162   } else {
 163     for (int repeat = 0; repeat < times; ++repeat) {
 164       maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride, second_pred, msk,
 165                     msk_stride, invert_mask, sads);
 166     }
 167   }
 168 }
 169
 170 void MaskedSADTestBase::runMaskedSADTest(int run_times) {
 171   ACMRandom rnd(ACMRandom::DeterministicSeed());
 172   const unsigned kBlockSize = MAX_SB_SIZE * MAX_SB_SIZE;
 173   DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 174   DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE * 4]);
 175   DECLARE_ALIGNED(16, uint8_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 176   DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 177
 178   const uint8_t *refs[] = { ref_ptr, ref_ptr + kBlockSize,
 179                             ref_ptr + 2 * kBlockSize,
 180                             ref_ptr + 3 * kBlockSize };
 181   unsigned sads[] = { 0, 0, 0, 0 };
 182   unsigned sads_ref[] = { 0, 0, 0, 0 };
 183   int err_count = 0;
 184   int first_failure = -1;
 185   int src_stride = MAX_SB_SIZE;
 186   int ref_stride = MAX_SB_SIZE;
 187   int msk_stride = MAX_SB_SIZE;
 188   const int iters = run_times == 1 ? number_of_iterations : 1;
 189   for (int i = 0; i < iters; ++i) {
 190     for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
 191       src_ptr[j] = rnd.Rand8();
 192       ref_ptr[j] = rnd.Rand8();
 193       (ref_ptr + kBlockSize)[j] = rnd.Rand8();
 194       (ref_ptr + 2 * kBlockSize)[j] = rnd.Rand8();
 195       (ref_ptr + 3 * kBlockSize)[j] = rnd.Rand8();
 196       second_pred_ptr[j] = rnd.Rand8();
 197       msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
 198       assert(msk_ptr[j] <= 64);
 199     }
 200
 201     for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
 202       aom_usec_timer timer;
 203       aom_usec_timer_start(&timer);
 204       runRef(src_ptr, src_stride, refs, ref_stride, second_pred_ptr, msk_ptr,
 205              msk_stride, invert_mask, sads_ref, run_times);
 206       aom_usec_timer_mark(&timer);
 207       const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));
 208
 209       aom_usec_timer_start(&timer);
 210       runTest(src_ptr, src_stride, refs, ref_stride, second_pred_ptr, msk_ptr,
 211               msk_stride, invert_mask, sads, run_times);
 212       aom_usec_timer_mark(&timer);
 213       const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));
 214
 215       if (run_times > 10) {
 216         printf("%7.2f/%7.2fns", time1, time2);
 217         printf("(%3.2f)\n", time1 / time2);
 218       }
 219       if (sads_ref[0] != sads[0] || sads_ref[1] != sads[1] ||
 220           sads_ref[2] != sads[2] || sads_ref[3] != sads[3]) {
 221         err_count++;
 222         if (first_failure == -1) first_failure = i;
 223       }
 224     }
 225   }
 226   EXPECT_EQ(0, err_count) << "Error: Masked SAD Test,  output doesn't match. "
 227                           << "First failed at test case " << first_failure;
 228 }
 229
 230 TEST_P(MaskedSADTest, OperationCheck) { runMaskedSADTest(1); }
 231
 232 TEST_P(MaskedSADTest, DISABLED_Speed) { runMaskedSADTest(2000000); }
 233
 234 TEST_P(MaskedSADx4Test, OperationCheck) { runMaskedSADTest(1); }
 235
 236 TEST_P(MaskedSADx4Test, DISABLED_Speed) { runMaskedSADTest(2000000); }
 237
 238 #if CONFIG_AV1_HIGHBITDEPTH
 239 typedef unsigned int (*HighbdMaskedSADFunc)(const uint8_t *src, int src_stride,
 240                                             const uint8_t *ref, int ref_stride,
 241                                             const uint8_t *second_pred,
 242                                             const uint8_t *msk, int msk_stride,
 243                                             int invert_mask);
 244 typedef std::tuple<HighbdMaskedSADFunc, HighbdMaskedSADFunc>
 245     HighbdMaskedSADParam;
 246
 247 class HighbdMaskedSADTest
 248     : public ::testing::TestWithParam<HighbdMaskedSADParam> {
 249  public:
 250   virtual ~HighbdMaskedSADTest() {}
 251   virtual void SetUp() {
 252     maskedSAD_op_ = GET_PARAM(0);
 253     ref_maskedSAD_op_ = GET_PARAM(1);
 254   }
 255
 256   virtual void TearDown() {}
 257   void runHighbdMaskedSADTest(int run_times);
 258
 259  protected:
 260   HighbdMaskedSADFunc maskedSAD_op_;
 261   HighbdMaskedSADFunc ref_maskedSAD_op_;
 262 };
 263 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HighbdMaskedSADTest);
 264
 265 void HighbdMaskedSADTest::runHighbdMaskedSADTest(int run_times) {
 266   unsigned int ref_ret = 0, ret = 1;
 267   ACMRandom rnd(ACMRandom::DeterministicSeed());
 268   DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 269   DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 270   DECLARE_ALIGNED(16, uint16_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 271   DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
 272   uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
 273   uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
 274   uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
 275   int err_count = 0;
 276   int first_failure = -1;
 277   int src_stride = MAX_SB_SIZE;
 278   int ref_stride = MAX_SB_SIZE;
 279   int msk_stride = MAX_SB_SIZE;
 280   const int iters = run_times == 1 ? number_of_iterations : 1;
 281   for (int i = 0; i < iters; ++i) {
 282     for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
 283       src_ptr[j] = rnd.Rand16() & 0xfff;
 284       ref_ptr[j] = rnd.Rand16() & 0xfff;
 285       second_pred_ptr[j] = rnd.Rand16() & 0xfff;
 286       msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
 287     }
 288
 289     for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
 290       aom_usec_timer timer;
 291       aom_usec_timer_start(&timer);
 292       for (int repeat = 0; repeat < run_times; ++repeat) {
 293         ref_ret = ref_maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
 294                                     second_pred8_ptr, msk_ptr, msk_stride,
 295                                     invert_mask);
 296       }
 297       aom_usec_timer_mark(&timer);
 298       const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));
 299       aom_usec_timer_start(&timer);
 300       if (run_times == 1) {
 301         API_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride,
 302                                                      ref8_ptr, ref_stride,
 303                                                      second_pred8_ptr, msk_ptr,
 304                                                      msk_stride, invert_mask));
 305       } else {
 306         for (int repeat = 0; repeat < run_times; ++repeat) {
 307           ret =
 308               maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
 309                             second_pred8_ptr, msk_ptr, msk_stride, invert_mask);
 310         }
 311       }
 312       aom_usec_timer_mark(&timer);
 313       const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));
 314       if (run_times > 10) {
 315         printf("%7.2f/%7.2fns", time1, time2);
 316         printf("(%3.2f)\n", time1 / time2);
 317       }
 318       if (ret != ref_ret) {
 319         err_count++;
 320         if (first_failure == -1) first_failure = i;
 321       }
 322     }
 323   }
 324   EXPECT_EQ(0, err_count)
 325       << "Error: High BD Masked SAD Test, output doesn't match. "
 326       << "First failed at test case " << first_failure;
 327 }
 328
 329 TEST_P(HighbdMaskedSADTest, OperationCheck) { runHighbdMaskedSADTest(1); }
 330
 331 TEST_P(HighbdMaskedSADTest, DISABLED_Speed) { runHighbdMaskedSADTest(1000000); }
 332 #endif  // CONFIG_AV1_HIGHBITDEPTH
 333
 334 using std::make_tuple;
 335
 336 #if HAVE_SSSE3
 337 const MaskedSADParam msad_test[] = {
 338   make_tuple(&aom_masked_sad4x4_ssse3, &aom_masked_sad4x4_c),
 339   make_tuple(&aom_masked_sad4x8_ssse3, &aom_masked_sad4x8_c),
 340   make_tuple(&aom_masked_sad8x4_ssse3, &aom_masked_sad8x4_c),
 341   make_tuple(&aom_masked_sad8x8_ssse3, &aom_masked_sad8x8_c),
 342   make_tuple(&aom_masked_sad8x16_ssse3, &aom_masked_sad8x16_c),
 343   make_tuple(&aom_masked_sad16x8_ssse3, &aom_masked_sad16x8_c),
 344   make_tuple(&aom_masked_sad16x16_ssse3, &aom_masked_sad16x16_c),
 345   make_tuple(&aom_masked_sad16x32_ssse3, &aom_masked_sad16x32_c),
 346   make_tuple(&aom_masked_sad32x16_ssse3, &aom_masked_sad32x16_c),
 347   make_tuple(&aom_masked_sad32x32_ssse3, &aom_masked_sad32x32_c),
 348   make_tuple(&aom_masked_sad32x64_ssse3, &aom_masked_sad32x64_c),
 349   make_tuple(&aom_masked_sad64x32_ssse3, &aom_masked_sad64x32_c),
 350   make_tuple(&aom_masked_sad64x64_ssse3, &aom_masked_sad64x64_c),
 351   make_tuple(&aom_masked_sad64x128_ssse3, &aom_masked_sad64x128_c),
 352   make_tuple(&aom_masked_sad128x64_ssse3, &aom_masked_sad128x64_c),
 353   make_tuple(&aom_masked_sad128x128_ssse3, &aom_masked_sad128x128_c),
 354 #if !CONFIG_REALTIME_ONLY
 355   make_tuple(&aom_masked_sad4x16_ssse3, &aom_masked_sad4x16_c),
 356   make_tuple(&aom_masked_sad16x4_ssse3, &aom_masked_sad16x4_c),
 357   make_tuple(&aom_masked_sad8x32_ssse3, &aom_masked_sad8x32_c),
 358   make_tuple(&aom_masked_sad32x8_ssse3, &aom_masked_sad32x8_c),
 359   make_tuple(&aom_masked_sad16x64_ssse3, &aom_masked_sad16x64_c),
 360   make_tuple(&aom_masked_sad64x16_ssse3, &aom_masked_sad64x16_c),
 361 #endif
 362 };
 363
 364 INSTANTIATE_TEST_SUITE_P(SSSE3, MaskedSADTest, ::testing::ValuesIn(msad_test));
 365
 366 const MaskedSADx4Param msadx4_test[] = {
 367   make_tuple(&aom_masked_sad4x4x4d_ssse3, &aom_masked_sad4x4x4d_c),
 368   make_tuple(&aom_masked_sad4x8x4d_ssse3, &aom_masked_sad4x8x4d_c),
 369   make_tuple(&aom_masked_sad8x4x4d_ssse3, &aom_masked_sad8x4x4d_c),
 370   make_tuple(&aom_masked_sad8x8x4d_ssse3, &aom_masked_sad8x8x4d_c),
 371   make_tuple(&aom_masked_sad8x16x4d_ssse3, &aom_masked_sad8x16x4d_c),
 372   make_tuple(&aom_masked_sad16x8x4d_ssse3, &aom_masked_sad16x8x4d_c),
 373   make_tuple(&aom_masked_sad16x16x4d_ssse3, &aom_masked_sad16x16x4d_c),
 374   make_tuple(&aom_masked_sad16x32x4d_ssse3, &aom_masked_sad16x32x4d_c),
 375   make_tuple(&aom_masked_sad32x16x4d_ssse3, &aom_masked_sad32x16x4d_c),
 376   make_tuple(&aom_masked_sad32x32x4d_ssse3, &aom_masked_sad32x32x4d_c),
 377   make_tuple(&aom_masked_sad32x64x4d_ssse3, &aom_masked_sad32x64x4d_c),
 378   make_tuple(&aom_masked_sad64x32x4d_ssse3, &aom_masked_sad64x32x4d_c),
 379   make_tuple(&aom_masked_sad64x64x4d_ssse3, &aom_masked_sad64x64x4d_c),
 380   make_tuple(&aom_masked_sad64x128x4d_ssse3, &aom_masked_sad64x128x4d_c),
 381   make_tuple(&aom_masked_sad128x64x4d_ssse3, &aom_masked_sad128x64x4d_c),
 382   make_tuple(&aom_masked_sad128x128x4d_ssse3, &aom_masked_sad128x128x4d_c),
 383 #if !CONFIG_REALTIME_ONLY
 384   make_tuple(&aom_masked_sad4x16x4d_ssse3, &aom_masked_sad4x16x4d_c),
 385   make_tuple(&aom_masked_sad16x4x4d_ssse3, &aom_masked_sad16x4x4d_c),
 386   make_tuple(&aom_masked_sad8x32x4d_ssse3, &aom_masked_sad8x32x4d_c),
 387   make_tuple(&aom_masked_sad32x8x4d_ssse3, &aom_masked_sad32x8x4d_c),
 388   make_tuple(&aom_masked_sad16x64x4d_ssse3, &aom_masked_sad16x64x4d_c),
 389   make_tuple(&aom_masked_sad64x16x4d_ssse3, &aom_masked_sad64x16x4d_c),
 390 #endif
 391 };
 392
 393 INSTANTIATE_TEST_SUITE_P(SSSE3, MaskedSADx4Test,
 394                          ::testing::ValuesIn(msadx4_test));
 395
 396 #if CONFIG_AV1_HIGHBITDEPTH
 397 const HighbdMaskedSADParam hbd_msad_test[] = {
 398   make_tuple(&aom_highbd_masked_sad4x4_ssse3, &aom_highbd_masked_sad4x4_c),
 399   make_tuple(&aom_highbd_masked_sad4x8_ssse3, &aom_highbd_masked_sad4x8_c),
 400   make_tuple(&aom_highbd_masked_sad8x4_ssse3, &aom_highbd_masked_sad8x4_c),
 401   make_tuple(&aom_highbd_masked_sad8x8_ssse3, &aom_highbd_masked_sad8x8_c),
 402   make_tuple(&aom_highbd_masked_sad8x16_ssse3, &aom_highbd_masked_sad8x16_c),
 403   make_tuple(&aom_highbd_masked_sad16x8_ssse3, &aom_highbd_masked_sad16x8_c),
 404   make_tuple(&aom_highbd_masked_sad16x16_ssse3, &aom_highbd_masked_sad16x16_c),
 405   make_tuple(&aom_highbd_masked_sad16x32_ssse3, &aom_highbd_masked_sad16x32_c),
 406   make_tuple(&aom_highbd_masked_sad32x16_ssse3, &aom_highbd_masked_sad32x16_c),
 407   make_tuple(&aom_highbd_masked_sad32x32_ssse3, &aom_highbd_masked_sad32x32_c),
 408   make_tuple(&aom_highbd_masked_sad32x64_ssse3, &aom_highbd_masked_sad32x64_c),
 409   make_tuple(&aom_highbd_masked_sad64x32_ssse3, &aom_highbd_masked_sad64x32_c),
 410   make_tuple(&aom_highbd_masked_sad64x64_ssse3, &aom_highbd_masked_sad64x64_c),
 411   make_tuple(&aom_highbd_masked_sad64x128_ssse3,
 412              &aom_highbd_masked_sad64x128_c),
 413   make_tuple(&aom_highbd_masked_sad128x64_ssse3,
 414              &aom_highbd_masked_sad128x64_c),
 415   make_tuple(&aom_highbd_masked_sad128x128_ssse3,
 416              &aom_highbd_masked_sad128x128_c),
 417 #if !CONFIG_REALTIME_ONLY
 418   make_tuple(&aom_highbd_masked_sad4x16_ssse3, &aom_highbd_masked_sad4x16_c),
 419   make_tuple(&aom_highbd_masked_sad16x4_ssse3, &aom_highbd_masked_sad16x4_c),
 420   make_tuple(&aom_highbd_masked_sad8x32_ssse3, &aom_highbd_masked_sad8x32_c),
 421   make_tuple(&aom_highbd_masked_sad32x8_ssse3, &aom_highbd_masked_sad32x8_c),
 422   make_tuple(&aom_highbd_masked_sad16x64_ssse3, &aom_highbd_masked_sad16x64_c),
 423   make_tuple(&aom_highbd_masked_sad64x16_ssse3, &aom_highbd_masked_sad64x16_c),
 424 #endif
 425 };
 426
 427 INSTANTIATE_TEST_SUITE_P(SSSE3, HighbdMaskedSADTest,
 428                          ::testing::ValuesIn(hbd_msad_test));
 429 #endif  // CONFIG_AV1_HIGHBITDEPTH
 430 #endif  // HAVE_SSSE3
 431
 432 #if HAVE_AVX2
 433 const MaskedSADParam msad_avx2_test[] = {
 434   make_tuple(&aom_masked_sad4x4_avx2, &aom_masked_sad4x4_ssse3),
 435   make_tuple(&aom_masked_sad4x8_avx2, &aom_masked_sad4x8_ssse3),
 436   make_tuple(&aom_masked_sad8x4_avx2, &aom_masked_sad8x4_ssse3),
 437   make_tuple(&aom_masked_sad8x8_avx2, &aom_masked_sad8x8_ssse3),
 438   make_tuple(&aom_masked_sad8x16_avx2, &aom_masked_sad8x16_ssse3),
 439   make_tuple(&aom_masked_sad16x8_avx2, &aom_masked_sad16x8_ssse3),
 440   make_tuple(&aom_masked_sad16x16_avx2, &aom_masked_sad16x16_ssse3),
 441   make_tuple(&aom_masked_sad16x32_avx2, &aom_masked_sad16x32_ssse3),
 442   make_tuple(&aom_masked_sad32x16_avx2, &aom_masked_sad32x16_ssse3),
 443   make_tuple(&aom_masked_sad32x32_avx2, &aom_masked_sad32x32_ssse3),
 444   make_tuple(&aom_masked_sad32x64_avx2, &aom_masked_sad32x64_ssse3),
 445   make_tuple(&aom_masked_sad64x32_avx2, &aom_masked_sad64x32_ssse3),
 446   make_tuple(&aom_masked_sad64x64_avx2, &aom_masked_sad64x64_ssse3),
 447   make_tuple(&aom_masked_sad64x128_avx2, &aom_masked_sad64x128_ssse3),
 448   make_tuple(&aom_masked_sad128x64_avx2, &aom_masked_sad128x64_ssse3),
 449   make_tuple(&aom_masked_sad128x128_avx2, &aom_masked_sad128x128_ssse3),
 450 #if !CONFIG_REALTIME_ONLY
 451   make_tuple(&aom_masked_sad4x16_avx2, &aom_masked_sad4x16_ssse3),
 452   make_tuple(&aom_masked_sad16x4_avx2, &aom_masked_sad16x4_ssse3),
 453   make_tuple(&aom_masked_sad8x32_avx2, &aom_masked_sad8x32_ssse3),
 454   make_tuple(&aom_masked_sad32x8_avx2, &aom_masked_sad32x8_ssse3),
 455   make_tuple(&aom_masked_sad16x64_avx2, &aom_masked_sad16x64_ssse3),
 456   make_tuple(&aom_masked_sad64x16_avx2, &aom_masked_sad64x16_ssse3)
 457 #endif
 458 };
 459
 460 INSTANTIATE_TEST_SUITE_P(AVX2, MaskedSADTest,
 461                          ::testing::ValuesIn(msad_avx2_test));
 462
 463 #if CONFIG_AV1_HIGHBITDEPTH
 464 const HighbdMaskedSADParam hbd_msad_avx2_test[] = {
 465   make_tuple(&aom_highbd_masked_sad4x4_avx2, &aom_highbd_masked_sad4x4_ssse3),
 466   make_tuple(&aom_highbd_masked_sad4x8_avx2, &aom_highbd_masked_sad4x8_ssse3),
 467   make_tuple(&aom_highbd_masked_sad8x4_avx2, &aom_highbd_masked_sad8x4_ssse3),
 468   make_tuple(&aom_highbd_masked_sad8x8_avx2, &aom_highbd_masked_sad8x8_ssse3),
 469   make_tuple(&aom_highbd_masked_sad8x16_avx2, &aom_highbd_masked_sad8x16_ssse3),
 470   make_tuple(&aom_highbd_masked_sad16x8_avx2, &aom_highbd_masked_sad16x8_ssse3),
 471   make_tuple(&aom_highbd_masked_sad16x16_avx2,
 472              &aom_highbd_masked_sad16x16_ssse3),
 473   make_tuple(&aom_highbd_masked_sad16x32_avx2,
 474              &aom_highbd_masked_sad16x32_ssse3),
 475   make_tuple(&aom_highbd_masked_sad32x16_avx2,
 476              &aom_highbd_masked_sad32x16_ssse3),
 477   make_tuple(&aom_highbd_masked_sad32x32_avx2,
 478              &aom_highbd_masked_sad32x32_ssse3),
 479   make_tuple(&aom_highbd_masked_sad32x64_avx2,
 480              &aom_highbd_masked_sad32x64_ssse3),
 481   make_tuple(&aom_highbd_masked_sad64x32_avx2,
 482              &aom_highbd_masked_sad64x32_ssse3),
 483   make_tuple(&aom_highbd_masked_sad64x64_avx2,
 484              &aom_highbd_masked_sad64x64_ssse3),
 485   make_tuple(&aom_highbd_masked_sad64x128_avx2,
 486              &aom_highbd_masked_sad64x128_ssse3),
 487   make_tuple(&aom_highbd_masked_sad128x64_avx2,
 488              &aom_highbd_masked_sad128x64_ssse3),
 489   make_tuple(&aom_highbd_masked_sad128x128_avx2,
 490              &aom_highbd_masked_sad128x128_ssse3),
 491 #if !CONFIG_REALTIME_ONLY
 492   make_tuple(&aom_highbd_masked_sad4x16_avx2, &aom_highbd_masked_sad4x16_ssse3),
 493   make_tuple(&aom_highbd_masked_sad16x4_avx2, &aom_highbd_masked_sad16x4_ssse3),
 494   make_tuple(&aom_highbd_masked_sad8x32_avx2, &aom_highbd_masked_sad8x32_ssse3),
 495   make_tuple(&aom_highbd_masked_sad32x8_avx2, &aom_highbd_masked_sad32x8_ssse3),
 496   make_tuple(&aom_highbd_masked_sad16x64_avx2,
 497              &aom_highbd_masked_sad16x64_ssse3),
 498   make_tuple(&aom_highbd_masked_sad64x16_avx2,
 499              &aom_highbd_masked_sad64x16_ssse3)
 500 #endif
 501 };
 502
 503 INSTANTIATE_TEST_SUITE_P(AVX2, HighbdMaskedSADTest,
 504                          ::testing::ValuesIn(hbd_msad_avx2_test));
 505 #endif  // CONFIG_AV1_HIGHBITDEPTH
 506 #endif  // HAVE_AVX2
 507
 508 }  // namespace