test/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
  12 #include <string.h>
  13 #include <limits.h>
  14 #include <stdio.h>
  15
  16 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  17
  18 #include "./aom_config.h"
  19 #include "./aom_dsp_rtcd.h"
  20 #include "test/acm_random.h"
  21 #include "test/clear_system_state.h"
  22 #include "test/register_state_check.h"
  23 #include "test/util.h"
  24 #include "aom/aom_codec.h"
  25 #include "aom_mem/aom_mem.h"
  26 #include "aom_ports/mem.h"
  27
  28 typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
  29                                    const uint8_t *ref_ptr, int ref_stride);
  30 typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam;
  31
  32 typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
  33                                   const uint8_t *ref_ptr, int ref_stride,
  34                                   const uint8_t *second_pred);
  35 typedef std::tr1::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
  36
  37 #if CONFIG_JNT_COMP
  38 typedef void (*JntCompAvgFunc)(uint8_t *comp_pred, const uint8_t *pred,
  39                                int width, int height, const uint8_t *ref,
  40                                int ref_stride,
  41                                const JNT_COMP_PARAMS *jcp_param);
  42 typedef std::tr1::tuple<int, int, JntCompAvgFunc, int> JntCompAvgParam;
  43
  44 typedef unsigned int (*JntSadMxhFunc)(const uint8_t *src_ptr, int src_stride,
  45                                       const uint8_t *ref_ptr, int ref_stride,
  46                                       int width, int height);
  47 typedef std::tr1::tuple<int, int, JntSadMxhFunc, int> JntSadMxhParam;
  48
  49 typedef uint32_t (*JntSadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
  50                                      const uint8_t *ref_ptr, int ref_stride,
  51                                      const uint8_t *second_pred,
  52                                      const JNT_COMP_PARAMS *jcp_param);
  53 typedef std::tr1::tuple<int, int, JntSadMxNAvgFunc, int> JntSadMxNAvgParam;
  54 #endif  // CONFIG_JNT_COMP
  55
  56 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, int src_stride,
  57                              const uint8_t *const ref_ptr[], int ref_stride,
  58                              uint32_t *sad_array);
  59 typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
  60
  61 using libaom_test::ACMRandom;
  62
  63 namespace {
  64 class SADTestBase : public ::testing::Test {
  65  public:
  66   SADTestBase(int width, int height, int bit_depth)
  67       : width_(width), height_(height), bd_(bit_depth) {}
  68
  69   static void SetUpTestCase() {
  70     source_data8_ = reinterpret_cast<uint8_t *>(
  71         aom_memalign(kDataAlignment, kDataBlockSize));
  72     reference_data8_ = reinterpret_cast<uint8_t *>(
  73         aom_memalign(kDataAlignment, kDataBufferSize));
  74     second_pred8_ =
  75         reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
  76 #if CONFIG_JNT_COMP
  77     comp_pred8_ =
  78         reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
  79     comp_pred8_test_ =
  80         reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
  81 #endif
  82     source_data16_ = reinterpret_cast<uint16_t *>(
  83         aom_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
  84     reference_data16_ = reinterpret_cast<uint16_t *>(
  85         aom_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
  86     second_pred16_ = reinterpret_cast<uint16_t *>(
  87         aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
  88 #if CONFIG_JNT_COMP
  89     comp_pred16_ = reinterpret_cast<uint16_t *>(
  90         aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
  91     comp_pred16_test_ = reinterpret_cast<uint16_t *>(
  92         aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
  93 #endif
  94   }
  95
  96   static void TearDownTestCase() {
  97     aom_free(source_data8_);
  98     source_data8_ = NULL;
  99     aom_free(reference_data8_);
 100     reference_data8_ = NULL;
 101     aom_free(second_pred8_);
 102     second_pred8_ = NULL;
 103 #if CONFIG_JNT_COMP
 104     aom_free(comp_pred8_);
 105     comp_pred8_ = NULL;
 106     aom_free(comp_pred8_test_);
 107     comp_pred8_test_ = NULL;
 108 #endif
 109     aom_free(source_data16_);
 110     source_data16_ = NULL;
 111     aom_free(reference_data16_);
 112     reference_data16_ = NULL;
 113     aom_free(second_pred16_);
 114     second_pred16_ = NULL;
 115 #if CONFIG_JNT_COMP
 116     aom_free(comp_pred16_);
 117     comp_pred16_ = NULL;
 118     aom_free(comp_pred16_test_);
 119     comp_pred16_test_ = NULL;
 120 #endif
 121   }
 122
 123   virtual void TearDown() { libaom_test::ClearSystemState(); }
 124
 125  protected:
 126   // Handle up to 4 128x128 blocks, with stride up to 256
 127   static const int kDataAlignment = 16;
 128   static const int kDataBlockSize = 128 * 256;
 129   static const int kDataBufferSize = 4 * kDataBlockSize;
 130
 131   virtual void SetUp() {
 132     if (bd_ == -1) {
 133       use_high_bit_depth_ = false;
 134       bit_depth_ = AOM_BITS_8;
 135       source_data_ = source_data8_;
 136       reference_data_ = reference_data8_;
 137       second_pred_ = second_pred8_;
 138 #if CONFIG_JNT_COMP
 139       comp_pred_ = comp_pred8_;
 140       comp_pred_test_ = comp_pred8_test_;
 141 #endif
 142     } else {
 143       use_high_bit_depth_ = true;
 144       bit_depth_ = static_cast<aom_bit_depth_t>(bd_);
 145       source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
 146       reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
 147       second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
 148 #if CONFIG_JNT_COMP
 149       comp_pred_ = CONVERT_TO_BYTEPTR(comp_pred16_);
 150       comp_pred_test_ = CONVERT_TO_BYTEPTR(comp_pred16_test_);
 151 #endif
 152     }
 153     mask_ = (1 << bit_depth_) - 1;
 154     source_stride_ = (width_ + 31) & ~31;
 155     reference_stride_ = width_ * 2;
 156     rnd_.Reset(ACMRandom::DeterministicSeed());
 157   }
 158
 159   virtual uint8_t *GetReference(int block_idx) {
 160     if (use_high_bit_depth_)
 161       return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
 162                                 block_idx * kDataBlockSize);
 163     return reference_data_ + block_idx * kDataBlockSize;
 164   }
 165
 166   // Sum of Absolute Differences. Given two blocks, calculate the absolute
 167   // difference between two pixels in the same relative location; accumulate.
 168   unsigned int ReferenceSAD(int block_idx) {
 169     unsigned int sad = 0;
 170     const uint8_t *const reference8 = GetReference(block_idx);
 171     const uint8_t *const source8 = source_data_;
 172     const uint16_t *const reference16 =
 173         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 174     const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 175     for (int h = 0; h < height_; ++h) {
 176       for (int w = 0; w < width_; ++w) {
 177         if (!use_high_bit_depth_) {
 178           sad += abs(source8[h * source_stride_ + w] -
 179                      reference8[h * reference_stride_ + w]);
 180         } else {
 181           sad += abs(source16[h * source_stride_ + w] -
 182                      reference16[h * reference_stride_ + w]);
 183         }
 184       }
 185     }
 186     return sad;
 187   }
 188
 189   // Sum of Absolute Differences Average. Given two blocks, and a prediction
 190   // calculate the absolute difference between one pixel and average of the
 191   // corresponding and predicted pixels; accumulate.
 192   unsigned int ReferenceSADavg(int block_idx) {
 193     unsigned int sad = 0;
 194     const uint8_t *const reference8 = GetReference(block_idx);
 195     const uint8_t *const source8 = source_data_;
 196     const uint8_t *const second_pred8 = second_pred_;
 197     const uint16_t *const reference16 =
 198         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 199     const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 200     const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
 201     for (int h = 0; h < height_; ++h) {
 202       for (int w = 0; w < width_; ++w) {
 203         if (!use_high_bit_depth_) {
 204           const int tmp = second_pred8[h * width_ + w] +
 205                           reference8[h * reference_stride_ + w];
 206           const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
 207           sad += abs(source8[h * source_stride_ + w] - comp_pred);
 208         } else {
 209           const int tmp = second_pred16[h * width_ + w] +
 210                           reference16[h * reference_stride_ + w];
 211           const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
 212           sad += abs(source16[h * source_stride_ + w] - comp_pred);
 213         }
 214       }
 215     }
 216     return sad;
 217   }
 218
 219 #if CONFIG_JNT_COMP
 220   void ReferenceJntCompAvg(int block_idx) {
 221     const uint8_t *const reference8 = GetReference(block_idx);
 222     const uint8_t *const second_pred8 = second_pred_;
 223     uint8_t *const comp_pred8 = comp_pred_;
 224     const uint16_t *const reference16 =
 225         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 226     const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
 227     uint16_t *const comp_pred16 = CONVERT_TO_SHORTPTR(comp_pred_);
 228     for (int h = 0; h < height_; ++h) {
 229       for (int w = 0; w < width_; ++w) {
 230         if (!use_high_bit_depth_) {
 231           const int tmp =
 232               second_pred8[h * width_ + w] * jcp_param_.bck_offset +
 233               reference8[h * reference_stride_ + w] * jcp_param_.fwd_offset;
 234           comp_pred8[h * width_ + w] = ROUND_POWER_OF_TWO(tmp, 4);
 235         } else {
 236           const int tmp =
 237               second_pred16[h * width_ + w] * jcp_param_.bck_offset +
 238               reference16[h * reference_stride_ + w] * jcp_param_.fwd_offset;
 239           comp_pred16[h * width_ + w] = ROUND_POWER_OF_TWO(tmp, 4);
 240         }
 241       }
 242     }
 243   }
 244
 245   unsigned int ReferenceJntSADavg(int block_idx) {
 246     unsigned int sad = 0;
 247     const uint8_t *const reference8 = GetReference(block_idx);
 248     const uint8_t *const source8 = source_data_;
 249     const uint8_t *const second_pred8 = second_pred_;
 250     const uint16_t *const reference16 =
 251         CONVERT_TO_SHORTPTR(GetReference(block_idx));
 252     const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 253     const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
 254     for (int h = 0; h < height_; ++h) {
 255       for (int w = 0; w < width_; ++w) {
 256         if (!use_high_bit_depth_) {
 257           const int tmp =
 258               second_pred8[h * width_ + w] * jcp_param_.bck_offset +
 259               reference8[h * reference_stride_ + w] * jcp_param_.fwd_offset;
 260           const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4);
 261           sad += abs(source8[h * source_stride_ + w] - comp_pred);
 262         } else {
 263           const int tmp =
 264               second_pred16[h * width_ + w] * jcp_param_.bck_offset +
 265               reference16[h * reference_stride_ + w] * jcp_param_.fwd_offset;
 266           const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4);
 267           sad += abs(source16[h * source_stride_ + w] - comp_pred);
 268         }
 269       }
 270     }
 271     return sad;
 272   }
 273 #endif  // CONFIG_JNT_COMP
 274
 275   void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) {
 276     uint8_t *data8 = data;
 277     uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
 278     for (int h = 0; h < height_; ++h) {
 279       for (int w = 0; w < width_; ++w) {
 280         if (!use_high_bit_depth_) {
 281           data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
 282         } else {
 283           data16[h * stride + w] = fill_constant;
 284         }
 285       }
 286     }
 287   }
 288
 289   void FillRandom(uint8_t *data, int stride) {
 290     uint8_t *data8 = data;
 291     uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
 292     for (int h = 0; h < height_; ++h) {
 293       for (int w = 0; w < width_; ++w) {
 294         if (!use_high_bit_depth_) {
 295           data8[h * stride + w] = rnd_.Rand8();
 296         } else {
 297           data16[h * stride + w] = rnd_.Rand16() & mask_;
 298         }
 299       }
 300     }
 301   }
 302
 303   int width_, height_, mask_, bd_;
 304   aom_bit_depth_t bit_depth_;
 305   static uint8_t *source_data_;
 306   static uint8_t *reference_data_;
 307   static uint8_t *second_pred_;
 308   int source_stride_;
 309   bool use_high_bit_depth_;
 310   static uint8_t *source_data8_;
 311   static uint8_t *reference_data8_;
 312   static uint8_t *second_pred8_;
 313   static uint16_t *source_data16_;
 314   static uint16_t *reference_data16_;
 315   static uint16_t *second_pred16_;
 316   int reference_stride_;
 317 #if CONFIG_JNT_COMP
 318   static uint8_t *comp_pred_;
 319   static uint8_t *comp_pred8_;
 320   static uint16_t *comp_pred16_;
 321   static uint8_t *comp_pred_test_;
 322   static uint8_t *comp_pred8_test_;
 323   static uint16_t *comp_pred16_test_;
 324   JNT_COMP_PARAMS jcp_param_;
 325 #endif
 326
 327   ACMRandom rnd_;
 328 };
 329
 330 class SADx4Test : public ::testing::WithParamInterface<SadMxNx4Param>,
 331                   public SADTestBase {
 332  public:
 333   SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 334
 335  protected:
 336   void SADs(unsigned int *results) {
 337     const uint8_t *references[] = { GetReference(0), GetReference(1),
 338                                     GetReference(2), GetReference(3) };
 339
 340     ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(
 341         source_data_, source_stride_, references, reference_stride_, results));
 342   }
 343
 344   void CheckSADs() {
 345     unsigned int reference_sad, exp_sad[4];
 346
 347     SADs(exp_sad);
 348     for (int block = 0; block < 4; ++block) {
 349       reference_sad = ReferenceSAD(block);
 350
 351       EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
 352     }
 353   }
 354 };
 355
 356 class SADTest : public ::testing::WithParamInterface<SadMxNParam>,
 357                 public SADTestBase {
 358  public:
 359   SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 360
 361  protected:
 362   unsigned int SAD(int block_idx) {
 363     unsigned int ret;
 364     const uint8_t *const reference = GetReference(block_idx);
 365
 366     ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
 367                                                 reference, reference_stride_));
 368     return ret;
 369   }
 370
 371   void CheckSAD() {
 372     const unsigned int reference_sad = ReferenceSAD(0);
 373     const unsigned int exp_sad = SAD(0);
 374
 375     ASSERT_EQ(reference_sad, exp_sad);
 376   }
 377
 378   void SpeedSAD() {
 379     int test_count = 20000000;
 380     while (test_count > 0) {
 381       SAD(0);
 382       test_count -= 1;
 383     }
 384   }
 385 };
 386
 387 class SADavgTest : public ::testing::WithParamInterface<SadMxNAvgParam>,
 388                    public SADTestBase {
 389  public:
 390   SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 391
 392  protected:
 393   unsigned int SAD_avg(int block_idx) {
 394     unsigned int ret;
 395     const uint8_t *const reference = GetReference(block_idx);
 396
 397     ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
 398                                                 reference, reference_stride_,
 399                                                 second_pred_));
 400     return ret;
 401   }
 402
 403   void CheckSAD() {
 404     const unsigned int reference_sad = ReferenceSADavg(0);
 405     const unsigned int exp_sad = SAD_avg(0);
 406
 407     ASSERT_EQ(reference_sad, exp_sad);
 408   }
 409 };
 410
 411 #if CONFIG_JNT_COMP
 412 class JntCompAvgTest : public ::testing::WithParamInterface<JntCompAvgParam>,
 413                        public SADTestBase {
 414  public:
 415   JntCompAvgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 416
 417  protected:
 418   void jnt_comp_avg(int block_idx) {
 419     const uint8_t *const reference = GetReference(block_idx);
 420
 421     ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(comp_pred_test_, second_pred_, width_,
 422                                           height_, reference, reference_stride_,
 423                                           &jcp_param_));
 424   }
 425
 426   void CheckCompAvg() {
 427     for (int j = 0; j < 2; ++j) {
 428       for (int i = 0; i < 4; ++i) {
 429         jcp_param_.fwd_offset = quant_dist_lookup_table[j][i][0];
 430         jcp_param_.bck_offset = quant_dist_lookup_table[j][i][1];
 431
 432         ReferenceJntCompAvg(0);
 433         jnt_comp_avg(0);
 434
 435         for (int y = 0; y < height_; ++y)
 436           for (int x = 0; x < width_; ++x)
 437             ASSERT_EQ(comp_pred_[y * width_ + x],
 438                       comp_pred_test_[y * width_ + x]);
 439       }
 440     }
 441   }
 442 };
 443
 444 class JntSADTest : public ::testing::WithParamInterface<JntSadMxhParam>,
 445                    public SADTestBase {
 446  public:
 447   JntSADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 448
 449  protected:
 450   unsigned int SAD(int block_idx) {
 451     unsigned int ret;
 452     const uint8_t *const reference = GetReference(block_idx);
 453
 454     ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
 455                                                 reference, reference_stride_,
 456                                                 GET_PARAM(0), GET_PARAM(1)));
 457     return ret;
 458   }
 459
 460   void CheckSAD() {
 461     const unsigned int reference_sad = ReferenceSAD(0);
 462     const unsigned int exp_sad = SAD(0);
 463
 464     ASSERT_EQ(reference_sad, exp_sad);
 465   }
 466
 467   void SpeedSAD() {
 468     int test_count = 20000000;
 469     while (test_count > 0) {
 470       SAD(0);
 471       test_count -= 1;
 472     }
 473   }
 474 };
 475
 476 class JntSADavgTest : public ::testing::WithParamInterface<JntSadMxNAvgParam>,
 477                       public SADTestBase {
 478  public:
 479   JntSADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 480
 481  protected:
 482   unsigned int jnt_SAD_avg(int block_idx) {
 483     unsigned int ret;
 484     const uint8_t *const reference = GetReference(block_idx);
 485
 486     ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
 487                                                 reference, reference_stride_,
 488                                                 second_pred_, &jcp_param_));
 489     return ret;
 490   }
 491
 492   void CheckSAD() {
 493     for (int j = 0; j < 2; ++j) {
 494       for (int i = 0; i < 4; ++i) {
 495         jcp_param_.fwd_offset = quant_dist_lookup_table[j][i][0];
 496         jcp_param_.bck_offset = quant_dist_lookup_table[j][i][1];
 497
 498         const unsigned int reference_sad = ReferenceJntSADavg(0);
 499         const unsigned int exp_sad = jnt_SAD_avg(0);
 500
 501         ASSERT_EQ(reference_sad, exp_sad);
 502       }
 503     }
 504   }
 505 };
 506 #endif  // CONFIG_JNT_COMP
 507
 508 uint8_t *SADTestBase::source_data_ = NULL;
 509 uint8_t *SADTestBase::reference_data_ = NULL;
 510 uint8_t *SADTestBase::second_pred_ = NULL;
 511 #if CONFIG_JNT_COMP
 512 uint8_t *SADTestBase::comp_pred_ = NULL;
 513 uint8_t *SADTestBase::comp_pred_test_ = NULL;
 514 #endif
 515 uint8_t *SADTestBase::source_data8_ = NULL;
 516 uint8_t *SADTestBase::reference_data8_ = NULL;
 517 uint8_t *SADTestBase::second_pred8_ = NULL;
 518 #if CONFIG_JNT_COMP
 519 uint8_t *SADTestBase::comp_pred8_ = NULL;
 520 uint8_t *SADTestBase::comp_pred8_test_ = NULL;
 521 #endif
 522 uint16_t *SADTestBase::source_data16_ = NULL;
 523 uint16_t *SADTestBase::reference_data16_ = NULL;
 524 uint16_t *SADTestBase::second_pred16_ = NULL;
 525 #if CONFIG_JNT_COMP
 526 uint16_t *SADTestBase::comp_pred16_ = NULL;
 527 uint16_t *SADTestBase::comp_pred16_test_ = NULL;
 528 #endif
 529
 530 TEST_P(SADTest, MaxRef) {
 531   FillConstant(source_data_, source_stride_, 0);
 532   FillConstant(reference_data_, reference_stride_, mask_);
 533   CheckSAD();
 534 }
 535
 536 TEST_P(SADTest, MaxSrc) {
 537   FillConstant(source_data_, source_stride_, mask_);
 538   FillConstant(reference_data_, reference_stride_, 0);
 539   CheckSAD();
 540 }
 541
 542 TEST_P(SADTest, ShortRef) {
 543   const int tmp_stride = reference_stride_;
 544   reference_stride_ >>= 1;
 545   FillRandom(source_data_, source_stride_);
 546   FillRandom(reference_data_, reference_stride_);
 547   CheckSAD();
 548   reference_stride_ = tmp_stride;
 549 }
 550
 551 TEST_P(SADTest, UnalignedRef) {
 552   // The reference frame, but not the source frame, may be unaligned for
 553   // certain types of searches.
 554   const int tmp_stride = reference_stride_;
 555   reference_stride_ -= 1;
 556   FillRandom(source_data_, source_stride_);
 557   FillRandom(reference_data_, reference_stride_);
 558   CheckSAD();
 559   reference_stride_ = tmp_stride;
 560 }
 561
 562 TEST_P(SADTest, ShortSrc) {
 563   const int tmp_stride = source_stride_;
 564   source_stride_ >>= 1;
 565   int test_count = 2000;
 566   while (test_count > 0) {
 567     FillRandom(source_data_, source_stride_);
 568     FillRandom(reference_data_, reference_stride_);
 569     CheckSAD();
 570     test_count -= 1;
 571   }
 572   source_stride_ = tmp_stride;
 573 }
 574
 575 #define SPEED_TEST (0)
 576 #if SPEED_TEST
 577 TEST_P(SADTest, Speed) {
 578   const int tmp_stride = source_stride_;
 579   source_stride_ >>= 1;
 580   FillRandom(source_data_, source_stride_);
 581   FillRandom(reference_data_, reference_stride_);
 582   SpeedSAD();
 583   source_stride_ = tmp_stride;
 584 }
 585 #endif
 586
 587 TEST_P(SADavgTest, MaxRef) {
 588   FillConstant(source_data_, source_stride_, 0);
 589   FillConstant(reference_data_, reference_stride_, mask_);
 590   FillConstant(second_pred_, width_, 0);
 591   CheckSAD();
 592 }
 593 TEST_P(SADavgTest, MaxSrc) {
 594   FillConstant(source_data_, source_stride_, mask_);
 595   FillConstant(reference_data_, reference_stride_, 0);
 596   FillConstant(second_pred_, width_, 0);
 597   CheckSAD();
 598 }
 599
 600 TEST_P(SADavgTest, ShortRef) {
 601   const int tmp_stride = reference_stride_;
 602   reference_stride_ >>= 1;
 603   FillRandom(source_data_, source_stride_);
 604   FillRandom(reference_data_, reference_stride_);
 605   FillRandom(second_pred_, width_);
 606   CheckSAD();
 607   reference_stride_ = tmp_stride;
 608 }
 609
 610 TEST_P(SADavgTest, UnalignedRef) {
 611   // The reference frame, but not the source frame, may be unaligned for
 612   // certain types of searches.
 613   const int tmp_stride = reference_stride_;
 614   reference_stride_ -= 1;
 615   FillRandom(source_data_, source_stride_);
 616   FillRandom(reference_data_, reference_stride_);
 617   FillRandom(second_pred_, width_);
 618   CheckSAD();
 619   reference_stride_ = tmp_stride;
 620 }
 621
 622 TEST_P(SADavgTest, ShortSrc) {
 623   const int tmp_stride = source_stride_;
 624   source_stride_ >>= 1;
 625   int test_count = 2000;
 626   while (test_count > 0) {
 627     FillRandom(source_data_, source_stride_);
 628     FillRandom(reference_data_, reference_stride_);
 629     FillRandom(second_pred_, width_);
 630     CheckSAD();
 631     test_count -= 1;
 632   }
 633   source_stride_ = tmp_stride;
 634 }
 635
 636 #if CONFIG_JNT_COMP
 637 TEST_P(JntCompAvgTest, MaxRef) {
 638   FillConstant(reference_data_, reference_stride_, mask_);
 639   FillConstant(second_pred_, width_, 0);
 640   CheckCompAvg();
 641 }
 642
 643 TEST_P(JntCompAvgTest, MaxSecondPred) {
 644   FillConstant(reference_data_, reference_stride_, 0);
 645   FillConstant(second_pred_, width_, mask_);
 646   CheckCompAvg();
 647 }
 648
 649 TEST_P(JntCompAvgTest, ShortRef) {
 650   const int tmp_stride = reference_stride_;
 651   reference_stride_ >>= 1;
 652   FillRandom(reference_data_, reference_stride_);
 653   FillRandom(second_pred_, width_);
 654   CheckCompAvg();
 655   reference_stride_ = tmp_stride;
 656 }
 657
 658 TEST_P(JntCompAvgTest, UnalignedRef) {
 659   // The reference frame, but not the source frame, may be unaligned for
 660   // certain types of searches.
 661   const int tmp_stride = reference_stride_;
 662   reference_stride_ -= 1;
 663   FillRandom(reference_data_, reference_stride_);
 664   FillRandom(second_pred_, width_);
 665   CheckCompAvg();
 666   reference_stride_ = tmp_stride;
 667 }
 668
 669 TEST_P(JntSADTest, MaxRef) {
 670   FillConstant(source_data_, source_stride_, 0);
 671   FillConstant(reference_data_, reference_stride_, mask_);
 672   CheckSAD();
 673 }
 674
 675 TEST_P(JntSADTest, MaxSrc) {
 676   FillConstant(source_data_, source_stride_, mask_);
 677   FillConstant(reference_data_, reference_stride_, 0);
 678   CheckSAD();
 679 }
 680
 681 TEST_P(JntSADTest, ShortRef) {
 682   const int tmp_stride = reference_stride_;
 683   reference_stride_ >>= 1;
 684   FillRandom(source_data_, source_stride_);
 685   FillRandom(reference_data_, reference_stride_);
 686   CheckSAD();
 687   reference_stride_ = tmp_stride;
 688 }
 689
 690 TEST_P(JntSADTest, UnalignedRef) {
 691   // The reference frame, but not the source frame, may be unaligned for
 692   // certain types of searches.
 693   const int tmp_stride = reference_stride_;
 694   reference_stride_ -= 1;
 695   FillRandom(source_data_, source_stride_);
 696   FillRandom(reference_data_, reference_stride_);
 697   CheckSAD();
 698   reference_stride_ = tmp_stride;
 699 }
 700
 701 TEST_P(JntSADTest, ShortSrc) {
 702   const int tmp_stride = source_stride_;
 703   source_stride_ >>= 1;
 704   int test_count = 2000;
 705   while (test_count > 0) {
 706     FillRandom(source_data_, source_stride_);
 707     FillRandom(reference_data_, reference_stride_);
 708     CheckSAD();
 709     test_count -= 1;
 710   }
 711   source_stride_ = tmp_stride;
 712 }
 713
 714 TEST_P(JntSADavgTest, MaxRef) {
 715   FillConstant(source_data_, source_stride_, 0);
 716   FillConstant(reference_data_, reference_stride_, mask_);
 717   FillConstant(second_pred_, width_, 0);
 718   CheckSAD();
 719 }
 720 TEST_P(JntSADavgTest, MaxSrc) {
 721   FillConstant(source_data_, source_stride_, mask_);
 722   FillConstant(reference_data_, reference_stride_, 0);
 723   FillConstant(second_pred_, width_, 0);
 724   CheckSAD();
 725 }
 726
 727 TEST_P(JntSADavgTest, ShortRef) {
 728   const int tmp_stride = reference_stride_;
 729   reference_stride_ >>= 1;
 730   FillRandom(source_data_, source_stride_);
 731   FillRandom(reference_data_, reference_stride_);
 732   FillRandom(second_pred_, width_);
 733   CheckSAD();
 734   reference_stride_ = tmp_stride;
 735 }
 736
 737 TEST_P(JntSADavgTest, UnalignedRef) {
 738   // The reference frame, but not the source frame, may be unaligned for
 739   // certain types of searches.
 740   const int tmp_stride = reference_stride_;
 741   reference_stride_ -= 1;
 742   FillRandom(source_data_, source_stride_);
 743   FillRandom(reference_data_, reference_stride_);
 744   FillRandom(second_pred_, width_);
 745   CheckSAD();
 746   reference_stride_ = tmp_stride;
 747 }
 748
 749 TEST_P(JntSADavgTest, ShortSrc) {
 750   const int tmp_stride = source_stride_;
 751   source_stride_ >>= 1;
 752   int test_count = 2000;
 753   while (test_count > 0) {
 754     FillRandom(source_data_, source_stride_);
 755     FillRandom(reference_data_, reference_stride_);
 756     FillRandom(second_pred_, width_);
 757     CheckSAD();
 758     test_count -= 1;
 759   }
 760   source_stride_ = tmp_stride;
 761 }
 762 #endif  // CONFIG_JNT_COMP
 763
 764 TEST_P(SADx4Test, MaxRef) {
 765   FillConstant(source_data_, source_stride_, 0);
 766   FillConstant(GetReference(0), reference_stride_, mask_);
 767   FillConstant(GetReference(1), reference_stride_, mask_);
 768   FillConstant(GetReference(2), reference_stride_, mask_);
 769   FillConstant(GetReference(3), reference_stride_, mask_);
 770   CheckSADs();
 771 }
 772
 773 TEST_P(SADx4Test, MaxSrc) {
 774   FillConstant(source_data_, source_stride_, mask_);
 775   FillConstant(GetReference(0), reference_stride_, 0);
 776   FillConstant(GetReference(1), reference_stride_, 0);
 777   FillConstant(GetReference(2), reference_stride_, 0);
 778   FillConstant(GetReference(3), reference_stride_, 0);
 779   CheckSADs();
 780 }
 781
 782 TEST_P(SADx4Test, ShortRef) {
 783   int tmp_stride = reference_stride_;
 784   reference_stride_ >>= 1;
 785   FillRandom(source_data_, source_stride_);
 786   FillRandom(GetReference(0), reference_stride_);
 787   FillRandom(GetReference(1), reference_stride_);
 788   FillRandom(GetReference(2), reference_stride_);
 789   FillRandom(GetReference(3), reference_stride_);
 790   CheckSADs();
 791   reference_stride_ = tmp_stride;
 792 }
 793
 794 TEST_P(SADx4Test, UnalignedRef) {
 795   // The reference frame, but not the source frame, may be unaligned for
 796   // certain types of searches.
 797   int tmp_stride = reference_stride_;
 798   reference_stride_ -= 1;
 799   FillRandom(source_data_, source_stride_);
 800   FillRandom(GetReference(0), reference_stride_);
 801   FillRandom(GetReference(1), reference_stride_);
 802   FillRandom(GetReference(2), reference_stride_);
 803   FillRandom(GetReference(3), reference_stride_);
 804   CheckSADs();
 805   reference_stride_ = tmp_stride;
 806 }
 807
 808 TEST_P(SADx4Test, ShortSrc) {
 809   int tmp_stride = source_stride_;
 810   source_stride_ >>= 1;
 811   int test_count = 1000;
 812   while (test_count > 0) {
 813     FillRandom(source_data_, source_stride_);
 814     FillRandom(GetReference(0), reference_stride_);
 815     FillRandom(GetReference(1), reference_stride_);
 816     FillRandom(GetReference(2), reference_stride_);
 817     FillRandom(GetReference(3), reference_stride_);
 818     CheckSADs();
 819     test_count -= 1;
 820   }
 821   source_stride_ = tmp_stride;
 822 }
 823
 824 TEST_P(SADx4Test, SrcAlignedByWidth) {
 825   uint8_t *tmp_source_data = source_data_;
 826   source_data_ += width_;
 827   FillRandom(source_data_, source_stride_);
 828   FillRandom(GetReference(0), reference_stride_);
 829   FillRandom(GetReference(1), reference_stride_);
 830   FillRandom(GetReference(2), reference_stride_);
 831   FillRandom(GetReference(3), reference_stride_);
 832   CheckSADs();
 833   source_data_ = tmp_source_data;
 834 }
 835
 836 using std::tr1::make_tuple;
 837
 838 //------------------------------------------------------------------------------
 839 // C functions
 840 const SadMxNParam c_tests[] = {
 841 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 842   make_tuple(128, 128, &aom_sad128x128_c, -1),
 843   make_tuple(128, 64, &aom_sad128x64_c, -1),
 844   make_tuple(64, 128, &aom_sad64x128_c, -1),
 845 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 846   make_tuple(64, 64, &aom_sad64x64_c, -1),
 847   make_tuple(64, 32, &aom_sad64x32_c, -1),
 848   make_tuple(32, 64, &aom_sad32x64_c, -1),
 849   make_tuple(32, 32, &aom_sad32x32_c, -1),
 850   make_tuple(32, 16, &aom_sad32x16_c, -1),
 851   make_tuple(16, 32, &aom_sad16x32_c, -1),
 852   make_tuple(16, 16, &aom_sad16x16_c, -1),
 853   make_tuple(16, 8, &aom_sad16x8_c, -1),
 854   make_tuple(8, 16, &aom_sad8x16_c, -1),
 855   make_tuple(8, 8, &aom_sad8x8_c, -1),
 856   make_tuple(8, 4, &aom_sad8x4_c, -1),
 857   make_tuple(4, 8, &aom_sad4x8_c, -1),
 858   make_tuple(4, 4, &aom_sad4x4_c, -1),
 859 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 860   make_tuple(128, 128, &aom_highbd_sad128x128_c, 8),
 861   make_tuple(128, 64, &aom_highbd_sad128x64_c, 8),
 862   make_tuple(64, 128, &aom_highbd_sad64x128_c, 8),
 863 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 864   make_tuple(64, 64, &aom_highbd_sad64x64_c, 8),
 865   make_tuple(64, 32, &aom_highbd_sad64x32_c, 8),
 866   make_tuple(32, 64, &aom_highbd_sad32x64_c, 8),
 867   make_tuple(32, 32, &aom_highbd_sad32x32_c, 8),
 868   make_tuple(32, 16, &aom_highbd_sad32x16_c, 8),
 869   make_tuple(16, 32, &aom_highbd_sad16x32_c, 8),
 870   make_tuple(16, 16, &aom_highbd_sad16x16_c, 8),
 871   make_tuple(16, 8, &aom_highbd_sad16x8_c, 8),
 872   make_tuple(8, 16, &aom_highbd_sad8x16_c, 8),
 873   make_tuple(8, 8, &aom_highbd_sad8x8_c, 8),
 874   make_tuple(8, 4, &aom_highbd_sad8x4_c, 8),
 875   make_tuple(4, 8, &aom_highbd_sad4x8_c, 8),
 876   make_tuple(4, 4, &aom_highbd_sad4x4_c, 8),
 877 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 878   make_tuple(128, 128, &aom_highbd_sad128x128_c, 10),
 879   make_tuple(128, 64, &aom_highbd_sad128x64_c, 10),
 880   make_tuple(64, 128, &aom_highbd_sad64x128_c, 10),
 881 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 882   make_tuple(64, 64, &aom_highbd_sad64x64_c, 10),
 883   make_tuple(64, 32, &aom_highbd_sad64x32_c, 10),
 884   make_tuple(32, 64, &aom_highbd_sad32x64_c, 10),
 885   make_tuple(32, 32, &aom_highbd_sad32x32_c, 10),
 886   make_tuple(32, 16, &aom_highbd_sad32x16_c, 10),
 887   make_tuple(16, 32, &aom_highbd_sad16x32_c, 10),
 888   make_tuple(16, 16, &aom_highbd_sad16x16_c, 10),
 889   make_tuple(16, 8, &aom_highbd_sad16x8_c, 10),
 890   make_tuple(8, 16, &aom_highbd_sad8x16_c, 10),
 891   make_tuple(8, 8, &aom_highbd_sad8x8_c, 10),
 892   make_tuple(8, 4, &aom_highbd_sad8x4_c, 10),
 893   make_tuple(4, 8, &aom_highbd_sad4x8_c, 10),
 894   make_tuple(4, 4, &aom_highbd_sad4x4_c, 10),
 895 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 896   make_tuple(128, 128, &aom_highbd_sad128x128_c, 12),
 897   make_tuple(128, 64, &aom_highbd_sad128x64_c, 12),
 898   make_tuple(64, 128, &aom_highbd_sad64x128_c, 12),
 899 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 900   make_tuple(64, 64, &aom_highbd_sad64x64_c, 12),
 901   make_tuple(64, 32, &aom_highbd_sad64x32_c, 12),
 902   make_tuple(32, 64, &aom_highbd_sad32x64_c, 12),
 903   make_tuple(32, 32, &aom_highbd_sad32x32_c, 12),
 904   make_tuple(32, 16, &aom_highbd_sad32x16_c, 12),
 905   make_tuple(16, 32, &aom_highbd_sad16x32_c, 12),
 906   make_tuple(16, 16, &aom_highbd_sad16x16_c, 12),
 907   make_tuple(16, 8, &aom_highbd_sad16x8_c, 12),
 908   make_tuple(8, 16, &aom_highbd_sad8x16_c, 12),
 909   make_tuple(8, 8, &aom_highbd_sad8x8_c, 12),
 910   make_tuple(8, 4, &aom_highbd_sad8x4_c, 12),
 911   make_tuple(4, 8, &aom_highbd_sad4x8_c, 12),
 912   make_tuple(4, 4, &aom_highbd_sad4x4_c, 12),
 913 };
 914 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
 915
 916 const SadMxNAvgParam avg_c_tests[] = {
 917 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 918   make_tuple(128, 128, &aom_sad128x128_avg_c, -1),
 919   make_tuple(128, 64, &aom_sad128x64_avg_c, -1),
 920   make_tuple(64, 128, &aom_sad64x128_avg_c, -1),
 921 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 922   make_tuple(64, 64, &aom_sad64x64_avg_c, -1),
 923   make_tuple(64, 32, &aom_sad64x32_avg_c, -1),
 924   make_tuple(32, 64, &aom_sad32x64_avg_c, -1),
 925   make_tuple(32, 32, &aom_sad32x32_avg_c, -1),
 926   make_tuple(32, 16, &aom_sad32x16_avg_c, -1),
 927   make_tuple(16, 32, &aom_sad16x32_avg_c, -1),
 928   make_tuple(16, 16, &aom_sad16x16_avg_c, -1),
 929   make_tuple(16, 8, &aom_sad16x8_avg_c, -1),
 930   make_tuple(8, 16, &aom_sad8x16_avg_c, -1),
 931   make_tuple(8, 8, &aom_sad8x8_avg_c, -1),
 932   make_tuple(8, 4, &aom_sad8x4_avg_c, -1),
 933   make_tuple(4, 8, &aom_sad4x8_avg_c, -1),
 934   make_tuple(4, 4, &aom_sad4x4_avg_c, -1),
 935 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 936   make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 8),
 937   make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 8),
 938   make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 8),
 939 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 940   make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 8),
 941   make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 8),
 942   make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 8),
 943   make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 8),
 944   make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 8),
 945   make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 8),
 946   make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 8),
 947   make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 8),
 948   make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 8),
 949   make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 8),
 950   make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 8),
 951   make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 8),
 952   make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 8),
 953 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 954   make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 10),
 955   make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 10),
 956   make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 10),
 957 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 958   make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 10),
 959   make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 10),
 960   make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 10),
 961   make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 10),
 962   make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 10),
 963   make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 10),
 964   make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 10),
 965   make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 10),
 966   make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 10),
 967   make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 10),
 968   make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 10),
 969   make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 10),
 970   make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 10),
 971 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 972   make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 12),
 973   make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 12),
 974   make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 12),
 975 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
 976   make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 12),
 977   make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 12),
 978   make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 12),
 979   make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 12),
 980   make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 12),
 981   make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 12),
 982   make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 12),
 983   make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 12),
 984   make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 12),
 985   make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 12),
 986   make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 12),
 987   make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 12),
 988   make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 12),
 989 };
 990 INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
 991
 992 #if CONFIG_JNT_COMP
 993 // TODO(chengchen): add highbd tests
 994 const JntCompAvgParam jnt_comp_avg_c_tests[] = {
 995 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
 996   make_tuple(128, 128, &aom_jnt_comp_avg_pred_c, -1),
 997   make_tuple(128, 64, &aom_jnt_comp_avg_pred_c, -1),
 998   make_tuple(64, 128, &aom_jnt_comp_avg_pred_c, -1),
 999 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1000   make_tuple(64, 64, &aom_jnt_comp_avg_pred_c, -1),
1001   make_tuple(64, 32, &aom_jnt_comp_avg_pred_c, -1),
1002   make_tuple(32, 64, &aom_jnt_comp_avg_pred_c, -1),
1003   make_tuple(32, 32, &aom_jnt_comp_avg_pred_c, -1),
1004   make_tuple(32, 16, &aom_jnt_comp_avg_pred_c, -1),
1005   make_tuple(16, 32, &aom_jnt_comp_avg_pred_c, -1),
1006   make_tuple(16, 16, &aom_jnt_comp_avg_pred_c, -1),
1007   make_tuple(16, 8, &aom_jnt_comp_avg_pred_c, -1),
1008   make_tuple(8, 16, &aom_jnt_comp_avg_pred_c, -1),
1009   make_tuple(8, 8, &aom_jnt_comp_avg_pred_c, -1),
1010   make_tuple(8, 4, &aom_jnt_comp_avg_pred_c, -1),
1011   make_tuple(4, 8, &aom_jnt_comp_avg_pred_c, -1),
1012   make_tuple(4, 4, &aom_jnt_comp_avg_pred_c, -1),
1013 };
1014
1015 INSTANTIATE_TEST_CASE_P(C, JntCompAvgTest,
1016                         ::testing::ValuesIn(jnt_comp_avg_c_tests));
1017
1018 const JntSadMxNAvgParam jnt_avg_c_tests[] = {
1019 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1020   make_tuple(128, 128, &aom_jnt_sad128x128_avg_c, -1),
1021   make_tuple(128, 64, &aom_jnt_sad128x64_avg_c, -1),
1022   make_tuple(64, 128, &aom_jnt_sad64x128_avg_c, -1),
1023 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1024   make_tuple(64, 64, &aom_jnt_sad64x64_avg_c, -1),
1025   make_tuple(64, 32, &aom_jnt_sad64x32_avg_c, -1),
1026   make_tuple(32, 64, &aom_jnt_sad32x64_avg_c, -1),
1027   make_tuple(32, 32, &aom_jnt_sad32x32_avg_c, -1),
1028   make_tuple(32, 16, &aom_jnt_sad32x16_avg_c, -1),
1029   make_tuple(16, 32, &aom_jnt_sad16x32_avg_c, -1),
1030   make_tuple(16, 16, &aom_jnt_sad16x16_avg_c, -1),
1031   make_tuple(16, 8, &aom_jnt_sad16x8_avg_c, -1),
1032   make_tuple(8, 16, &aom_jnt_sad8x16_avg_c, -1),
1033   make_tuple(8, 8, &aom_jnt_sad8x8_avg_c, -1),
1034   make_tuple(8, 4, &aom_jnt_sad8x4_avg_c, -1),
1035   make_tuple(4, 8, &aom_jnt_sad4x8_avg_c, -1),
1036   make_tuple(4, 4, &aom_jnt_sad4x4_avg_c, -1),
1037 };
1038 INSTANTIATE_TEST_CASE_P(C, JntSADavgTest, ::testing::ValuesIn(jnt_avg_c_tests));
1039 #endif  // CONFIG_JNT_COMP
1040
1041 const SadMxNx4Param x4d_c_tests[] = {
1042 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1043   make_tuple(128, 128, &aom_sad128x128x4d_c, -1),
1044   make_tuple(128, 64, &aom_sad128x64x4d_c, -1),
1045   make_tuple(64, 128, &aom_sad64x128x4d_c, -1),
1046 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1047   make_tuple(64, 64, &aom_sad64x64x4d_c, -1),
1048   make_tuple(64, 32, &aom_sad64x32x4d_c, -1),
1049   make_tuple(32, 64, &aom_sad32x64x4d_c, -1),
1050   make_tuple(32, 32, &aom_sad32x32x4d_c, -1),
1051   make_tuple(32, 16, &aom_sad32x16x4d_c, -1),
1052   make_tuple(16, 32, &aom_sad16x32x4d_c, -1),
1053   make_tuple(16, 16, &aom_sad16x16x4d_c, -1),
1054   make_tuple(16, 8, &aom_sad16x8x4d_c, -1),
1055   make_tuple(8, 16, &aom_sad8x16x4d_c, -1),
1056   make_tuple(8, 8, &aom_sad8x8x4d_c, -1),
1057   make_tuple(8, 4, &aom_sad8x4x4d_c, -1),
1058   make_tuple(4, 8, &aom_sad4x8x4d_c, -1),
1059   make_tuple(4, 4, &aom_sad4x4x4d_c, -1),
1060 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1061   make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 8),
1062   make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 8),
1063   make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 8),
1064 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1065   make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 8),
1066   make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 8),
1067   make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 8),
1068   make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 8),
1069   make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 8),
1070   make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 8),
1071   make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 8),
1072   make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 8),
1073   make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 8),
1074   make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 8),
1075   make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 8),
1076   make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 8),
1077   make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 8),
1078 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1079   make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 10),
1080   make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 10),
1081   make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 10),
1082 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1083   make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 10),
1084   make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 10),
1085   make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 10),
1086   make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 10),
1087   make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 10),
1088   make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 10),
1089   make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 10),
1090   make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 10),
1091   make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 10),
1092   make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 10),
1093   make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 10),
1094   make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 10),
1095   make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 10),
1096 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1097   make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 12),
1098   make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 12),
1099   make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 12),
1100 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1101   make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 12),
1102   make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 12),
1103   make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 12),
1104   make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 12),
1105   make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 12),
1106   make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 12),
1107   make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 12),
1108   make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 12),
1109   make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 12),
1110   make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 12),
1111   make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 12),
1112   make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 12),
1113   make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 12),
1114 };
1115 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
1116
1117 //------------------------------------------------------------------------------
1118 // ARM functions
1119 #if HAVE_NEON
1120 const SadMxNParam neon_tests[] = {
1121   make_tuple(64, 64, &aom_sad64x64_neon, -1),
1122   make_tuple(32, 32, &aom_sad32x32_neon, -1),
1123   make_tuple(16, 16, &aom_sad16x16_neon, -1),
1124   make_tuple(16, 8, &aom_sad16x8_neon, -1),
1125   make_tuple(8, 16, &aom_sad8x16_neon, -1),
1126   make_tuple(8, 8, &aom_sad8x8_neon, -1),
1127   make_tuple(4, 4, &aom_sad4x4_neon, -1),
1128 };
1129 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
1130
1131 const SadMxNx4Param x4d_neon_tests[] = {
1132   make_tuple(64, 64, &aom_sad64x64x4d_neon, -1),
1133   make_tuple(32, 32, &aom_sad32x32x4d_neon, -1),
1134   make_tuple(16, 16, &aom_sad16x16x4d_neon, -1),
1135 };
1136 INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
1137 #endif  // HAVE_NEON
1138
1139 //------------------------------------------------------------------------------
1140 // x86 functions
1141 #if HAVE_SSE2
1142 const SadMxNParam sse2_tests[] = {
1143 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1144   make_tuple(128, 128, &aom_sad128x128_sse2, -1),
1145   make_tuple(128, 64, &aom_sad128x64_sse2, -1),
1146   make_tuple(64, 128, &aom_sad64x128_sse2, -1),
1147 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1148   make_tuple(64, 64, &aom_sad64x64_sse2, -1),
1149   make_tuple(64, 32, &aom_sad64x32_sse2, -1),
1150   make_tuple(32, 64, &aom_sad32x64_sse2, -1),
1151   make_tuple(32, 32, &aom_sad32x32_sse2, -1),
1152   make_tuple(32, 16, &aom_sad32x16_sse2, -1),
1153   make_tuple(16, 32, &aom_sad16x32_sse2, -1),
1154   make_tuple(16, 16, &aom_sad16x16_sse2, -1),
1155   make_tuple(16, 8, &aom_sad16x8_sse2, -1),
1156   make_tuple(8, 16, &aom_sad8x16_sse2, -1),
1157   make_tuple(8, 8, &aom_sad8x8_sse2, -1),
1158   make_tuple(8, 4, &aom_sad8x4_sse2, -1),
1159   make_tuple(4, 8, &aom_sad4x8_sse2, -1),
1160   make_tuple(4, 4, &aom_sad4x4_sse2, -1),
1161   make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 8),
1162   make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 8),
1163   make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 8),
1164   make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 8),
1165   make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 8),
1166   make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 8),
1167   make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 8),
1168   make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 8),
1169   make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8),
1170   make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8),
1171   make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8),
1172   make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 10),
1173   make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 10),
1174   make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 10),
1175   make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 10),
1176   make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 10),
1177   make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 10),
1178   make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 10),
1179   make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 10),
1180   make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10),
1181   make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10),
1182   make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10),
1183   make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 12),
1184   make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 12),
1185   make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 12),
1186   make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 12),
1187   make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 12),
1188   make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 12),
1189   make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 12),
1190   make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 12),
1191   make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12),
1192   make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12),
1193   make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12),
1194 };
1195 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
1196
1197 const SadMxNAvgParam avg_sse2_tests[] = {
1198 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1199   make_tuple(128, 128, &aom_sad128x128_avg_sse2, -1),
1200   make_tuple(128, 64, &aom_sad128x64_avg_sse2, -1),
1201   make_tuple(64, 128, &aom_sad64x128_avg_sse2, -1),
1202 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1203   make_tuple(64, 64, &aom_sad64x64_avg_sse2, -1),
1204   make_tuple(64, 32, &aom_sad64x32_avg_sse2, -1),
1205   make_tuple(32, 64, &aom_sad32x64_avg_sse2, -1),
1206   make_tuple(32, 32, &aom_sad32x32_avg_sse2, -1),
1207   make_tuple(32, 16, &aom_sad32x16_avg_sse2, -1),
1208   make_tuple(16, 32, &aom_sad16x32_avg_sse2, -1),
1209   make_tuple(16, 16, &aom_sad16x16_avg_sse2, -1),
1210   make_tuple(16, 8, &aom_sad16x8_avg_sse2, -1),
1211   make_tuple(8, 16, &aom_sad8x16_avg_sse2, -1),
1212   make_tuple(8, 8, &aom_sad8x8_avg_sse2, -1),
1213   make_tuple(8, 4, &aom_sad8x4_avg_sse2, -1),
1214   make_tuple(4, 8, &aom_sad4x8_avg_sse2, -1),
1215   make_tuple(4, 4, &aom_sad4x4_avg_sse2, -1),
1216   make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 8),
1217   make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 8),
1218   make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 8),
1219   make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 8),
1220   make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 8),
1221   make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 8),
1222   make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 8),
1223   make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 8),
1224   make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8),
1225   make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8),
1226   make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 8),
1227   make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 10),
1228   make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 10),
1229   make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 10),
1230   make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 10),
1231   make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 10),
1232   make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 10),
1233   make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 10),
1234   make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 10),
1235   make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10),
1236   make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10),
1237   make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 10),
1238   make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 12),
1239   make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 12),
1240   make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 12),
1241   make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 12),
1242   make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 12),
1243   make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 12),
1244   make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 12),
1245   make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 12),
1246   make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12),
1247   make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12),
1248   make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 12),
1249 };
1250 INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
1251
1252 const SadMxNx4Param x4d_sse2_tests[] = {
1253 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1254   make_tuple(128, 128, &aom_sad128x128x4d_sse2, -1),
1255   make_tuple(128, 64, &aom_sad128x64x4d_sse2, -1),
1256   make_tuple(64, 128, &aom_sad64x128x4d_sse2, -1),
1257 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1258   make_tuple(64, 64, &aom_sad64x64x4d_sse2, -1),
1259   make_tuple(64, 32, &aom_sad64x32x4d_sse2, -1),
1260   make_tuple(32, 64, &aom_sad32x64x4d_sse2, -1),
1261   make_tuple(32, 32, &aom_sad32x32x4d_sse2, -1),
1262   make_tuple(32, 16, &aom_sad32x16x4d_sse2, -1),
1263   make_tuple(16, 32, &aom_sad16x32x4d_sse2, -1),
1264   make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1),
1265   make_tuple(16, 8, &aom_sad16x8x4d_sse2, -1),
1266   make_tuple(8, 16, &aom_sad8x16x4d_sse2, -1),
1267   make_tuple(8, 8, &aom_sad8x8x4d_sse2, -1),
1268   make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1),
1269   make_tuple(4, 8, &aom_sad4x8x4d_sse2, -1),
1270   make_tuple(4, 4, &aom_sad4x4x4d_sse2, -1),
1271   make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 8),
1272   make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 8),
1273   make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 8),
1274   make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 8),
1275   make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 8),
1276   make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 8),
1277   make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 8),
1278   make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 8),
1279   make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 8),
1280   make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 8),
1281   make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 8),
1282   make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 8),
1283   make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 8),
1284   make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 10),
1285   make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 10),
1286   make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 10),
1287   make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 10),
1288   make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 10),
1289   make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 10),
1290   make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 10),
1291   make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 10),
1292   make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 10),
1293   make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 10),
1294   make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 10),
1295   make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 10),
1296   make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 10),
1297   make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 12),
1298   make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 12),
1299   make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 12),
1300   make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 12),
1301   make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 12),
1302   make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 12),
1303   make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 12),
1304   make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 12),
1305   make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 12),
1306   make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 12),
1307   make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 12),
1308   make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 12),
1309   make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 12),
1310 };
1311 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
1312
1313 #if CONFIG_JNT_COMP
1314 const JntSadMxhParam jnt_sad_sse2_tests[] = {
1315   make_tuple(4, 4, &aom_sad4xh_sse2, -1),
1316   make_tuple(4, 8, &aom_sad4xh_sse2, -1),
1317   make_tuple(8, 4, &aom_sad8xh_sse2, -1),
1318   make_tuple(8, 8, &aom_sad8xh_sse2, -1),
1319   make_tuple(8, 16, &aom_sad8xh_sse2, -1),
1320   make_tuple(16, 8, &aom_sad16xh_sse2, -1),
1321   make_tuple(16, 16, &aom_sad16xh_sse2, -1),
1322   make_tuple(16, 32, &aom_sad16xh_sse2, -1),
1323   make_tuple(32, 16, &aom_sad32xh_sse2, -1),
1324   make_tuple(32, 32, &aom_sad32xh_sse2, -1),
1325   make_tuple(32, 64, &aom_sad32xh_sse2, -1),
1326   make_tuple(64, 32, &aom_sad64xh_sse2, -1),
1327   make_tuple(64, 64, &aom_sad64xh_sse2, -1),
1328 #if CONFIG_EXT_PARTITION
1329   make_tuple(128, 128, &aom_sad128xh_sse2, -1),
1330   make_tuple(128, 64, &aom_sad128xh_sse2, -1),
1331   make_tuple(64, 128, &aom_sad64xh_sse2, -1),
1332 #endif  // CONFIG_EXT_PARTITION
1333 #if CONFIG_EXT_PARTITION_TYPES
1334   make_tuple(4, 16, &aom_sad4xh_sse2, -1),
1335   make_tuple(16, 4, &aom_sad16xh_sse2, -1),
1336   make_tuple(8, 32, &aom_sad8xh_sse2, -1),
1337   make_tuple(32, 8, &aom_sad32xh_sse2, -1),
1338   make_tuple(16, 64, &aom_sad16xh_sse2, -1),
1339   make_tuple(64, 16, &aom_sad64xh_sse2, -1),
1340   make_tuple(32, 128, &aom_sad32xh_sse2, -1),
1341   make_tuple(128, 32, &aom_sad128xh_sse2, -1),
1342 #endif  // CONFIG_EXT_PARTITION_TYPES
1343 };
1344 INSTANTIATE_TEST_CASE_P(SSE2, JntSADTest,
1345                         ::testing::ValuesIn(jnt_sad_sse2_tests));
1346 #endif  // CONFIG_JNT_COMP
1347
1348 #endif  // HAVE_SSE2
1349
1350 #if HAVE_SSE3
1351 // Only functions are x3, which do not have tests.
1352 #endif  // HAVE_SSE3
1353
1354 #if HAVE_SSSE3
1355 #if CONFIG_JNT_COMP
1356 const JntCompAvgParam jnt_comp_avg_ssse3_tests[] = {
1357 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1358   make_tuple(128, 128, &aom_jnt_comp_avg_pred_ssse3, -1),
1359   make_tuple(128, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
1360   make_tuple(64, 128, &aom_jnt_comp_avg_pred_ssse3, -1),
1361 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1362   make_tuple(64, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
1363   make_tuple(64, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
1364   make_tuple(32, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
1365   make_tuple(32, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
1366   make_tuple(32, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
1367   make_tuple(16, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
1368   make_tuple(16, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
1369   make_tuple(16, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
1370   make_tuple(8, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
1371   make_tuple(8, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
1372   make_tuple(8, 4, &aom_jnt_comp_avg_pred_ssse3, -1),
1373   make_tuple(4, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
1374   make_tuple(4, 4, &aom_jnt_comp_avg_pred_ssse3, -1),
1375   make_tuple(16, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
1376 };
1377
1378 INSTANTIATE_TEST_CASE_P(SSSE3, JntCompAvgTest,
1379                         ::testing::ValuesIn(jnt_comp_avg_ssse3_tests));
1380
1381 const JntSadMxNAvgParam jnt_avg_ssse3_tests[] = {
1382 #if CONFIG_AV1 && CONFIG_EXT_PARTITION
1383   make_tuple(128, 128, &aom_jnt_sad128x128_avg_ssse3, -1),
1384   make_tuple(128, 64, &aom_jnt_sad128x64_avg_ssse3, -1),
1385   make_tuple(64, 128, &aom_jnt_sad64x128_avg_ssse3, -1),
1386 #endif  // CONFIG_AV1 && CONFIG_EXT_PARTITION
1387   make_tuple(64, 64, &aom_jnt_sad64x64_avg_ssse3, -1),
1388   make_tuple(64, 32, &aom_jnt_sad64x32_avg_ssse3, -1),
1389   make_tuple(32, 64, &aom_jnt_sad32x64_avg_ssse3, -1),
1390   make_tuple(32, 32, &aom_jnt_sad32x32_avg_ssse3, -1),
1391   make_tuple(32, 16, &aom_jnt_sad32x16_avg_ssse3, -1),
1392   make_tuple(16, 32, &aom_jnt_sad16x32_avg_ssse3, -1),
1393   make_tuple(16, 16, &aom_jnt_sad16x16_avg_ssse3, -1),
1394   make_tuple(16, 8, &aom_jnt_sad16x8_avg_ssse3, -1),
1395   make_tuple(8, 16, &aom_jnt_sad8x16_avg_ssse3, -1),
1396   make_tuple(8, 8, &aom_jnt_sad8x8_avg_ssse3, -1),
1397   make_tuple(8, 4, &aom_jnt_sad8x4_avg_ssse3, -1),
1398   make_tuple(4, 8, &aom_jnt_sad4x8_avg_ssse3, -1),
1399   make_tuple(4, 4, &aom_jnt_sad4x4_avg_ssse3, -1),
1400 };
1401 INSTANTIATE_TEST_CASE_P(SSSE3, JntSADavgTest,
1402                         ::testing::ValuesIn(jnt_avg_ssse3_tests));
1403 #endif  // CONFIG_JNT_COMP
1404 #endif  // HAVE_SSSE3
1405
1406 #if HAVE_SSE4_1
1407 // Only functions are x8, which do not have tests.
1408 #endif  // HAVE_SSE4_1
1409
1410 #if HAVE_AVX2
1411 const SadMxNParam avx2_tests[] = {
1412 #if CONFIG_EXT_PARTITION
1413   make_tuple(64, 128, &aom_sad64x128_avx2, -1),
1414   make_tuple(128, 64, &aom_sad128x64_avx2, -1),
1415   make_tuple(128, 128, &aom_sad128x128_avx2, -1),
1416 #endif
1417   make_tuple(64, 64, &aom_sad64x64_avx2, -1),
1418   make_tuple(64, 32, &aom_sad64x32_avx2, -1),
1419   make_tuple(32, 64, &aom_sad32x64_avx2, -1),
1420   make_tuple(32, 32, &aom_sad32x32_avx2, -1),
1421   make_tuple(32, 16, &aom_sad32x16_avx2, -1),
1422 #if CONFIG_EXT_PARTITION
1423   make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 8),
1424   make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 10),
1425   make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 12),
1426   make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 8),
1427   make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 10),
1428   make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 12),
1429   make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 8),
1430   make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 10),
1431   make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 12),
1432 #endif
1433   make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 8),
1434   make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 10),
1435   make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 12),
1436   make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 8),
1437   make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 10),
1438   make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 12),
1439   make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 8),
1440   make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 10),
1441   make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 12),
1442   make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 8),
1443   make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 10),
1444   make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 12),
1445   make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 8),
1446   make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 10),
1447   make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 12),
1448   make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 8),
1449   make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 10),
1450   make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 12),
1451   make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 8),
1452   make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 10),
1453   make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 12),
1454   make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 8),
1455   make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 10),
1456   make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 12),
1457 };
1458 INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
1459
1460 const SadMxNAvgParam avg_avx2_tests[] = {
1461 #if CONFIG_EXT_PARTITION
1462   make_tuple(64, 128, &aom_sad64x128_avg_avx2, -1),
1463   make_tuple(128, 64, &aom_sad128x64_avg_avx2, -1),
1464   make_tuple(128, 128, &aom_sad128x128_avg_avx2, -1),
1465 #endif
1466   make_tuple(64, 64, &aom_sad64x64_avg_avx2, -1),
1467   make_tuple(64, 32, &aom_sad64x32_avg_avx2, -1),
1468   make_tuple(32, 64, &aom_sad32x64_avg_avx2, -1),
1469   make_tuple(32, 32, &aom_sad32x32_avg_avx2, -1),
1470   make_tuple(32, 16, &aom_sad32x16_avg_avx2, -1),
1471 #if CONFIG_EXT_PARTITION
1472   make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 8),
1473   make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 10),
1474   make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 12),
1475   make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 8),
1476   make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 10),
1477   make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 12),
1478   make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 8),
1479   make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 10),
1480   make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 12),
1481 #endif
1482   make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 8),
1483   make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 10),
1484   make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 12),
1485   make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 8),
1486   make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 10),
1487   make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 12),
1488   make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 8),
1489   make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 10),
1490   make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 12),
1491   make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 8),
1492   make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 10),
1493   make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 12),
1494   make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 8),
1495   make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 10),
1496   make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 12),
1497   make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 8),
1498   make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 10),
1499   make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 12),
1500   make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 8),
1501   make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 10),
1502   make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 12),
1503   make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 8),
1504   make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 10),
1505   make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 12),
1506 };
1507 INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
1508
1509 const SadMxNx4Param x4d_avx2_tests[] = {
1510 #if CONFIG_EXT_PARTITION
1511   make_tuple(64, 128, &aom_sad64x128x4d_avx2, -1),
1512   make_tuple(128, 64, &aom_sad128x64x4d_avx2, -1),
1513   make_tuple(128, 128, &aom_sad128x128x4d_avx2, -1),
1514 #endif
1515   make_tuple(64, 64, &aom_sad64x64x4d_avx2, -1),
1516   make_tuple(32, 64, &aom_sad32x64x4d_avx2, -1),
1517   make_tuple(64, 32, &aom_sad64x32x4d_avx2, -1),
1518   make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1),
1519 #if CONFIG_EXT_PARTITION
1520   make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 8),
1521   make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 10),
1522   make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 12),
1523   make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 8),
1524   make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 10),
1525   make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 12),
1526   make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 8),
1527   make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 10),
1528   make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 12),
1529 #endif
1530   make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 8),
1531   make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 10),
1532   make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 12),
1533   make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 8),
1534   make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 10),
1535   make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 12),
1536   make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 8),
1537   make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 10),
1538   make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 12),
1539   make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 8),
1540   make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 10),
1541   make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 12),
1542   make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 8),
1543   make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 10),
1544   make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 12),
1545   make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 8),
1546   make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 10),
1547   make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 12),
1548   make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 8),
1549   make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 10),
1550   make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 12),
1551   make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 8),
1552   make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 10),
1553   make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 12),
1554 };
1555 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
1556 #endif  // HAVE_AVX2
1557
1558 //------------------------------------------------------------------------------
1559 // MIPS functions
1560 #if HAVE_MSA
1561 const SadMxNParam msa_tests[] = {
1562   make_tuple(64, 64, &aom_sad64x64_msa, -1),
1563   make_tuple(64, 32, &aom_sad64x32_msa, -1),
1564   make_tuple(32, 64, &aom_sad32x64_msa, -1),
1565   make_tuple(32, 32, &aom_sad32x32_msa, -1),
1566   make_tuple(32, 16, &aom_sad32x16_msa, -1),
1567   make_tuple(16, 32, &aom_sad16x32_msa, -1),
1568   make_tuple(16, 16, &aom_sad16x16_msa, -1),
1569   make_tuple(16, 8, &aom_sad16x8_msa, -1),
1570   make_tuple(8, 16, &aom_sad8x16_msa, -1),
1571   make_tuple(8, 8, &aom_sad8x8_msa, -1),
1572   make_tuple(8, 4, &aom_sad8x4_msa, -1),
1573   make_tuple(4, 8, &aom_sad4x8_msa, -1),
1574   make_tuple(4, 4, &aom_sad4x4_msa, -1),
1575 };
1576 INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
1577
1578 const SadMxNAvgParam avg_msa_tests[] = {
1579   make_tuple(64, 64, &aom_sad64x64_avg_msa, -1),
1580   make_tuple(64, 32, &aom_sad64x32_avg_msa, -1),
1581   make_tuple(32, 64, &aom_sad32x64_avg_msa, -1),
1582   make_tuple(32, 32, &aom_sad32x32_avg_msa, -1),
1583   make_tuple(32, 16, &aom_sad32x16_avg_msa, -1),
1584   make_tuple(16, 32, &aom_sad16x32_avg_msa, -1),
1585   make_tuple(16, 16, &aom_sad16x16_avg_msa, -1),
1586   make_tuple(16, 8, &aom_sad16x8_avg_msa, -1),
1587   make_tuple(8, 16, &aom_sad8x16_avg_msa, -1),
1588   make_tuple(8, 8, &aom_sad8x8_avg_msa, -1),
1589   make_tuple(8, 4, &aom_sad8x4_avg_msa, -1),
1590   make_tuple(4, 8, &aom_sad4x8_avg_msa, -1),
1591   make_tuple(4, 4, &aom_sad4x4_avg_msa, -1),
1592 };
1593 INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
1594
1595 const SadMxNx4Param x4d_msa_tests[] = {
1596   make_tuple(64, 64, &aom_sad64x64x4d_msa, -1),
1597   make_tuple(64, 32, &aom_sad64x32x4d_msa, -1),
1598   make_tuple(32, 64, &aom_sad32x64x4d_msa, -1),
1599   make_tuple(32, 32, &aom_sad32x32x4d_msa, -1),
1600   make_tuple(32, 16, &aom_sad32x16x4d_msa, -1),
1601   make_tuple(16, 32, &aom_sad16x32x4d_msa, -1),
1602   make_tuple(16, 16, &aom_sad16x16x4d_msa, -1),
1603   make_tuple(16, 8, &aom_sad16x8x4d_msa, -1),
1604   make_tuple(8, 16, &aom_sad8x16x4d_msa, -1),
1605   make_tuple(8, 8, &aom_sad8x8x4d_msa, -1),
1606   make_tuple(8, 4, &aom_sad8x4x4d_msa, -1),
1607   make_tuple(4, 8, &aom_sad4x8x4d_msa, -1),
1608   make_tuple(4, 4, &aom_sad4x4x4d_msa, -1),
1609 };
1610 INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
1611 #endif  // HAVE_MSA
1612
1613 }  // namespace