sad_test.cc (130869B)
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 #include <tuple> 16 17 #include "gtest/gtest.h" 18 19 #include "config/aom_config.h" 20 #include "config/aom_dsp_rtcd.h" 21 22 #include "test/acm_random.h" 23 #include "test/register_state_check.h" 24 #include "test/util.h" 25 #include "aom/aom_codec.h" 26 #include "aom_mem/aom_mem.h" 27 #include "aom_ports/mem.h" 28 29 using SadMxNFunc = unsigned int (*)(const uint8_t *src_ptr, int src_stride, 30 const uint8_t *ref_ptr, int ref_stride); 31 using SadMxNParam = std::tuple<int, int, SadMxNFunc, int>; 32 33 using SadSkipMxNFunc = unsigned int (*)(const uint8_t *src_ptr, int src_stride, 34 const uint8_t *ref_ptr, int ref_stride); 35 using SadSkipMxNParam = std::tuple<int, int, SadSkipMxNFunc, int>; 36 37 using SadMxNAvgFunc = uint32_t (*)(const uint8_t *src_ptr, int src_stride, 38 const uint8_t *ref_ptr, int ref_stride, 39 const uint8_t *second_pred); 40 using SadMxNAvgParam = std::tuple<int, int, SadMxNAvgFunc, int>; 41 42 using DistWtdSadMxhFunc = unsigned int (*)(const uint8_t *src_ptr, 43 int src_stride, 44 const uint8_t *ref_ptr, 45 int ref_stride, int width, 46 int height); 47 using DistWtdSadMxhParam = std::tuple<int, int, DistWtdSadMxhFunc, int>; 48 49 using SadMxNx4Func = void (*)(const uint8_t *src_ptr, int src_stride, 50 const uint8_t *const ref_ptr[], int ref_stride, 51 uint32_t *sad_array); 52 using SadMxNx4Param = std::tuple<int, int, SadMxNx4Func, int>; 53 54 using SadSkipMxNx4Func = void (*)(const uint8_t *src_ptr, int src_stride, 55 const uint8_t *const ref_ptr[], 56 int ref_stride, uint32_t *sad_array); 57 using SadSkipMxNx4Param = std::tuple<int, int, SadSkipMxNx4Func, int>; 58 59 using SadMxNx4AvgFunc = void (*)(const uint8_t *src_ptr, int src_stride, 60 const uint8_t *const ref_ptr[], int ref_stride, 61 const uint8_t *second_pred, 62 uint32_t *sad_array); 63 using SadMxNx4AvgParam = std::tuple<int, int, SadMxNx4AvgFunc, int>; 64 65 using libaom_test::ACMRandom; 66 67 namespace { 68 class SADTestBase : public ::testing::Test { 69 public: 70 SADTestBase(int width, int height, int bit_depth) 71 : width_(width), height_(height), bd_(bit_depth) {} 72 73 static void SetUpTestSuite() { 74 source_data8_ = reinterpret_cast<uint8_t *>( 75 aom_memalign(kDataAlignment, kDataBlockSize)); 76 ASSERT_NE(source_data8_, nullptr); 77 reference_data8_ = reinterpret_cast<uint8_t *>( 78 aom_memalign(kDataAlignment, kDataBufferSize)); 79 ASSERT_NE(reference_data8_, nullptr); 80 second_pred8_ = 81 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128)); 82 ASSERT_NE(second_pred8_, nullptr); 83 comp_pred8_ = 84 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128)); 85 ASSERT_NE(comp_pred8_, nullptr); 86 comp_pred8_test_ = 87 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128)); 88 ASSERT_NE(comp_pred8_test_, nullptr); 89 source_data16_ = reinterpret_cast<uint16_t *>( 90 aom_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t))); 91 ASSERT_NE(source_data16_, nullptr); 92 reference_data16_ = reinterpret_cast<uint16_t *>( 93 aom_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t))); 94 ASSERT_NE(reference_data16_, nullptr); 95 second_pred16_ = reinterpret_cast<uint16_t *>( 96 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t))); 97 ASSERT_NE(second_pred16_, nullptr); 98 comp_pred16_ = reinterpret_cast<uint16_t *>( 99 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t))); 100 ASSERT_NE(comp_pred16_, nullptr); 101 comp_pred16_test_ = reinterpret_cast<uint16_t *>( 102 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t))); 103 ASSERT_NE(comp_pred16_test_, nullptr); 104 } 105 106 static void TearDownTestSuite() { 107 aom_free(source_data8_); 108 source_data8_ = nullptr; 109 aom_free(reference_data8_); 110 reference_data8_ = nullptr; 111 aom_free(second_pred8_); 112 second_pred8_ = nullptr; 113 aom_free(comp_pred8_); 114 comp_pred8_ = nullptr; 115 aom_free(comp_pred8_test_); 116 comp_pred8_test_ = nullptr; 117 aom_free(source_data16_); 118 source_data16_ = nullptr; 119 aom_free(reference_data16_); 120 reference_data16_ = nullptr; 121 aom_free(second_pred16_); 122 second_pred16_ = nullptr; 123 aom_free(comp_pred16_); 124 comp_pred16_ = nullptr; 125 aom_free(comp_pred16_test_); 126 comp_pred16_test_ = nullptr; 127 } 128 129 protected: 130 // Handle up to 4 128x128 blocks, with stride up to 256 131 static const int kDataAlignment = 16; 132 static const int kDataBlockSize = 128 * 256; 133 static const int kDataBufferSize = 4 * kDataBlockSize; 134 135 void SetUp() override { 136 if (bd_ == -1) { 137 use_high_bit_depth_ = false; 138 bit_depth_ = AOM_BITS_8; 139 source_data_ = source_data8_; 140 reference_data_ = reference_data8_; 141 second_pred_ = second_pred8_; 142 comp_pred_ = comp_pred8_; 143 comp_pred_test_ = comp_pred8_test_; 144 } else { 145 use_high_bit_depth_ = true; 146 bit_depth_ = static_cast<aom_bit_depth_t>(bd_); 147 source_data_ = CONVERT_TO_BYTEPTR(source_data16_); 148 reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_); 149 second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_); 150 comp_pred_ = CONVERT_TO_BYTEPTR(comp_pred16_); 151 comp_pred_test_ = CONVERT_TO_BYTEPTR(comp_pred16_test_); 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 Skip rows. Given two blocks, 190 // calculate the absolute difference between two pixels in the same 191 // relative location every other row; accumulate and double the result at the 192 // end. 193 unsigned int ReferenceSADSkip(int block_idx) { 194 unsigned int sad = 0; 195 const uint8_t *const reference8 = GetReference(block_idx); 196 const uint8_t *const source8 = source_data_; 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 for (int h = 0; h < height_; h += 2) { 201 for (int w = 0; w < width_; ++w) { 202 if (!use_high_bit_depth_) { 203 sad += abs(source8[h * source_stride_ + w] - 204 reference8[h * reference_stride_ + w]); 205 } else { 206 sad += abs(source16[h * source_stride_ + w] - 207 reference16[h * reference_stride_ + w]); 208 } 209 } 210 } 211 return sad * 2; 212 } 213 214 // Sum of Absolute Differences Average. Given two blocks, and a prediction 215 // calculate the absolute difference between one pixel and average of the 216 // corresponding and predicted pixels; accumulate. 217 unsigned int ReferenceSADavg(int block_idx) { 218 unsigned int sad = 0; 219 const uint8_t *const reference8 = GetReference(block_idx); 220 const uint8_t *const source8 = source_data_; 221 const uint8_t *const second_pred8 = second_pred_; 222 const uint16_t *const reference16 = 223 CONVERT_TO_SHORTPTR(GetReference(block_idx)); 224 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_); 225 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_); 226 for (int h = 0; h < height_; ++h) { 227 for (int w = 0; w < width_; ++w) { 228 if (!use_high_bit_depth_) { 229 const int tmp = second_pred8[h * width_ + w] + 230 reference8[h * reference_stride_ + w]; 231 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); 232 sad += abs(source8[h * source_stride_ + w] - comp_pred); 233 } else { 234 const int tmp = second_pred16[h * width_ + w] + 235 reference16[h * reference_stride_ + w]; 236 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); 237 sad += abs(source16[h * source_stride_ + w] - comp_pred); 238 } 239 } 240 } 241 return sad; 242 } 243 244 unsigned int ReferenceDistWtdSADavg(int block_idx) { 245 unsigned int sad = 0; 246 const uint8_t *const reference8 = GetReference(block_idx); 247 const uint8_t *const source8 = source_data_; 248 const uint8_t *const second_pred8 = second_pred_; 249 const uint16_t *const reference16 = 250 CONVERT_TO_SHORTPTR(GetReference(block_idx)); 251 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_); 252 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_); 253 for (int h = 0; h < height_; ++h) { 254 for (int w = 0; w < width_; ++w) { 255 if (!use_high_bit_depth_) { 256 const int tmp = 257 second_pred8[h * width_ + w] * jcp_param_.bck_offset + 258 reference8[h * reference_stride_ + w] * jcp_param_.fwd_offset; 259 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4); 260 sad += abs(source8[h * source_stride_ + w] - comp_pred); 261 } else { 262 const int tmp = 263 second_pred16[h * width_ + w] * jcp_param_.bck_offset + 264 reference16[h * reference_stride_ + w] * jcp_param_.fwd_offset; 265 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4); 266 sad += abs(source16[h * source_stride_ + w] - comp_pred); 267 } 268 } 269 } 270 return sad; 271 } 272 273 void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) { 274 uint8_t *data8 = data; 275 uint16_t *data16 = CONVERT_TO_SHORTPTR(data); 276 for (int h = 0; h < height_; ++h) { 277 for (int w = 0; w < width_; ++w) { 278 if (!use_high_bit_depth_) { 279 data8[h * stride + w] = static_cast<uint8_t>(fill_constant); 280 } else { 281 data16[h * stride + w] = fill_constant; 282 } 283 } 284 } 285 } 286 287 void FillRandom(uint8_t *data, int stride) { 288 uint8_t *data8 = data; 289 uint16_t *data16 = CONVERT_TO_SHORTPTR(data); 290 for (int h = 0; h < height_; ++h) { 291 for (int w = 0; w < width_; ++w) { 292 if (!use_high_bit_depth_) { 293 data8[h * stride + w] = rnd_.Rand8(); 294 } else { 295 data16[h * stride + w] = rnd_.Rand16() & mask_; 296 } 297 } 298 } 299 } 300 301 virtual void SADForSpeedTest(unsigned int *results, 302 const uint8_t *const *references) { 303 (void)results; 304 (void)references; 305 } 306 307 void SpeedSAD() { 308 int test_count = 20000000; 309 unsigned int exp_sad[4]; 310 const uint8_t *references[] = { GetReference(0), GetReference(1), 311 GetReference(2), GetReference(3) }; 312 aom_usec_timer timer; 313 aom_usec_timer_start(&timer); 314 while (test_count > 0) { 315 SADForSpeedTest(exp_sad, references); 316 test_count -= 1; 317 } 318 aom_usec_timer_mark(&timer); 319 const int64_t time = aom_usec_timer_elapsed(&timer) / 1000; 320 std::cout << "BLOCK_" << width_ << "X" << height_ 321 << ", bit_depth:" << bit_depth_ << ",Time: " << time << "ms" 322 << std::endl; 323 } 324 325 int width_, height_, mask_, bd_; 326 aom_bit_depth_t bit_depth_; 327 static uint8_t *source_data_; 328 static uint8_t *reference_data_; 329 static uint8_t *second_pred_; 330 int source_stride_; 331 bool use_high_bit_depth_; 332 static uint8_t *source_data8_; 333 static uint8_t *reference_data8_; 334 static uint8_t *second_pred8_; 335 static uint16_t *source_data16_; 336 static uint16_t *reference_data16_; 337 static uint16_t *second_pred16_; 338 int reference_stride_; 339 static uint8_t *comp_pred_; 340 static uint8_t *comp_pred8_; 341 static uint16_t *comp_pred16_; 342 static uint8_t *comp_pred_test_; 343 static uint8_t *comp_pred8_test_; 344 static uint16_t *comp_pred16_test_; 345 DIST_WTD_COMP_PARAMS jcp_param_; 346 347 ACMRandom rnd_; 348 }; 349 350 class SADx4Test : public ::testing::WithParamInterface<SadMxNx4Param>, 351 public SADTestBase { 352 public: 353 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 354 355 protected: 356 void SADs(unsigned int *results) { 357 const uint8_t *references[] = { GetReference(0), GetReference(1), 358 GetReference(2), GetReference(3) }; 359 360 API_REGISTER_STATE_CHECK(GET_PARAM(2)( 361 source_data_, source_stride_, references, reference_stride_, results)); 362 } 363 364 void SADForSpeedTest(unsigned int *results, 365 const uint8_t *const *references) override { 366 GET_PARAM(2) 367 (source_data_, source_stride_, references, reference_stride_, results); 368 } 369 370 void CheckSADs() { 371 unsigned int reference_sad, exp_sad[4]; 372 SADs(exp_sad); 373 for (int block = 0; block < 4; ++block) { 374 reference_sad = ReferenceSAD(block); 375 376 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; 377 } 378 } 379 }; 380 381 class SADx3Test : public ::testing::WithParamInterface<SadMxNx4Param>, 382 public SADTestBase { 383 public: 384 SADx3Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 385 386 protected: 387 void SADs(unsigned int *results) { 388 const uint8_t *references[] = { GetReference(0), GetReference(1), 389 GetReference(2), GetReference(3) }; 390 391 GET_PARAM(2) 392 (source_data_, source_stride_, references, reference_stride_, results); 393 } 394 395 void SADForSpeedTest(unsigned int *results, 396 const uint8_t *const *references) override { 397 GET_PARAM(2) 398 (source_data_, source_stride_, references, reference_stride_, results); 399 } 400 401 void CheckSADs() { 402 unsigned int reference_sad, exp_sad[4]; 403 404 SADs(exp_sad); 405 for (int block = 0; block < 3; ++block) { 406 reference_sad = ReferenceSAD(block); 407 408 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; 409 } 410 } 411 }; 412 413 class SADSkipx4Test : public ::testing::WithParamInterface<SadMxNx4Param>, 414 public SADTestBase { 415 public: 416 SADSkipx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 417 418 protected: 419 void SADs(unsigned int *results) { 420 const uint8_t *references[] = { GetReference(0), GetReference(1), 421 GetReference(2), GetReference(3) }; 422 423 API_REGISTER_STATE_CHECK(GET_PARAM(2)( 424 source_data_, source_stride_, references, reference_stride_, results)); 425 } 426 427 void CheckSADs() { 428 unsigned int reference_sad, exp_sad[4]; 429 430 SADs(exp_sad); 431 for (int block = 0; block < 4; ++block) { 432 reference_sad = ReferenceSADSkip(block); 433 434 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; 435 } 436 } 437 438 void SADForSpeedTest(unsigned int *results, 439 const uint8_t *const *references) override { 440 GET_PARAM(2) 441 (source_data_, source_stride_, references, reference_stride_, results); 442 } 443 }; 444 445 class SADTest : public ::testing::WithParamInterface<SadMxNParam>, 446 public SADTestBase { 447 public: 448 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 449 450 protected: 451 unsigned int SAD(int block_idx) { 452 unsigned int ret; 453 const uint8_t *const reference = GetReference(block_idx); 454 455 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, 456 reference, reference_stride_)); 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 SADForSpeedTest(unsigned int *results, 468 const uint8_t *const *references) override { 469 GET_PARAM(2) 470 (source_data_, source_stride_, references[0], reference_stride_); 471 (void)results; 472 } 473 }; 474 475 class SADSkipTest : public ::testing::WithParamInterface<SadMxNParam>, 476 public SADTestBase { 477 public: 478 SADSkipTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 479 480 protected: 481 unsigned int SAD(int block_idx) { 482 unsigned int ret; 483 const uint8_t *const reference = GetReference(block_idx); 484 485 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, 486 reference, reference_stride_)); 487 return ret; 488 } 489 490 void CheckSAD() { 491 const unsigned int reference_sad = ReferenceSADSkip(0); 492 const unsigned int exp_sad = SAD(0); 493 494 ASSERT_EQ(reference_sad, exp_sad); 495 } 496 497 void SADForSpeedTest(unsigned int *results, 498 const uint8_t *const *references) override { 499 GET_PARAM(2) 500 (source_data_, source_stride_, references[0], reference_stride_); 501 (void)results; 502 } 503 }; 504 505 class SADavgTest : public ::testing::WithParamInterface<SadMxNAvgParam>, 506 public SADTestBase { 507 public: 508 SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 509 510 protected: 511 unsigned int SAD_avg(int block_idx) { 512 unsigned int ret; 513 const uint8_t *const reference = GetReference(block_idx); 514 515 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, 516 reference, reference_stride_, 517 second_pred_)); 518 return ret; 519 } 520 521 void CheckSAD() { 522 const unsigned int reference_sad = ReferenceSADavg(0); 523 const unsigned int exp_sad = SAD_avg(0); 524 525 ASSERT_EQ(reference_sad, exp_sad); 526 } 527 }; 528 529 uint8_t *SADTestBase::source_data_ = nullptr; 530 uint8_t *SADTestBase::reference_data_ = nullptr; 531 uint8_t *SADTestBase::second_pred_ = nullptr; 532 uint8_t *SADTestBase::comp_pred_ = nullptr; 533 uint8_t *SADTestBase::comp_pred_test_ = nullptr; 534 uint8_t *SADTestBase::source_data8_ = nullptr; 535 uint8_t *SADTestBase::reference_data8_ = nullptr; 536 uint8_t *SADTestBase::second_pred8_ = nullptr; 537 uint8_t *SADTestBase::comp_pred8_ = nullptr; 538 uint8_t *SADTestBase::comp_pred8_test_ = nullptr; 539 uint16_t *SADTestBase::source_data16_ = nullptr; 540 uint16_t *SADTestBase::reference_data16_ = nullptr; 541 uint16_t *SADTestBase::second_pred16_ = nullptr; 542 uint16_t *SADTestBase::comp_pred16_ = nullptr; 543 uint16_t *SADTestBase::comp_pred16_test_ = nullptr; 544 545 TEST_P(SADTest, MaxRef) { 546 FillConstant(source_data_, source_stride_, 0); 547 FillConstant(reference_data_, reference_stride_, mask_); 548 CheckSAD(); 549 } 550 551 TEST_P(SADTest, MaxSrc) { 552 FillConstant(source_data_, source_stride_, mask_); 553 FillConstant(reference_data_, reference_stride_, 0); 554 CheckSAD(); 555 } 556 557 TEST_P(SADTest, ShortRef) { 558 const int tmp_stride = reference_stride_; 559 reference_stride_ >>= 1; 560 FillRandom(source_data_, source_stride_); 561 FillRandom(reference_data_, reference_stride_); 562 CheckSAD(); 563 reference_stride_ = tmp_stride; 564 } 565 566 TEST_P(SADTest, UnalignedRef) { 567 // The reference frame, but not the source frame, may be unaligned for 568 // certain types of searches. 569 const int tmp_stride = reference_stride_; 570 reference_stride_ -= 1; 571 FillRandom(source_data_, source_stride_); 572 FillRandom(reference_data_, reference_stride_); 573 CheckSAD(); 574 reference_stride_ = tmp_stride; 575 } 576 577 TEST_P(SADTest, ShortSrc) { 578 const int tmp_stride = source_stride_; 579 source_stride_ >>= 1; 580 int test_count = 2000; 581 while (test_count > 0) { 582 FillRandom(source_data_, source_stride_); 583 FillRandom(reference_data_, reference_stride_); 584 CheckSAD(); 585 if (testing::Test::HasFatalFailure()) break; 586 test_count -= 1; 587 } 588 source_stride_ = tmp_stride; 589 } 590 591 TEST_P(SADTest, DISABLED_Speed) { 592 const int tmp_stride = source_stride_; 593 source_stride_ >>= 1; 594 FillRandom(source_data_, source_stride_); 595 FillRandom(reference_data_, reference_stride_); 596 SpeedSAD(); 597 source_stride_ = tmp_stride; 598 } 599 600 TEST_P(SADSkipTest, MaxRef) { 601 FillConstant(source_data_, source_stride_, 0); 602 FillConstant(reference_data_, reference_stride_, mask_); 603 CheckSAD(); 604 } 605 606 TEST_P(SADSkipTest, MaxSrc) { 607 FillConstant(source_data_, source_stride_, mask_); 608 FillConstant(reference_data_, reference_stride_, 0); 609 CheckSAD(); 610 } 611 612 TEST_P(SADSkipTest, ShortRef) { 613 const int tmp_stride = reference_stride_; 614 reference_stride_ >>= 1; 615 FillRandom(source_data_, source_stride_); 616 FillRandom(reference_data_, reference_stride_); 617 CheckSAD(); 618 reference_stride_ = tmp_stride; 619 } 620 621 TEST_P(SADSkipTest, UnalignedRef) { 622 // The reference frame, but not the source frame, may be unaligned for 623 // certain types of searches. 624 const int tmp_stride = reference_stride_; 625 reference_stride_ -= 1; 626 FillRandom(source_data_, source_stride_); 627 FillRandom(reference_data_, reference_stride_); 628 CheckSAD(); 629 reference_stride_ = tmp_stride; 630 } 631 632 TEST_P(SADSkipTest, ShortSrc) { 633 const int tmp_stride = source_stride_; 634 source_stride_ >>= 1; 635 int test_count = 2000; 636 while (test_count > 0) { 637 FillRandom(source_data_, source_stride_); 638 FillRandom(reference_data_, reference_stride_); 639 CheckSAD(); 640 if (testing::Test::HasFatalFailure()) break; 641 test_count -= 1; 642 } 643 source_stride_ = tmp_stride; 644 } 645 646 TEST_P(SADSkipTest, DISABLED_Speed) { 647 const int tmp_stride = source_stride_; 648 source_stride_ >>= 1; 649 FillRandom(source_data_, source_stride_); 650 FillRandom(reference_data_, reference_stride_); 651 SpeedSAD(); 652 source_stride_ = tmp_stride; 653 } 654 655 TEST_P(SADavgTest, MaxRef) { 656 FillConstant(source_data_, source_stride_, 0); 657 FillConstant(reference_data_, reference_stride_, mask_); 658 FillConstant(second_pred_, width_, 0); 659 CheckSAD(); 660 } 661 TEST_P(SADavgTest, MaxSrc) { 662 FillConstant(source_data_, source_stride_, mask_); 663 FillConstant(reference_data_, reference_stride_, 0); 664 FillConstant(second_pred_, width_, 0); 665 CheckSAD(); 666 } 667 668 TEST_P(SADavgTest, ShortRef) { 669 const int tmp_stride = reference_stride_; 670 reference_stride_ >>= 1; 671 FillRandom(source_data_, source_stride_); 672 FillRandom(reference_data_, reference_stride_); 673 FillRandom(second_pred_, width_); 674 CheckSAD(); 675 reference_stride_ = tmp_stride; 676 } 677 678 TEST_P(SADavgTest, UnalignedRef) { 679 // The reference frame, but not the source frame, may be unaligned for 680 // certain types of searches. 681 const int tmp_stride = reference_stride_; 682 reference_stride_ -= 1; 683 FillRandom(source_data_, source_stride_); 684 FillRandom(reference_data_, reference_stride_); 685 FillRandom(second_pred_, width_); 686 CheckSAD(); 687 reference_stride_ = tmp_stride; 688 } 689 690 TEST_P(SADavgTest, ShortSrc) { 691 const int tmp_stride = source_stride_; 692 source_stride_ >>= 1; 693 int test_count = 2000; 694 while (test_count > 0) { 695 FillRandom(source_data_, source_stride_); 696 FillRandom(reference_data_, reference_stride_); 697 FillRandom(second_pred_, width_); 698 CheckSAD(); 699 if (testing::Test::HasFatalFailure()) break; 700 test_count -= 1; 701 } 702 source_stride_ = tmp_stride; 703 } 704 705 // SADx4 706 TEST_P(SADx4Test, MaxRef) { 707 FillConstant(source_data_, source_stride_, 0); 708 FillConstant(GetReference(0), reference_stride_, mask_); 709 FillConstant(GetReference(1), reference_stride_, mask_); 710 FillConstant(GetReference(2), reference_stride_, mask_); 711 FillConstant(GetReference(3), reference_stride_, mask_); 712 CheckSADs(); 713 } 714 715 TEST_P(SADx4Test, MaxSrc) { 716 FillConstant(source_data_, source_stride_, mask_); 717 FillConstant(GetReference(0), reference_stride_, 0); 718 FillConstant(GetReference(1), reference_stride_, 0); 719 FillConstant(GetReference(2), reference_stride_, 0); 720 FillConstant(GetReference(3), reference_stride_, 0); 721 CheckSADs(); 722 } 723 724 TEST_P(SADx4Test, ShortRef) { 725 int tmp_stride = reference_stride_; 726 reference_stride_ >>= 1; 727 FillRandom(source_data_, source_stride_); 728 FillRandom(GetReference(0), reference_stride_); 729 FillRandom(GetReference(1), reference_stride_); 730 FillRandom(GetReference(2), reference_stride_); 731 FillRandom(GetReference(3), reference_stride_); 732 CheckSADs(); 733 reference_stride_ = tmp_stride; 734 } 735 736 TEST_P(SADx4Test, UnalignedRef) { 737 // The reference frame, but not the source frame, may be unaligned for 738 // certain types of searches. 739 int tmp_stride = reference_stride_; 740 reference_stride_ -= 1; 741 FillRandom(source_data_, source_stride_); 742 FillRandom(GetReference(0), reference_stride_); 743 FillRandom(GetReference(1), reference_stride_); 744 FillRandom(GetReference(2), reference_stride_); 745 FillRandom(GetReference(3), reference_stride_); 746 CheckSADs(); 747 reference_stride_ = tmp_stride; 748 } 749 750 TEST_P(SADx4Test, ShortSrc) { 751 int tmp_stride = source_stride_; 752 source_stride_ >>= 1; 753 int test_count = 1000; 754 while (test_count > 0) { 755 FillRandom(source_data_, source_stride_); 756 FillRandom(GetReference(0), reference_stride_); 757 FillRandom(GetReference(1), reference_stride_); 758 FillRandom(GetReference(2), reference_stride_); 759 FillRandom(GetReference(3), reference_stride_); 760 CheckSADs(); 761 test_count -= 1; 762 } 763 source_stride_ = tmp_stride; 764 } 765 766 TEST_P(SADx4Test, SrcAlignedByWidth) { 767 uint8_t *tmp_source_data = source_data_; 768 source_data_ += width_; 769 FillRandom(source_data_, source_stride_); 770 FillRandom(GetReference(0), reference_stride_); 771 FillRandom(GetReference(1), reference_stride_); 772 FillRandom(GetReference(2), reference_stride_); 773 FillRandom(GetReference(3), reference_stride_); 774 CheckSADs(); 775 source_data_ = tmp_source_data; 776 } 777 778 TEST_P(SADx4Test, DISABLED_Speed) { 779 FillRandom(source_data_, source_stride_); 780 FillRandom(GetReference(0), reference_stride_); 781 FillRandom(GetReference(1), reference_stride_); 782 FillRandom(GetReference(2), reference_stride_); 783 FillRandom(GetReference(3), reference_stride_); 784 SpeedSAD(); 785 } 786 787 // SADx3 788 TEST_P(SADx3Test, MaxRef) { 789 FillConstant(source_data_, source_stride_, 0); 790 FillConstant(GetReference(0), reference_stride_, mask_); 791 FillConstant(GetReference(1), reference_stride_, mask_); 792 FillConstant(GetReference(2), reference_stride_, mask_); 793 FillConstant(GetReference(3), reference_stride_, mask_); 794 CheckSADs(); 795 } 796 797 TEST_P(SADx3Test, MaxSrc) { 798 FillConstant(source_data_, source_stride_, mask_); 799 FillConstant(GetReference(0), reference_stride_, 0); 800 FillConstant(GetReference(1), reference_stride_, 0); 801 FillConstant(GetReference(2), reference_stride_, 0); 802 FillConstant(GetReference(3), reference_stride_, 0); 803 CheckSADs(); 804 } 805 806 TEST_P(SADx3Test, ShortRef) { 807 int tmp_stride = reference_stride_; 808 reference_stride_ >>= 1; 809 FillRandom(source_data_, source_stride_); 810 FillRandom(GetReference(0), reference_stride_); 811 FillRandom(GetReference(1), reference_stride_); 812 FillRandom(GetReference(2), reference_stride_); 813 FillRandom(GetReference(3), reference_stride_); 814 CheckSADs(); 815 reference_stride_ = tmp_stride; 816 } 817 818 TEST_P(SADx3Test, UnalignedRef) { 819 // The reference frame, but not the source frame, may be unaligned for 820 // certain types of searches. 821 int tmp_stride = reference_stride_; 822 reference_stride_ -= 1; 823 FillRandom(source_data_, source_stride_); 824 FillRandom(GetReference(0), reference_stride_); 825 FillRandom(GetReference(1), reference_stride_); 826 FillRandom(GetReference(2), reference_stride_); 827 FillRandom(GetReference(3), reference_stride_); 828 CheckSADs(); 829 reference_stride_ = tmp_stride; 830 } 831 832 TEST_P(SADx3Test, ShortSrc) { 833 int tmp_stride = source_stride_; 834 source_stride_ >>= 1; 835 int test_count = 1000; 836 while (test_count > 0) { 837 FillRandom(source_data_, source_stride_); 838 FillRandom(GetReference(0), reference_stride_); 839 FillRandom(GetReference(1), reference_stride_); 840 FillRandom(GetReference(2), reference_stride_); 841 FillRandom(GetReference(3), reference_stride_); 842 CheckSADs(); 843 test_count -= 1; 844 } 845 source_stride_ = tmp_stride; 846 } 847 848 TEST_P(SADx3Test, SrcAlignedByWidth) { 849 uint8_t *tmp_source_data = source_data_; 850 source_data_ += width_; 851 FillRandom(source_data_, source_stride_); 852 FillRandom(GetReference(0), reference_stride_); 853 FillRandom(GetReference(1), reference_stride_); 854 FillRandom(GetReference(2), reference_stride_); 855 FillRandom(GetReference(3), reference_stride_); 856 CheckSADs(); 857 source_data_ = tmp_source_data; 858 } 859 860 TEST_P(SADx3Test, DISABLED_Speed) { 861 FillRandom(source_data_, source_stride_); 862 FillRandom(GetReference(0), reference_stride_); 863 FillRandom(GetReference(1), reference_stride_); 864 FillRandom(GetReference(2), reference_stride_); 865 FillRandom(GetReference(3), reference_stride_); 866 SpeedSAD(); 867 } 868 869 // SADSkipx4 870 TEST_P(SADSkipx4Test, MaxRef) { 871 FillConstant(source_data_, source_stride_, 0); 872 FillConstant(GetReference(0), reference_stride_, mask_); 873 FillConstant(GetReference(1), reference_stride_, mask_); 874 FillConstant(GetReference(2), reference_stride_, mask_); 875 FillConstant(GetReference(3), reference_stride_, mask_); 876 CheckSADs(); 877 } 878 879 TEST_P(SADSkipx4Test, MaxSrc) { 880 FillConstant(source_data_, source_stride_, mask_); 881 FillConstant(GetReference(0), reference_stride_, 0); 882 FillConstant(GetReference(1), reference_stride_, 0); 883 FillConstant(GetReference(2), reference_stride_, 0); 884 FillConstant(GetReference(3), reference_stride_, 0); 885 CheckSADs(); 886 } 887 888 TEST_P(SADSkipx4Test, ShortRef) { 889 int tmp_stride = reference_stride_; 890 reference_stride_ >>= 1; 891 FillRandom(source_data_, source_stride_); 892 FillRandom(GetReference(0), reference_stride_); 893 FillRandom(GetReference(1), reference_stride_); 894 FillRandom(GetReference(2), reference_stride_); 895 FillRandom(GetReference(3), reference_stride_); 896 CheckSADs(); 897 reference_stride_ = tmp_stride; 898 } 899 900 TEST_P(SADSkipx4Test, UnalignedRef) { 901 // The reference frame, but not the source frame, may be unaligned for 902 // certain types of searches. 903 int tmp_stride = reference_stride_; 904 reference_stride_ -= 1; 905 FillRandom(source_data_, source_stride_); 906 FillRandom(GetReference(0), reference_stride_); 907 FillRandom(GetReference(1), reference_stride_); 908 FillRandom(GetReference(2), reference_stride_); 909 FillRandom(GetReference(3), reference_stride_); 910 CheckSADs(); 911 reference_stride_ = tmp_stride; 912 } 913 914 TEST_P(SADSkipx4Test, ShortSrc) { 915 int tmp_stride = source_stride_; 916 source_stride_ >>= 1; 917 int test_count = 1000; 918 while (test_count > 0) { 919 FillRandom(source_data_, source_stride_); 920 FillRandom(GetReference(0), reference_stride_); 921 FillRandom(GetReference(1), reference_stride_); 922 FillRandom(GetReference(2), reference_stride_); 923 FillRandom(GetReference(3), reference_stride_); 924 CheckSADs(); 925 test_count -= 1; 926 } 927 source_stride_ = tmp_stride; 928 } 929 930 TEST_P(SADSkipx4Test, SrcAlignedByWidth) { 931 uint8_t *tmp_source_data = source_data_; 932 source_data_ += width_; 933 FillRandom(source_data_, source_stride_); 934 FillRandom(GetReference(0), reference_stride_); 935 FillRandom(GetReference(1), reference_stride_); 936 FillRandom(GetReference(2), reference_stride_); 937 FillRandom(GetReference(3), reference_stride_); 938 CheckSADs(); 939 source_data_ = tmp_source_data; 940 } 941 942 TEST_P(SADSkipx4Test, DISABLED_Speed) { 943 FillRandom(source_data_, source_stride_); 944 FillRandom(GetReference(0), reference_stride_); 945 FillRandom(GetReference(1), reference_stride_); 946 FillRandom(GetReference(2), reference_stride_); 947 FillRandom(GetReference(3), reference_stride_); 948 SpeedSAD(); 949 } 950 951 using std::make_tuple; 952 953 //------------------------------------------------------------------------------ 954 // C functions 955 const SadMxNParam c_tests[] = { 956 make_tuple(128, 128, &aom_sad128x128_c, -1), 957 make_tuple(128, 64, &aom_sad128x64_c, -1), 958 make_tuple(64, 128, &aom_sad64x128_c, -1), 959 make_tuple(64, 64, &aom_sad64x64_c, -1), 960 make_tuple(64, 32, &aom_sad64x32_c, -1), 961 make_tuple(32, 64, &aom_sad32x64_c, -1), 962 make_tuple(32, 32, &aom_sad32x32_c, -1), 963 make_tuple(32, 16, &aom_sad32x16_c, -1), 964 make_tuple(16, 32, &aom_sad16x32_c, -1), 965 make_tuple(16, 16, &aom_sad16x16_c, -1), 966 make_tuple(16, 8, &aom_sad16x8_c, -1), 967 make_tuple(8, 16, &aom_sad8x16_c, -1), 968 make_tuple(8, 8, &aom_sad8x8_c, -1), 969 make_tuple(8, 4, &aom_sad8x4_c, -1), 970 make_tuple(4, 8, &aom_sad4x8_c, -1), 971 make_tuple(4, 4, &aom_sad4x4_c, -1), 972 #if CONFIG_AV1_HIGHBITDEPTH 973 make_tuple(128, 128, &aom_highbd_sad128x128_c, 8), 974 make_tuple(128, 64, &aom_highbd_sad128x64_c, 8), 975 make_tuple(64, 128, &aom_highbd_sad64x128_c, 8), 976 make_tuple(64, 64, &aom_highbd_sad64x64_c, 8), 977 make_tuple(64, 32, &aom_highbd_sad64x32_c, 8), 978 make_tuple(32, 64, &aom_highbd_sad32x64_c, 8), 979 make_tuple(32, 32, &aom_highbd_sad32x32_c, 8), 980 make_tuple(32, 16, &aom_highbd_sad32x16_c, 8), 981 make_tuple(16, 32, &aom_highbd_sad16x32_c, 8), 982 make_tuple(16, 16, &aom_highbd_sad16x16_c, 8), 983 make_tuple(16, 8, &aom_highbd_sad16x8_c, 8), 984 make_tuple(8, 16, &aom_highbd_sad8x16_c, 8), 985 make_tuple(8, 8, &aom_highbd_sad8x8_c, 8), 986 make_tuple(8, 4, &aom_highbd_sad8x4_c, 8), 987 make_tuple(4, 8, &aom_highbd_sad4x8_c, 8), 988 make_tuple(4, 4, &aom_highbd_sad4x4_c, 8), 989 make_tuple(128, 128, &aom_highbd_sad128x128_c, 10), 990 make_tuple(128, 64, &aom_highbd_sad128x64_c, 10), 991 make_tuple(64, 128, &aom_highbd_sad64x128_c, 10), 992 make_tuple(64, 64, &aom_highbd_sad64x64_c, 10), 993 make_tuple(64, 32, &aom_highbd_sad64x32_c, 10), 994 make_tuple(32, 64, &aom_highbd_sad32x64_c, 10), 995 make_tuple(32, 32, &aom_highbd_sad32x32_c, 10), 996 make_tuple(32, 16, &aom_highbd_sad32x16_c, 10), 997 make_tuple(16, 32, &aom_highbd_sad16x32_c, 10), 998 make_tuple(16, 16, &aom_highbd_sad16x16_c, 10), 999 make_tuple(16, 8, &aom_highbd_sad16x8_c, 10), 1000 make_tuple(8, 16, &aom_highbd_sad8x16_c, 10), 1001 make_tuple(8, 8, &aom_highbd_sad8x8_c, 10), 1002 make_tuple(8, 4, &aom_highbd_sad8x4_c, 10), 1003 make_tuple(4, 8, &aom_highbd_sad4x8_c, 10), 1004 make_tuple(4, 4, &aom_highbd_sad4x4_c, 10), 1005 make_tuple(128, 128, &aom_highbd_sad128x128_c, 12), 1006 make_tuple(128, 64, &aom_highbd_sad128x64_c, 12), 1007 make_tuple(64, 128, &aom_highbd_sad64x128_c, 12), 1008 make_tuple(64, 64, &aom_highbd_sad64x64_c, 12), 1009 make_tuple(64, 32, &aom_highbd_sad64x32_c, 12), 1010 make_tuple(32, 64, &aom_highbd_sad32x64_c, 12), 1011 make_tuple(32, 32, &aom_highbd_sad32x32_c, 12), 1012 make_tuple(32, 16, &aom_highbd_sad32x16_c, 12), 1013 make_tuple(16, 32, &aom_highbd_sad16x32_c, 12), 1014 make_tuple(16, 16, &aom_highbd_sad16x16_c, 12), 1015 make_tuple(16, 8, &aom_highbd_sad16x8_c, 12), 1016 make_tuple(8, 16, &aom_highbd_sad8x16_c, 12), 1017 make_tuple(8, 8, &aom_highbd_sad8x8_c, 12), 1018 make_tuple(8, 4, &aom_highbd_sad8x4_c, 12), 1019 make_tuple(4, 8, &aom_highbd_sad4x8_c, 12), 1020 make_tuple(4, 4, &aom_highbd_sad4x4_c, 12), 1021 #endif // CONFIG_AV1_HIGHBITDEPTH 1022 #if !CONFIG_REALTIME_ONLY 1023 make_tuple(64, 16, &aom_sad64x16_c, -1), 1024 make_tuple(16, 64, &aom_sad16x64_c, -1), 1025 #if CONFIG_AV1_HIGHBITDEPTH 1026 make_tuple(64, 16, &aom_highbd_sad64x16_c, 8), 1027 make_tuple(16, 64, &aom_highbd_sad16x64_c, 8), 1028 make_tuple(64, 16, &aom_highbd_sad64x16_c, 10), 1029 make_tuple(16, 64, &aom_highbd_sad16x64_c, 10), 1030 make_tuple(64, 16, &aom_highbd_sad64x16_c, 12), 1031 make_tuple(16, 64, &aom_highbd_sad16x64_c, 12), 1032 #endif 1033 make_tuple(32, 8, &aom_sad32x8_c, -1), 1034 make_tuple(8, 32, &aom_sad8x32_c, -1), 1035 #if CONFIG_AV1_HIGHBITDEPTH 1036 make_tuple(32, 8, &aom_highbd_sad32x8_c, 8), 1037 make_tuple(8, 32, &aom_highbd_sad8x32_c, 8), 1038 make_tuple(32, 8, &aom_highbd_sad32x8_c, 10), 1039 make_tuple(8, 32, &aom_highbd_sad8x32_c, 10), 1040 make_tuple(32, 8, &aom_highbd_sad32x8_c, 12), 1041 make_tuple(8, 32, &aom_highbd_sad8x32_c, 12), 1042 #endif 1043 make_tuple(16, 4, &aom_sad16x4_c, -1), 1044 make_tuple(4, 16, &aom_sad4x16_c, -1), 1045 #if CONFIG_AV1_HIGHBITDEPTH 1046 make_tuple(16, 4, &aom_highbd_sad16x4_c, 8), 1047 make_tuple(4, 16, &aom_highbd_sad4x16_c, 8), 1048 make_tuple(16, 4, &aom_highbd_sad16x4_c, 10), 1049 make_tuple(4, 16, &aom_highbd_sad4x16_c, 10), 1050 make_tuple(16, 4, &aom_highbd_sad16x4_c, 12), 1051 make_tuple(4, 16, &aom_highbd_sad4x16_c, 12), 1052 #endif 1053 #endif // !CONFIG_REALTIME_ONLY 1054 }; 1055 INSTANTIATE_TEST_SUITE_P(C, SADTest, ::testing::ValuesIn(c_tests)); 1056 1057 const SadSkipMxNParam skip_c_tests[] = { 1058 make_tuple(128, 128, &aom_sad_skip_128x128_c, -1), 1059 make_tuple(128, 64, &aom_sad_skip_128x64_c, -1), 1060 make_tuple(64, 128, &aom_sad_skip_64x128_c, -1), 1061 make_tuple(64, 64, &aom_sad_skip_64x64_c, -1), 1062 make_tuple(64, 32, &aom_sad_skip_64x32_c, -1), 1063 make_tuple(32, 64, &aom_sad_skip_32x64_c, -1), 1064 make_tuple(32, 32, &aom_sad_skip_32x32_c, -1), 1065 make_tuple(32, 16, &aom_sad_skip_32x16_c, -1), 1066 make_tuple(16, 32, &aom_sad_skip_16x32_c, -1), 1067 make_tuple(16, 16, &aom_sad_skip_16x16_c, -1), 1068 make_tuple(8, 16, &aom_sad_skip_8x16_c, -1), 1069 #if !CONFIG_REALTIME_ONLY 1070 make_tuple(64, 16, &aom_sad_skip_64x16_c, -1), 1071 make_tuple(16, 64, &aom_sad_skip_16x64_c, -1), 1072 make_tuple(8, 32, &aom_sad_skip_8x32_c, -1), 1073 make_tuple(4, 16, &aom_sad_skip_4x16_c, -1), 1074 #endif 1075 #if CONFIG_AV1_HIGHBITDEPTH 1076 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 8), 1077 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 8), 1078 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 8), 1079 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 8), 1080 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 8), 1081 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 8), 1082 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 8), 1083 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 8), 1084 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 8), 1085 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 8), 1086 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 8), 1087 #if !CONFIG_REALTIME_ONLY 1088 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 8), 1089 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 8), 1090 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 8), 1091 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 8), 1092 #endif 1093 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 10), 1094 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 10), 1095 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 10), 1096 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 10), 1097 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 10), 1098 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 10), 1099 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 10), 1100 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 10), 1101 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 10), 1102 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 10), 1103 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 10), 1104 #if !CONFIG_REALTIME_ONLY 1105 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 10), 1106 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 10), 1107 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 10), 1108 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 10), 1109 #endif 1110 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 12), 1111 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 12), 1112 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 12), 1113 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 12), 1114 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 12), 1115 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 12), 1116 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 12), 1117 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 12), 1118 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 12), 1119 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 12), 1120 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 12), 1121 #if !CONFIG_REALTIME_ONLY 1122 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 12), 1123 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 12), 1124 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 12), 1125 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 12), 1126 #endif // !CONFIG_REALTIME_ONLY 1127 #endif // CONFIG_AV1_HIGHBITDEPTH 1128 }; 1129 INSTANTIATE_TEST_SUITE_P(C, SADSkipTest, ::testing::ValuesIn(skip_c_tests)); 1130 1131 const SadMxNAvgParam avg_c_tests[] = { 1132 make_tuple(128, 128, &aom_sad128x128_avg_c, -1), 1133 make_tuple(128, 64, &aom_sad128x64_avg_c, -1), 1134 make_tuple(64, 128, &aom_sad64x128_avg_c, -1), 1135 make_tuple(64, 64, &aom_sad64x64_avg_c, -1), 1136 make_tuple(64, 32, &aom_sad64x32_avg_c, -1), 1137 make_tuple(32, 64, &aom_sad32x64_avg_c, -1), 1138 make_tuple(32, 32, &aom_sad32x32_avg_c, -1), 1139 make_tuple(32, 16, &aom_sad32x16_avg_c, -1), 1140 make_tuple(16, 32, &aom_sad16x32_avg_c, -1), 1141 make_tuple(16, 16, &aom_sad16x16_avg_c, -1), 1142 make_tuple(16, 8, &aom_sad16x8_avg_c, -1), 1143 make_tuple(8, 16, &aom_sad8x16_avg_c, -1), 1144 make_tuple(8, 8, &aom_sad8x8_avg_c, -1), 1145 #if CONFIG_AV1_HIGHBITDEPTH 1146 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 8), 1147 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 8), 1148 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 8), 1149 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 8), 1150 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 8), 1151 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 8), 1152 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 8), 1153 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 8), 1154 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 8), 1155 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 8), 1156 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 8), 1157 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 8), 1158 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 8), 1159 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 10), 1160 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 10), 1161 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 10), 1162 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 10), 1163 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 10), 1164 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 10), 1165 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 10), 1166 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 10), 1167 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 10), 1168 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 10), 1169 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 10), 1170 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 10), 1171 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 10), 1172 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 12), 1173 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 12), 1174 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 12), 1175 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 12), 1176 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 12), 1177 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 12), 1178 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 12), 1179 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 12), 1180 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 12), 1181 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 12), 1182 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 12), 1183 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 12), 1184 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 12), 1185 #endif // CONFIG_AV1_HIGHBITDEPTH 1186 #if !CONFIG_REALTIME_ONLY 1187 make_tuple(64, 16, &aom_sad64x16_avg_c, -1), 1188 make_tuple(16, 64, &aom_sad16x64_avg_c, -1), 1189 #if CONFIG_AV1_HIGHBITDEPTH 1190 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 8), 1191 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 8), 1192 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 10), 1193 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 10), 1194 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 12), 1195 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 12), 1196 #endif 1197 make_tuple(32, 8, &aom_sad32x8_avg_c, -1), 1198 make_tuple(8, 32, &aom_sad8x32_avg_c, -1), 1199 #if CONFIG_AV1_HIGHBITDEPTH 1200 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 8), 1201 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 8), 1202 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 10), 1203 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 10), 1204 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 12), 1205 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 12), 1206 #endif 1207 #endif // !CONFIG_REALTIME_ONLY 1208 }; 1209 INSTANTIATE_TEST_SUITE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests)); 1210 1211 const SadMxNx4Param x4d_c_tests[] = { 1212 make_tuple(128, 128, &aom_sad128x128x4d_c, -1), 1213 make_tuple(128, 64, &aom_sad128x64x4d_c, -1), 1214 make_tuple(64, 128, &aom_sad64x128x4d_c, -1), 1215 make_tuple(64, 64, &aom_sad64x64x4d_c, -1), 1216 make_tuple(64, 32, &aom_sad64x32x4d_c, -1), 1217 make_tuple(32, 64, &aom_sad32x64x4d_c, -1), 1218 make_tuple(32, 32, &aom_sad32x32x4d_c, -1), 1219 make_tuple(32, 16, &aom_sad32x16x4d_c, -1), 1220 make_tuple(16, 32, &aom_sad16x32x4d_c, -1), 1221 make_tuple(16, 16, &aom_sad16x16x4d_c, -1), 1222 make_tuple(16, 8, &aom_sad16x8x4d_c, -1), 1223 make_tuple(8, 16, &aom_sad8x16x4d_c, -1), 1224 make_tuple(8, 8, &aom_sad8x8x4d_c, -1), 1225 make_tuple(8, 4, &aom_sad8x4x4d_c, -1), 1226 make_tuple(4, 8, &aom_sad4x8x4d_c, -1), 1227 make_tuple(4, 4, &aom_sad4x4x4d_c, -1), 1228 #if CONFIG_AV1_HIGHBITDEPTH 1229 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 8), 1230 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 8), 1231 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 8), 1232 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 8), 1233 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 8), 1234 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 8), 1235 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 8), 1236 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 8), 1237 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 8), 1238 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 8), 1239 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 8), 1240 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 8), 1241 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 8), 1242 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 8), 1243 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 8), 1244 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 8), 1245 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 10), 1246 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 10), 1247 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 10), 1248 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 10), 1249 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 10), 1250 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 10), 1251 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 10), 1252 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 10), 1253 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 10), 1254 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 10), 1255 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 10), 1256 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 10), 1257 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 10), 1258 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 10), 1259 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 10), 1260 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 10), 1261 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 12), 1262 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 12), 1263 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 12), 1264 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 12), 1265 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 12), 1266 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 12), 1267 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 12), 1268 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 12), 1269 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 12), 1270 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 12), 1271 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 12), 1272 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 12), 1273 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 12), 1274 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 12), 1275 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 12), 1276 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 12), 1277 #endif 1278 #if !CONFIG_REALTIME_ONLY 1279 make_tuple(64, 16, &aom_sad64x16x4d_c, -1), 1280 make_tuple(16, 64, &aom_sad16x64x4d_c, -1), 1281 #if CONFIG_AV1_HIGHBITDEPTH 1282 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 8), 1283 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 8), 1284 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 10), 1285 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 10), 1286 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 12), 1287 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 12), 1288 #endif 1289 make_tuple(32, 8, &aom_sad32x8x4d_c, -1), 1290 make_tuple(8, 32, &aom_sad8x32x4d_c, -1), 1291 #if CONFIG_AV1_HIGHBITDEPTH 1292 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 8), 1293 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 8), 1294 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 10), 1295 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 10), 1296 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 12), 1297 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 12), 1298 #endif 1299 make_tuple(16, 4, &aom_sad16x4x4d_c, -1), 1300 make_tuple(4, 16, &aom_sad4x16x4d_c, -1), 1301 #if CONFIG_AV1_HIGHBITDEPTH 1302 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 8), 1303 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 8), 1304 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 10), 1305 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 10), 1306 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 12), 1307 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 12), 1308 #endif 1309 #endif // !CONFIG_REALTIME_ONLY 1310 }; 1311 INSTANTIATE_TEST_SUITE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests)); 1312 1313 const SadMxNx4Param x3d_c_tests[] = { 1314 make_tuple(128, 128, &aom_sad128x128x3d_c, -1), 1315 make_tuple(128, 64, &aom_sad128x64x3d_c, -1), 1316 make_tuple(64, 128, &aom_sad64x128x3d_c, -1), 1317 make_tuple(64, 64, &aom_sad64x64x3d_c, -1), 1318 make_tuple(64, 32, &aom_sad64x32x3d_c, -1), 1319 make_tuple(32, 64, &aom_sad32x64x3d_c, -1), 1320 make_tuple(32, 32, &aom_sad32x32x3d_c, -1), 1321 make_tuple(32, 16, &aom_sad32x16x3d_c, -1), 1322 make_tuple(16, 32, &aom_sad16x32x3d_c, -1), 1323 make_tuple(16, 16, &aom_sad16x16x3d_c, -1), 1324 make_tuple(16, 8, &aom_sad16x8x3d_c, -1), 1325 make_tuple(8, 16, &aom_sad8x16x3d_c, -1), 1326 make_tuple(8, 8, &aom_sad8x8x3d_c, -1), 1327 make_tuple(8, 4, &aom_sad8x4x3d_c, -1), 1328 make_tuple(4, 8, &aom_sad4x8x3d_c, -1), 1329 make_tuple(4, 4, &aom_sad4x4x3d_c, -1), 1330 #if CONFIG_AV1_HIGHBITDEPTH 1331 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 8), 1332 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 8), 1333 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 8), 1334 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 8), 1335 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 8), 1336 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 8), 1337 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 8), 1338 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 8), 1339 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 8), 1340 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 8), 1341 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 8), 1342 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 8), 1343 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 8), 1344 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 8), 1345 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 8), 1346 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 8), 1347 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 10), 1348 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 10), 1349 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 10), 1350 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 10), 1351 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 10), 1352 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 10), 1353 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 10), 1354 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 10), 1355 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 10), 1356 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 10), 1357 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 10), 1358 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 10), 1359 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 10), 1360 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 10), 1361 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 10), 1362 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 10), 1363 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 12), 1364 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 12), 1365 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 12), 1366 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 12), 1367 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 12), 1368 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 12), 1369 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 12), 1370 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 12), 1371 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 12), 1372 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 12), 1373 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 12), 1374 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 12), 1375 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 12), 1376 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 12), 1377 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 12), 1378 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 12), 1379 #endif 1380 #if !CONFIG_REALTIME_ONLY 1381 make_tuple(64, 16, &aom_sad64x16x3d_c, -1), 1382 make_tuple(16, 64, &aom_sad16x64x3d_c, -1), 1383 #if CONFIG_AV1_HIGHBITDEPTH 1384 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 8), 1385 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 8), 1386 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 10), 1387 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 10), 1388 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 12), 1389 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 12), 1390 #endif 1391 make_tuple(32, 8, &aom_sad32x8x3d_c, -1), 1392 make_tuple(8, 32, &aom_sad8x32x3d_c, -1), 1393 #if CONFIG_AV1_HIGHBITDEPTH 1394 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 8), 1395 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 8), 1396 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 10), 1397 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 10), 1398 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 12), 1399 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 12), 1400 #endif 1401 make_tuple(16, 4, &aom_sad16x4x3d_c, -1), 1402 make_tuple(4, 16, &aom_sad4x16x3d_c, -1), 1403 #if CONFIG_AV1_HIGHBITDEPTH 1404 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 8), 1405 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 8), 1406 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 10), 1407 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 10), 1408 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 12), 1409 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 12), 1410 #endif 1411 #endif // !CONFIG_REALTIME_ONLY 1412 }; 1413 INSTANTIATE_TEST_SUITE_P(C, SADx3Test, ::testing::ValuesIn(x3d_c_tests)); 1414 1415 const SadMxNx4Param skip_x4d_c_tests[] = { 1416 make_tuple(128, 128, &aom_sad_skip_128x128x4d_c, -1), 1417 make_tuple(128, 64, &aom_sad_skip_128x64x4d_c, -1), 1418 make_tuple(64, 128, &aom_sad_skip_64x128x4d_c, -1), 1419 make_tuple(64, 64, &aom_sad_skip_64x64x4d_c, -1), 1420 make_tuple(64, 32, &aom_sad_skip_64x32x4d_c, -1), 1421 make_tuple(32, 64, &aom_sad_skip_32x64x4d_c, -1), 1422 make_tuple(32, 32, &aom_sad_skip_32x32x4d_c, -1), 1423 make_tuple(32, 16, &aom_sad_skip_32x16x4d_c, -1), 1424 make_tuple(16, 32, &aom_sad_skip_16x32x4d_c, -1), 1425 make_tuple(16, 16, &aom_sad_skip_16x16x4d_c, -1), 1426 make_tuple(8, 16, &aom_sad_skip_8x16x4d_c, -1), 1427 #if !CONFIG_REALTIME_ONLY 1428 make_tuple(64, 16, &aom_sad_skip_64x16x4d_c, -1), 1429 make_tuple(16, 64, &aom_sad_skip_16x64x4d_c, -1), 1430 make_tuple(8, 32, &aom_sad_skip_8x32x4d_c, -1), 1431 make_tuple(4, 16, &aom_sad_skip_4x16x4d_c, -1), 1432 #endif 1433 #if CONFIG_AV1_HIGHBITDEPTH 1434 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 8), 1435 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 8), 1436 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 8), 1437 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 8), 1438 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 8), 1439 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 8), 1440 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 8), 1441 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 8), 1442 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 8), 1443 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 8), 1444 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 8), 1445 #if !CONFIG_REALTIME_ONLY 1446 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 8), 1447 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 8), 1448 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 8), 1449 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 8), 1450 #endif 1451 1452 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 10), 1453 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 10), 1454 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 10), 1455 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 10), 1456 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 10), 1457 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 10), 1458 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 10), 1459 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 10), 1460 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 10), 1461 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 10), 1462 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 10), 1463 #if !CONFIG_REALTIME_ONLY 1464 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 10), 1465 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 10), 1466 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 10), 1467 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 10), 1468 #endif 1469 1470 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 12), 1471 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 12), 1472 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 12), 1473 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 12), 1474 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 12), 1475 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 12), 1476 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 12), 1477 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 12), 1478 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 12), 1479 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 12), 1480 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 12), 1481 #if !CONFIG_REALTIME_ONLY 1482 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 12), 1483 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 12), 1484 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 12), 1485 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 12), 1486 #endif 1487 #endif // CONFIG_AV1_HIGHBITDEPTH 1488 }; 1489 INSTANTIATE_TEST_SUITE_P(C, SADSkipx4Test, 1490 ::testing::ValuesIn(skip_x4d_c_tests)); 1491 1492 //------------------------------------------------------------------------------ 1493 // ARM functions 1494 #if HAVE_NEON 1495 const SadMxNParam neon_tests[] = { 1496 make_tuple(128, 128, &aom_sad128x128_neon, -1), 1497 make_tuple(128, 64, &aom_sad128x64_neon, -1), 1498 make_tuple(64, 128, &aom_sad64x128_neon, -1), 1499 make_tuple(64, 64, &aom_sad64x64_neon, -1), 1500 make_tuple(64, 32, &aom_sad64x32_neon, -1), 1501 make_tuple(32, 64, &aom_sad32x64_neon, -1), 1502 make_tuple(32, 32, &aom_sad32x32_neon, -1), 1503 make_tuple(32, 16, &aom_sad32x16_neon, -1), 1504 make_tuple(16, 32, &aom_sad16x32_neon, -1), 1505 make_tuple(16, 16, &aom_sad16x16_neon, -1), 1506 make_tuple(16, 8, &aom_sad16x8_neon, -1), 1507 make_tuple(8, 16, &aom_sad8x16_neon, -1), 1508 make_tuple(8, 8, &aom_sad8x8_neon, -1), 1509 make_tuple(8, 4, &aom_sad8x4_neon, -1), 1510 make_tuple(4, 8, &aom_sad4x8_neon, -1), 1511 make_tuple(4, 4, &aom_sad4x4_neon, -1), 1512 #if CONFIG_AV1_HIGHBITDEPTH 1513 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 8), 1514 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 8), 1515 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 8), 1516 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 8), 1517 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 8), 1518 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 8), 1519 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 8), 1520 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 8), 1521 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 8), 1522 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 8), 1523 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 8), 1524 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 8), 1525 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 8), 1526 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 8), 1527 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 8), 1528 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 8), 1529 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 10), 1530 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 10), 1531 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 10), 1532 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 10), 1533 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 10), 1534 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 10), 1535 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 10), 1536 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 10), 1537 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 10), 1538 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 10), 1539 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 10), 1540 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 10), 1541 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 10), 1542 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 10), 1543 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 10), 1544 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 10), 1545 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 12), 1546 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 12), 1547 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 12), 1548 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 12), 1549 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 12), 1550 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 12), 1551 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 12), 1552 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 12), 1553 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 12), 1554 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 12), 1555 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 12), 1556 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 12), 1557 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 12), 1558 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 12), 1559 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 12), 1560 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 12), 1561 #endif // CONFIG_AV1_HIGHBITDEPTH 1562 #if !CONFIG_REALTIME_ONLY 1563 make_tuple(64, 16, &aom_sad64x16_neon, -1), 1564 make_tuple(32, 8, &aom_sad32x8_neon, -1), 1565 make_tuple(16, 64, &aom_sad16x64_neon, -1), 1566 make_tuple(16, 4, &aom_sad16x4_neon, -1), 1567 make_tuple(8, 32, &aom_sad8x32_neon, -1), 1568 make_tuple(4, 16, &aom_sad4x16_neon, -1), 1569 #if CONFIG_AV1_HIGHBITDEPTH 1570 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 8), 1571 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 8), 1572 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 8), 1573 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 8), 1574 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 8), 1575 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 8), 1576 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 10), 1577 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 10), 1578 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 10), 1579 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 10), 1580 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 10), 1581 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 10), 1582 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 12), 1583 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 12), 1584 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 12), 1585 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 12), 1586 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 12), 1587 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 12), 1588 #endif // CONFIG_AV1_HIGHBITDEPTH 1589 #endif // !CONFIG_REALTIME_ONLY 1590 }; 1591 INSTANTIATE_TEST_SUITE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests)); 1592 1593 const SadMxNx4Param x4d_neon_tests[] = { 1594 make_tuple(128, 128, &aom_sad128x128x4d_neon, -1), 1595 make_tuple(128, 64, &aom_sad128x64x4d_neon, -1), 1596 make_tuple(64, 128, &aom_sad64x128x4d_neon, -1), 1597 make_tuple(64, 64, &aom_sad64x64x4d_neon, -1), 1598 make_tuple(64, 32, &aom_sad64x32x4d_neon, -1), 1599 make_tuple(32, 64, &aom_sad32x64x4d_neon, -1), 1600 make_tuple(32, 32, &aom_sad32x32x4d_neon, -1), 1601 make_tuple(32, 16, &aom_sad32x16x4d_neon, -1), 1602 make_tuple(16, 32, &aom_sad16x32x4d_neon, -1), 1603 make_tuple(16, 16, &aom_sad16x16x4d_neon, -1), 1604 make_tuple(16, 8, &aom_sad16x8x4d_neon, -1), 1605 make_tuple(8, 16, &aom_sad8x16x4d_neon, -1), 1606 make_tuple(8, 8, &aom_sad8x8x4d_neon, -1), 1607 make_tuple(8, 4, &aom_sad8x4x4d_neon, -1), 1608 make_tuple(4, 8, &aom_sad4x8x4d_neon, -1), 1609 make_tuple(4, 4, &aom_sad4x4x4d_neon, -1), 1610 #if CONFIG_AV1_HIGHBITDEPTH 1611 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 8), 1612 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 8), 1613 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 8), 1614 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 8), 1615 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 8), 1616 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 8), 1617 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 8), 1618 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 8), 1619 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 8), 1620 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 8), 1621 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 8), 1622 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 8), 1623 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 8), 1624 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 8), 1625 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 8), 1626 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 8), 1627 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 10), 1628 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 10), 1629 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 10), 1630 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 10), 1631 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 10), 1632 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 10), 1633 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 10), 1634 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 10), 1635 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 10), 1636 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 10), 1637 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 10), 1638 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 10), 1639 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 10), 1640 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 10), 1641 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 10), 1642 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 10), 1643 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 12), 1644 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 12), 1645 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 12), 1646 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 12), 1647 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 12), 1648 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 12), 1649 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 12), 1650 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 12), 1651 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 12), 1652 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 12), 1653 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 12), 1654 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 12), 1655 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 12), 1656 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 12), 1657 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 12), 1658 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 12), 1659 #endif // CONFIG_AV1_HIGHBITDEPTH 1660 #if !CONFIG_REALTIME_ONLY 1661 make_tuple(64, 16, &aom_sad64x16x4d_neon, -1), 1662 make_tuple(32, 8, &aom_sad32x8x4d_neon, -1), 1663 make_tuple(16, 64, &aom_sad16x64x4d_neon, -1), 1664 make_tuple(16, 4, &aom_sad16x4x4d_neon, -1), 1665 make_tuple(8, 32, &aom_sad8x32x4d_neon, -1), 1666 make_tuple(4, 16, &aom_sad4x16x4d_neon, -1), 1667 #if CONFIG_AV1_HIGHBITDEPTH 1668 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 8), 1669 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 8), 1670 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 8), 1671 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 8), 1672 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 8), 1673 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 8), 1674 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 10), 1675 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 10), 1676 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 10), 1677 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 10), 1678 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 10), 1679 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 10), 1680 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 12), 1681 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 12), 1682 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 12), 1683 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 12), 1684 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 12), 1685 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 12), 1686 #endif // CONFIG_AV1_HIGHBITDEPTH 1687 #endif // !CONFIG_REALTIME_ONLY 1688 }; 1689 INSTANTIATE_TEST_SUITE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests)); 1690 const SadSkipMxNParam skip_neon_tests[] = { 1691 make_tuple(128, 128, &aom_sad_skip_128x128_neon, -1), 1692 make_tuple(128, 64, &aom_sad_skip_128x64_neon, -1), 1693 make_tuple(64, 128, &aom_sad_skip_64x128_neon, -1), 1694 make_tuple(64, 64, &aom_sad_skip_64x64_neon, -1), 1695 make_tuple(64, 32, &aom_sad_skip_64x32_neon, -1), 1696 make_tuple(32, 64, &aom_sad_skip_32x64_neon, -1), 1697 make_tuple(32, 32, &aom_sad_skip_32x32_neon, -1), 1698 make_tuple(32, 16, &aom_sad_skip_32x16_neon, -1), 1699 make_tuple(16, 32, &aom_sad_skip_16x32_neon, -1), 1700 make_tuple(16, 16, &aom_sad_skip_16x16_neon, -1), 1701 make_tuple(8, 16, &aom_sad_skip_8x16_neon, -1), 1702 #if CONFIG_AV1_HIGHBITDEPTH 1703 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 8), 1704 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 8), 1705 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 8), 1706 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 8), 1707 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 8), 1708 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 8), 1709 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 8), 1710 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 8), 1711 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 8), 1712 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 8), 1713 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 8), 1714 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 10), 1715 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 10), 1716 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 10), 1717 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 10), 1718 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 10), 1719 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 10), 1720 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 10), 1721 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 10), 1722 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 10), 1723 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 10), 1724 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 10), 1725 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 12), 1726 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 12), 1727 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 12), 1728 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 12), 1729 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 12), 1730 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 12), 1731 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 12), 1732 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 12), 1733 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 12), 1734 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 12), 1735 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 12), 1736 #endif // CONFIG_AV1_HIGHBITDEPTH 1737 #if !CONFIG_REALTIME_ONLY 1738 make_tuple(64, 16, &aom_sad_skip_64x16_neon, -1), 1739 make_tuple(16, 64, &aom_sad_skip_16x64_neon, -1), 1740 make_tuple(8, 32, &aom_sad_skip_8x32_neon, -1), 1741 make_tuple(4, 16, &aom_sad_skip_4x16_neon, -1), 1742 #if CONFIG_AV1_HIGHBITDEPTH 1743 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 8), 1744 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 8), 1745 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 8), 1746 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 8), 1747 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 10), 1748 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 10), 1749 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 10), 1750 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 10), 1751 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 12), 1752 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 12), 1753 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 12), 1754 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 12), 1755 #endif // CONFIG_AV1_HIGHBITDEPTH 1756 #endif // !CONFIG_REALTIME_ONLY 1757 }; 1758 INSTANTIATE_TEST_SUITE_P(NEON, SADSkipTest, 1759 ::testing::ValuesIn(skip_neon_tests)); 1760 1761 const SadSkipMxNx4Param skip_x4d_neon_tests[] = { 1762 make_tuple(128, 128, &aom_sad_skip_128x128x4d_neon, -1), 1763 make_tuple(128, 64, &aom_sad_skip_128x64x4d_neon, -1), 1764 make_tuple(64, 128, &aom_sad_skip_64x128x4d_neon, -1), 1765 make_tuple(64, 64, &aom_sad_skip_64x64x4d_neon, -1), 1766 make_tuple(64, 32, &aom_sad_skip_64x32x4d_neon, -1), 1767 make_tuple(32, 64, &aom_sad_skip_32x64x4d_neon, -1), 1768 make_tuple(32, 32, &aom_sad_skip_32x32x4d_neon, -1), 1769 make_tuple(32, 16, &aom_sad_skip_32x16x4d_neon, -1), 1770 make_tuple(16, 32, &aom_sad_skip_16x32x4d_neon, -1), 1771 make_tuple(16, 16, &aom_sad_skip_16x16x4d_neon, -1), 1772 make_tuple(8, 16, &aom_sad_skip_8x16x4d_neon, -1), 1773 #if CONFIG_AV1_HIGHBITDEPTH 1774 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 8), 1775 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 8), 1776 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 8), 1777 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 8), 1778 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 8), 1779 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 8), 1780 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 8), 1781 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 8), 1782 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 8), 1783 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 8), 1784 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 8), 1785 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 10), 1786 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 10), 1787 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 10), 1788 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 10), 1789 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 10), 1790 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 10), 1791 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 10), 1792 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 10), 1793 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 10), 1794 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 10), 1795 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 10), 1796 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 12), 1797 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 12), 1798 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 12), 1799 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 12), 1800 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 12), 1801 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 12), 1802 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 12), 1803 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 12), 1804 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 12), 1805 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 12), 1806 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 12), 1807 #endif // CONFIG_AV1_HIGHBITDEPTH 1808 #if !CONFIG_REALTIME_ONLY 1809 make_tuple(64, 16, &aom_sad_skip_64x16x4d_neon, -1), 1810 make_tuple(16, 64, &aom_sad_skip_16x64x4d_neon, -1), 1811 make_tuple(8, 32, &aom_sad_skip_8x32x4d_neon, -1), 1812 make_tuple(4, 16, &aom_sad_skip_4x16x4d_neon, -1), 1813 #if CONFIG_AV1_HIGHBITDEPTH 1814 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 8), 1815 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 8), 1816 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 8), 1817 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 8), 1818 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 10), 1819 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 10), 1820 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 10), 1821 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 10), 1822 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 12), 1823 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 12), 1824 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 12), 1825 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 12), 1826 #endif // CONFIG_AV1_HIGHBITDEPTH 1827 #endif // !CONFIG_REALTIME_ONLY 1828 }; 1829 INSTANTIATE_TEST_SUITE_P(NEON, SADSkipx4Test, 1830 ::testing::ValuesIn(skip_x4d_neon_tests)); 1831 1832 const SadMxNAvgParam avg_neon_tests[] = { 1833 make_tuple(128, 128, &aom_sad128x128_avg_neon, -1), 1834 make_tuple(128, 64, &aom_sad128x64_avg_neon, -1), 1835 make_tuple(64, 128, &aom_sad64x128_avg_neon, -1), 1836 make_tuple(64, 64, &aom_sad64x64_avg_neon, -1), 1837 make_tuple(64, 32, &aom_sad64x32_avg_neon, -1), 1838 make_tuple(32, 64, &aom_sad32x64_avg_neon, -1), 1839 make_tuple(32, 32, &aom_sad32x32_avg_neon, -1), 1840 make_tuple(32, 16, &aom_sad32x16_avg_neon, -1), 1841 make_tuple(16, 32, &aom_sad16x32_avg_neon, -1), 1842 make_tuple(16, 16, &aom_sad16x16_avg_neon, -1), 1843 make_tuple(16, 8, &aom_sad16x8_avg_neon, -1), 1844 make_tuple(8, 16, &aom_sad8x16_avg_neon, -1), 1845 make_tuple(8, 8, &aom_sad8x8_avg_neon, -1), 1846 #if CONFIG_AV1_HIGHBITDEPTH 1847 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 8), 1848 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 8), 1849 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 8), 1850 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 8), 1851 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 8), 1852 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 8), 1853 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 8), 1854 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 8), 1855 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 8), 1856 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 8), 1857 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 8), 1858 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 8), 1859 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 8), 1860 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 10), 1861 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 10), 1862 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 10), 1863 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 10), 1864 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 10), 1865 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 10), 1866 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 10), 1867 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 10), 1868 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 10), 1869 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 10), 1870 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 10), 1871 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 10), 1872 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 10), 1873 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 12), 1874 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 12), 1875 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 12), 1876 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 12), 1877 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 12), 1878 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 12), 1879 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 12), 1880 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 12), 1881 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 12), 1882 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 12), 1883 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 12), 1884 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 12), 1885 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 12), 1886 #endif // CONFIG_AV1_HIGHBITDEPTH 1887 #if !CONFIG_REALTIME_ONLY 1888 make_tuple(64, 16, &aom_sad64x16_avg_neon, -1), 1889 make_tuple(32, 8, &aom_sad32x8_avg_neon, -1), 1890 make_tuple(16, 64, &aom_sad16x64_avg_neon, -1), 1891 make_tuple(8, 32, &aom_sad8x32_avg_neon, -1), 1892 #if CONFIG_AV1_HIGHBITDEPTH 1893 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 8), 1894 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 8), 1895 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 8), 1896 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 8), 1897 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 10), 1898 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 10), 1899 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 10), 1900 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 10), 1901 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 12), 1902 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 12), 1903 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 12), 1904 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 12), 1905 #endif // CONFIG_AV1_HIGHBITDEPTH 1906 #endif // !CONFIG_REALTIME_ONLY 1907 }; 1908 INSTANTIATE_TEST_SUITE_P(NEON, SADavgTest, ::testing::ValuesIn(avg_neon_tests)); 1909 1910 const SadMxNx4Param x3d_neon_tests[] = { 1911 make_tuple(128, 128, &aom_sad128x128x3d_neon, -1), 1912 make_tuple(128, 64, &aom_sad128x64x3d_neon, -1), 1913 make_tuple(64, 128, &aom_sad64x128x3d_neon, -1), 1914 make_tuple(64, 64, &aom_sad64x64x3d_neon, -1), 1915 make_tuple(64, 32, &aom_sad64x32x3d_neon, -1), 1916 make_tuple(32, 64, &aom_sad32x64x3d_neon, -1), 1917 make_tuple(32, 32, &aom_sad32x32x3d_neon, -1), 1918 make_tuple(32, 16, &aom_sad32x16x3d_neon, -1), 1919 make_tuple(16, 32, &aom_sad16x32x3d_neon, -1), 1920 make_tuple(16, 16, &aom_sad16x16x3d_neon, -1), 1921 make_tuple(16, 8, &aom_sad16x8x3d_neon, -1), 1922 make_tuple(8, 16, &aom_sad8x16x3d_neon, -1), 1923 make_tuple(8, 8, &aom_sad8x8x3d_neon, -1), 1924 make_tuple(8, 4, &aom_sad8x4x3d_neon, -1), 1925 make_tuple(4, 8, &aom_sad4x8x3d_neon, -1), 1926 make_tuple(4, 4, &aom_sad4x4x3d_neon, -1), 1927 #if CONFIG_AV1_HIGHBITDEPTH 1928 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 8), 1929 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 8), 1930 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 8), 1931 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 8), 1932 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 8), 1933 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 8), 1934 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 8), 1935 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 8), 1936 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 8), 1937 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 8), 1938 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 8), 1939 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 8), 1940 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 8), 1941 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 8), 1942 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 8), 1943 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 8), 1944 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 10), 1945 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 10), 1946 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 10), 1947 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 10), 1948 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 10), 1949 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 10), 1950 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 10), 1951 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 10), 1952 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 10), 1953 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 10), 1954 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 10), 1955 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 10), 1956 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 10), 1957 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 10), 1958 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 10), 1959 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 10), 1960 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 12), 1961 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 12), 1962 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 12), 1963 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 12), 1964 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 12), 1965 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 12), 1966 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 12), 1967 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 12), 1968 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 12), 1969 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 12), 1970 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 12), 1971 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 12), 1972 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 12), 1973 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 12), 1974 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 12), 1975 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 12), 1976 #endif // CONFIG_AV1_HIGHBITDEPTH 1977 #if !CONFIG_REALTIME_ONLY 1978 make_tuple(64, 16, &aom_sad64x16x3d_neon, -1), 1979 make_tuple(32, 8, &aom_sad32x8x3d_neon, -1), 1980 make_tuple(16, 64, &aom_sad16x64x3d_neon, -1), 1981 make_tuple(16, 4, &aom_sad16x4x3d_neon, -1), 1982 make_tuple(8, 32, &aom_sad8x32x3d_neon, -1), 1983 make_tuple(4, 16, &aom_sad4x16x3d_neon, -1), 1984 #if CONFIG_AV1_HIGHBITDEPTH 1985 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 8), 1986 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 8), 1987 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 8), 1988 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 8), 1989 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 8), 1990 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 8), 1991 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 10), 1992 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 10), 1993 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 10), 1994 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 10), 1995 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 10), 1996 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 10), 1997 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 12), 1998 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 12), 1999 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 12), 2000 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 12), 2001 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 12), 2002 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 12), 2003 #endif // CONFIG_AV1_HIGHBITDEPTH 2004 #endif // !CONFIG_REALTIME_ONLY 2005 }; 2006 INSTANTIATE_TEST_SUITE_P(NEON, SADx3Test, ::testing::ValuesIn(x3d_neon_tests)); 2007 2008 #endif // HAVE_NEON 2009 2010 #if HAVE_NEON_DOTPROD 2011 const SadMxNParam neon_dotprod_tests[] = { 2012 make_tuple(128, 128, &aom_sad128x128_neon_dotprod, -1), 2013 make_tuple(128, 64, &aom_sad128x64_neon_dotprod, -1), 2014 make_tuple(64, 128, &aom_sad64x128_neon_dotprod, -1), 2015 make_tuple(64, 64, &aom_sad64x64_neon_dotprod, -1), 2016 make_tuple(64, 32, &aom_sad64x32_neon_dotprod, -1), 2017 make_tuple(32, 64, &aom_sad32x64_neon_dotprod, -1), 2018 make_tuple(32, 32, &aom_sad32x32_neon_dotprod, -1), 2019 make_tuple(32, 16, &aom_sad32x16_neon_dotprod, -1), 2020 make_tuple(16, 32, &aom_sad16x32_neon_dotprod, -1), 2021 make_tuple(16, 16, &aom_sad16x16_neon_dotprod, -1), 2022 make_tuple(16, 8, &aom_sad16x8_neon_dotprod, -1), 2023 #if !CONFIG_REALTIME_ONLY 2024 make_tuple(64, 16, &aom_sad64x16_neon_dotprod, -1), 2025 make_tuple(32, 8, &aom_sad32x8_neon_dotprod, -1), 2026 make_tuple(16, 64, &aom_sad16x64_neon_dotprod, -1), 2027 make_tuple(16, 4, &aom_sad16x4_neon_dotprod, -1), 2028 #endif // !CONFIG_REALTIME_ONLY 2029 }; 2030 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADTest, 2031 ::testing::ValuesIn(neon_dotprod_tests)); 2032 2033 const SadMxNParam skip_neon_dotprod_tests[] = { 2034 make_tuple(128, 128, &aom_sad_skip_128x128_neon_dotprod, -1), 2035 make_tuple(128, 64, &aom_sad_skip_128x64_neon_dotprod, -1), 2036 make_tuple(64, 128, &aom_sad_skip_64x128_neon_dotprod, -1), 2037 make_tuple(64, 64, &aom_sad_skip_64x64_neon_dotprod, -1), 2038 make_tuple(64, 32, &aom_sad_skip_64x32_neon_dotprod, -1), 2039 make_tuple(32, 64, &aom_sad_skip_32x64_neon_dotprod, -1), 2040 make_tuple(32, 32, &aom_sad_skip_32x32_neon_dotprod, -1), 2041 make_tuple(32, 16, &aom_sad_skip_32x16_neon_dotprod, -1), 2042 make_tuple(16, 32, &aom_sad_skip_16x32_neon_dotprod, -1), 2043 make_tuple(16, 16, &aom_sad_skip_16x16_neon_dotprod, -1), 2044 #if !CONFIG_REALTIME_ONLY 2045 make_tuple(64, 16, &aom_sad_skip_64x16_neon_dotprod, -1), 2046 make_tuple(16, 64, &aom_sad_skip_16x64_neon_dotprod, -1), 2047 #endif // !CONFIG_REALTIME_ONLY 2048 }; 2049 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADSkipTest, 2050 ::testing::ValuesIn(skip_neon_dotprod_tests)); 2051 2052 const SadMxNAvgParam avg_neon_dotprod_tests[] = { 2053 make_tuple(128, 128, &aom_sad128x128_avg_neon_dotprod, -1), 2054 make_tuple(128, 64, &aom_sad128x64_avg_neon_dotprod, -1), 2055 make_tuple(64, 128, &aom_sad64x128_avg_neon_dotprod, -1), 2056 make_tuple(64, 64, &aom_sad64x64_avg_neon_dotprod, -1), 2057 make_tuple(64, 32, &aom_sad64x32_avg_neon_dotprod, -1), 2058 make_tuple(32, 64, &aom_sad32x64_avg_neon_dotprod, -1), 2059 make_tuple(32, 32, &aom_sad32x32_avg_neon_dotprod, -1), 2060 make_tuple(32, 16, &aom_sad32x16_avg_neon_dotprod, -1), 2061 make_tuple(16, 32, &aom_sad16x32_avg_neon_dotprod, -1), 2062 make_tuple(16, 16, &aom_sad16x16_avg_neon_dotprod, -1), 2063 make_tuple(16, 8, &aom_sad16x8_avg_neon_dotprod, -1), 2064 #if !CONFIG_REALTIME_ONLY 2065 make_tuple(64, 16, &aom_sad64x16_avg_neon_dotprod, -1), 2066 make_tuple(32, 8, &aom_sad32x8_avg_neon_dotprod, -1), 2067 make_tuple(16, 64, &aom_sad16x64_avg_neon_dotprod, -1), 2068 #endif // !CONFIG_REALTIME_ONLY 2069 }; 2070 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADavgTest, 2071 ::testing::ValuesIn(avg_neon_dotprod_tests)); 2072 2073 const SadMxNx4Param x3d_neon_dotprod_tests[] = { 2074 make_tuple(128, 128, &aom_sad128x128x3d_neon_dotprod, -1), 2075 make_tuple(128, 64, &aom_sad128x64x3d_neon_dotprod, -1), 2076 make_tuple(64, 128, &aom_sad64x128x3d_neon_dotprod, -1), 2077 make_tuple(64, 64, &aom_sad64x64x3d_neon_dotprod, -1), 2078 make_tuple(64, 32, &aom_sad64x32x3d_neon_dotprod, -1), 2079 make_tuple(32, 64, &aom_sad32x64x3d_neon_dotprod, -1), 2080 make_tuple(32, 32, &aom_sad32x32x3d_neon_dotprod, -1), 2081 make_tuple(32, 16, &aom_sad32x16x3d_neon_dotprod, -1), 2082 make_tuple(16, 32, &aom_sad16x32x3d_neon_dotprod, -1), 2083 make_tuple(16, 16, &aom_sad16x16x3d_neon_dotprod, -1), 2084 make_tuple(16, 8, &aom_sad16x8x3d_neon_dotprod, -1), 2085 #if !CONFIG_REALTIME_ONLY 2086 make_tuple(64, 16, &aom_sad64x16x3d_neon_dotprod, -1), 2087 make_tuple(32, 8, &aom_sad32x8x3d_neon_dotprod, -1), 2088 make_tuple(16, 64, &aom_sad16x64x3d_neon_dotprod, -1), 2089 make_tuple(16, 4, &aom_sad16x4x3d_neon_dotprod, -1), 2090 #endif // !CONFIG_REALTIME_ONLY 2091 }; 2092 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADx3Test, 2093 ::testing::ValuesIn(x3d_neon_dotprod_tests)); 2094 2095 const SadMxNx4Param x4d_neon_dotprod_tests[] = { 2096 make_tuple(128, 128, &aom_sad128x128x4d_neon_dotprod, -1), 2097 make_tuple(128, 64, &aom_sad128x64x4d_neon_dotprod, -1), 2098 make_tuple(64, 128, &aom_sad64x128x4d_neon_dotprod, -1), 2099 make_tuple(64, 64, &aom_sad64x64x4d_neon_dotprod, -1), 2100 make_tuple(64, 32, &aom_sad64x32x4d_neon_dotprod, -1), 2101 make_tuple(32, 64, &aom_sad32x64x4d_neon_dotprod, -1), 2102 make_tuple(32, 32, &aom_sad32x32x4d_neon_dotprod, -1), 2103 make_tuple(32, 16, &aom_sad32x16x4d_neon_dotprod, -1), 2104 make_tuple(16, 32, &aom_sad16x32x4d_neon_dotprod, -1), 2105 make_tuple(16, 16, &aom_sad16x16x4d_neon_dotprod, -1), 2106 make_tuple(16, 8, &aom_sad16x8x4d_neon_dotprod, -1), 2107 #if !CONFIG_REALTIME_ONLY 2108 make_tuple(64, 16, &aom_sad64x16x4d_neon_dotprod, -1), 2109 make_tuple(32, 8, &aom_sad32x8x4d_neon_dotprod, -1), 2110 make_tuple(16, 64, &aom_sad16x64x4d_neon_dotprod, -1), 2111 make_tuple(16, 4, &aom_sad16x4x4d_neon_dotprod, -1), 2112 #endif // !CONFIG_REALTIME_ONLY 2113 }; 2114 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADx4Test, 2115 ::testing::ValuesIn(x4d_neon_dotprod_tests)); 2116 2117 const SadSkipMxNx4Param skip_x4d_neon_dotprod_tests[] = { 2118 make_tuple(128, 128, &aom_sad_skip_128x128x4d_neon_dotprod, -1), 2119 make_tuple(128, 64, &aom_sad_skip_128x64x4d_neon_dotprod, -1), 2120 make_tuple(64, 128, &aom_sad_skip_64x128x4d_neon_dotprod, -1), 2121 make_tuple(64, 64, &aom_sad_skip_64x64x4d_neon_dotprod, -1), 2122 make_tuple(64, 32, &aom_sad_skip_64x32x4d_neon_dotprod, -1), 2123 make_tuple(32, 64, &aom_sad_skip_32x64x4d_neon_dotprod, -1), 2124 make_tuple(32, 32, &aom_sad_skip_32x32x4d_neon_dotprod, -1), 2125 make_tuple(32, 16, &aom_sad_skip_32x16x4d_neon_dotprod, -1), 2126 make_tuple(16, 32, &aom_sad_skip_16x32x4d_neon_dotprod, -1), 2127 make_tuple(16, 16, &aom_sad_skip_16x16x4d_neon_dotprod, -1), 2128 #if !CONFIG_REALTIME_ONLY 2129 make_tuple(64, 16, &aom_sad_skip_64x16x4d_neon_dotprod, -1), 2130 make_tuple(16, 64, &aom_sad_skip_16x64x4d_neon_dotprod, -1), 2131 #endif // !CONFIG_REALTIME_ONLY 2132 }; 2133 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADSkipx4Test, 2134 ::testing::ValuesIn(skip_x4d_neon_dotprod_tests)); 2135 #endif // HAVE_NEON_DOTPROD 2136 2137 //------------------------------------------------------------------------------ 2138 // x86 functions 2139 #if HAVE_SSE2 2140 const SadMxNParam sse2_tests[] = { 2141 make_tuple(128, 128, &aom_sad128x128_sse2, -1), 2142 make_tuple(128, 64, &aom_sad128x64_sse2, -1), 2143 make_tuple(64, 128, &aom_sad64x128_sse2, -1), 2144 make_tuple(64, 64, &aom_sad64x64_sse2, -1), 2145 make_tuple(64, 32, &aom_sad64x32_sse2, -1), 2146 make_tuple(32, 64, &aom_sad32x64_sse2, -1), 2147 make_tuple(32, 32, &aom_sad32x32_sse2, -1), 2148 make_tuple(32, 16, &aom_sad32x16_sse2, -1), 2149 make_tuple(16, 32, &aom_sad16x32_sse2, -1), 2150 make_tuple(16, 16, &aom_sad16x16_sse2, -1), 2151 make_tuple(16, 8, &aom_sad16x8_sse2, -1), 2152 make_tuple(8, 16, &aom_sad8x16_sse2, -1), 2153 make_tuple(8, 8, &aom_sad8x8_sse2, -1), 2154 make_tuple(8, 4, &aom_sad8x4_sse2, -1), 2155 make_tuple(4, 8, &aom_sad4x8_sse2, -1), 2156 make_tuple(4, 4, &aom_sad4x4_sse2, -1), 2157 #if CONFIG_AV1_HIGHBITDEPTH 2158 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 8), 2159 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 8), 2160 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 8), 2161 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 8), 2162 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 8), 2163 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 8), 2164 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 8), 2165 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 8), 2166 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8), 2167 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8), 2168 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8), 2169 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 8), 2170 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 8), 2171 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 10), 2172 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 10), 2173 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 10), 2174 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 10), 2175 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 10), 2176 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 10), 2177 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 10), 2178 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 10), 2179 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10), 2180 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10), 2181 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10), 2182 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 10), 2183 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 10), 2184 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 12), 2185 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 12), 2186 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 12), 2187 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 12), 2188 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 12), 2189 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 12), 2190 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 12), 2191 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 12), 2192 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12), 2193 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12), 2194 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12), 2195 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 12), 2196 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 12), 2197 #endif 2198 #if !CONFIG_REALTIME_ONLY 2199 make_tuple(64, 16, &aom_sad64x16_sse2, -1), 2200 make_tuple(16, 64, &aom_sad16x64_sse2, -1), 2201 #if CONFIG_AV1_HIGHBITDEPTH 2202 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 8), 2203 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 8), 2204 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 10), 2205 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 10), 2206 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 12), 2207 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 12), 2208 #endif 2209 make_tuple(32, 8, &aom_sad32x8_sse2, -1), 2210 make_tuple(8, 32, &aom_sad8x32_sse2, -1), 2211 #if CONFIG_AV1_HIGHBITDEPTH 2212 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 8), 2213 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 8), 2214 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 10), 2215 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 10), 2216 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 12), 2217 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 12), 2218 #endif 2219 make_tuple(16, 4, &aom_sad16x4_sse2, -1), 2220 make_tuple(4, 16, &aom_sad4x16_sse2, -1), 2221 #if CONFIG_AV1_HIGHBITDEPTH 2222 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 8), 2223 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 8), 2224 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 10), 2225 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 10), 2226 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 12), 2227 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 12), 2228 #endif 2229 #endif // !CONFIG_REALTIME_ONLY 2230 }; 2231 INSTANTIATE_TEST_SUITE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); 2232 2233 const SadSkipMxNParam skip_sse2_tests[] = { 2234 make_tuple(128, 128, &aom_sad_skip_128x128_sse2, -1), 2235 make_tuple(128, 64, &aom_sad_skip_128x64_sse2, -1), 2236 make_tuple(64, 128, &aom_sad_skip_64x128_sse2, -1), 2237 make_tuple(64, 64, &aom_sad_skip_64x64_sse2, -1), 2238 make_tuple(64, 32, &aom_sad_skip_64x32_sse2, -1), 2239 make_tuple(32, 64, &aom_sad_skip_32x64_sse2, -1), 2240 make_tuple(32, 32, &aom_sad_skip_32x32_sse2, -1), 2241 make_tuple(32, 16, &aom_sad_skip_32x16_sse2, -1), 2242 make_tuple(16, 32, &aom_sad_skip_16x32_sse2, -1), 2243 make_tuple(16, 16, &aom_sad_skip_16x16_sse2, -1), 2244 make_tuple(8, 16, &aom_sad_skip_8x16_sse2, -1), 2245 #if !CONFIG_REALTIME_ONLY 2246 make_tuple(64, 16, &aom_sad_skip_64x16_sse2, -1), 2247 make_tuple(16, 64, &aom_sad_skip_16x64_sse2, -1), 2248 make_tuple(8, 32, &aom_sad_skip_8x32_sse2, -1), 2249 make_tuple(4, 16, &aom_sad_skip_4x16_sse2, -1), 2250 #endif 2251 #if CONFIG_AV1_HIGHBITDEPTH 2252 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 8), 2253 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 8), 2254 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 8), 2255 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 8), 2256 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 8), 2257 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 8), 2258 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 8), 2259 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 8), 2260 #if !CONFIG_REALTIME_ONLY 2261 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 8), 2262 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 8), 2263 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 8), 2264 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 8), 2265 #endif 2266 2267 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 10), 2268 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 10), 2269 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 10), 2270 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 10), 2271 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 10), 2272 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 10), 2273 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 10), 2274 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 10), 2275 #if !CONFIG_REALTIME_ONLY 2276 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 10), 2277 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 10), 2278 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 10), 2279 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 10), 2280 #endif 2281 2282 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 12), 2283 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 12), 2284 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 12), 2285 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 12), 2286 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 12), 2287 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 12), 2288 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 12), 2289 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 12), 2290 #if !CONFIG_REALTIME_ONLY 2291 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 12), 2292 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 12), 2293 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 12), 2294 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 12), 2295 #endif 2296 #endif // CONFIG_AV1_HIGHBITDEPTH 2297 }; 2298 INSTANTIATE_TEST_SUITE_P(SSE2, SADSkipTest, 2299 ::testing::ValuesIn(skip_sse2_tests)); 2300 2301 const SadMxNAvgParam avg_sse2_tests[] = { 2302 make_tuple(128, 128, &aom_sad128x128_avg_sse2, -1), 2303 make_tuple(128, 64, &aom_sad128x64_avg_sse2, -1), 2304 make_tuple(64, 128, &aom_sad64x128_avg_sse2, -1), 2305 make_tuple(64, 64, &aom_sad64x64_avg_sse2, -1), 2306 make_tuple(64, 32, &aom_sad64x32_avg_sse2, -1), 2307 make_tuple(32, 64, &aom_sad32x64_avg_sse2, -1), 2308 make_tuple(32, 32, &aom_sad32x32_avg_sse2, -1), 2309 make_tuple(32, 16, &aom_sad32x16_avg_sse2, -1), 2310 make_tuple(16, 32, &aom_sad16x32_avg_sse2, -1), 2311 make_tuple(16, 16, &aom_sad16x16_avg_sse2, -1), 2312 make_tuple(16, 8, &aom_sad16x8_avg_sse2, -1), 2313 make_tuple(8, 16, &aom_sad8x16_avg_sse2, -1), 2314 make_tuple(8, 8, &aom_sad8x8_avg_sse2, -1), 2315 #if CONFIG_AV1_HIGHBITDEPTH 2316 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 8), 2317 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 8), 2318 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 8), 2319 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 8), 2320 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 8), 2321 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 8), 2322 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 8), 2323 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 8), 2324 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8), 2325 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8), 2326 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 10), 2327 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 10), 2328 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 10), 2329 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 10), 2330 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 10), 2331 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 10), 2332 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 10), 2333 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 10), 2334 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10), 2335 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10), 2336 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 12), 2337 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 12), 2338 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 12), 2339 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 12), 2340 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 12), 2341 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 12), 2342 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 12), 2343 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 12), 2344 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12), 2345 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12), 2346 #endif 2347 #if !CONFIG_REALTIME_ONLY 2348 make_tuple(64, 16, &aom_sad64x16_avg_sse2, -1), 2349 make_tuple(16, 64, &aom_sad16x64_avg_sse2, -1), 2350 #if CONFIG_AV1_HIGHBITDEPTH 2351 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 8), 2352 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 8), 2353 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 10), 2354 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 10), 2355 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 12), 2356 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 12), 2357 #endif 2358 make_tuple(32, 8, &aom_sad32x8_avg_sse2, -1), 2359 make_tuple(8, 32, &aom_sad8x32_avg_sse2, -1), 2360 #if CONFIG_AV1_HIGHBITDEPTH 2361 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 8), 2362 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 8), 2363 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 10), 2364 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 10), 2365 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 12), 2366 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 12), 2367 #endif 2368 #endif // !CONFIG_REALTIME_ONLY 2369 }; 2370 INSTANTIATE_TEST_SUITE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests)); 2371 2372 const SadMxNx4Param x4d_sse2_tests[] = { 2373 make_tuple(128, 128, &aom_sad128x128x4d_sse2, -1), 2374 make_tuple(128, 64, &aom_sad128x64x4d_sse2, -1), 2375 make_tuple(64, 128, &aom_sad64x128x4d_sse2, -1), 2376 make_tuple(64, 64, &aom_sad64x64x4d_sse2, -1), 2377 make_tuple(64, 32, &aom_sad64x32x4d_sse2, -1), 2378 make_tuple(32, 64, &aom_sad32x64x4d_sse2, -1), 2379 make_tuple(32, 32, &aom_sad32x32x4d_sse2, -1), 2380 make_tuple(32, 16, &aom_sad32x16x4d_sse2, -1), 2381 make_tuple(16, 32, &aom_sad16x32x4d_sse2, -1), 2382 make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1), 2383 make_tuple(16, 8, &aom_sad16x8x4d_sse2, -1), 2384 make_tuple(8, 16, &aom_sad8x16x4d_sse2, -1), 2385 make_tuple(8, 8, &aom_sad8x8x4d_sse2, -1), 2386 make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1), 2387 make_tuple(4, 8, &aom_sad4x8x4d_sse2, -1), 2388 make_tuple(4, 4, &aom_sad4x4x4d_sse2, -1), 2389 #if CONFIG_AV1_HIGHBITDEPTH 2390 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 8), 2391 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 8), 2392 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 8), 2393 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 8), 2394 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 8), 2395 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 8), 2396 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 8), 2397 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 8), 2398 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 8), 2399 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 8), 2400 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 8), 2401 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 8), 2402 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 8), 2403 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 10), 2404 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 10), 2405 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 10), 2406 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 10), 2407 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 10), 2408 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 10), 2409 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 10), 2410 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 10), 2411 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 10), 2412 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 10), 2413 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 10), 2414 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 10), 2415 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 10), 2416 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 12), 2417 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 12), 2418 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 12), 2419 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 12), 2420 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 12), 2421 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 12), 2422 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 12), 2423 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 12), 2424 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 12), 2425 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 12), 2426 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 12), 2427 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 12), 2428 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 12), 2429 #endif 2430 #if !CONFIG_REALTIME_ONLY 2431 make_tuple(64, 16, &aom_sad64x16x4d_sse2, -1), 2432 make_tuple(16, 64, &aom_sad16x64x4d_sse2, -1), 2433 #if CONFIG_AV1_HIGHBITDEPTH 2434 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 8), 2435 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 8), 2436 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 10), 2437 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 10), 2438 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 12), 2439 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 12), 2440 #endif 2441 make_tuple(32, 8, &aom_sad32x8x4d_sse2, -1), 2442 make_tuple(8, 32, &aom_sad8x32x4d_sse2, -1), 2443 #if CONFIG_AV1_HIGHBITDEPTH 2444 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 8), 2445 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 8), 2446 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 10), 2447 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 10), 2448 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 12), 2449 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 12), 2450 #endif 2451 make_tuple(16, 4, &aom_sad16x4x4d_sse2, -1), 2452 make_tuple(4, 16, &aom_sad4x16x4d_sse2, -1), 2453 #if CONFIG_AV1_HIGHBITDEPTH 2454 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 8), 2455 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 8), 2456 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 10), 2457 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 10), 2458 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 12), 2459 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 12), 2460 #endif 2461 #endif 2462 }; 2463 INSTANTIATE_TEST_SUITE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests)); 2464 2465 const SadSkipMxNx4Param skip_x4d_sse2_tests[] = { 2466 make_tuple(128, 128, &aom_sad_skip_128x128x4d_sse2, -1), 2467 make_tuple(128, 64, &aom_sad_skip_128x64x4d_sse2, -1), 2468 make_tuple(64, 128, &aom_sad_skip_64x128x4d_sse2, -1), 2469 make_tuple(64, 64, &aom_sad_skip_64x64x4d_sse2, -1), 2470 make_tuple(64, 32, &aom_sad_skip_64x32x4d_sse2, -1), 2471 make_tuple(32, 64, &aom_sad_skip_32x64x4d_sse2, -1), 2472 make_tuple(32, 32, &aom_sad_skip_32x32x4d_sse2, -1), 2473 make_tuple(32, 16, &aom_sad_skip_32x16x4d_sse2, -1), 2474 make_tuple(16, 32, &aom_sad_skip_16x32x4d_sse2, -1), 2475 make_tuple(16, 16, &aom_sad_skip_16x16x4d_sse2, -1), 2476 make_tuple(8, 16, &aom_sad_skip_8x16x4d_sse2, -1), 2477 #if !CONFIG_REALTIME_ONLY 2478 make_tuple(64, 16, &aom_sad_skip_64x16x4d_sse2, -1), 2479 make_tuple(16, 64, &aom_sad_skip_16x64x4d_sse2, -1), 2480 make_tuple(8, 32, &aom_sad_skip_8x32x4d_sse2, -1), 2481 make_tuple(4, 16, &aom_sad_skip_4x16x4d_sse2, -1), 2482 #endif 2483 #if CONFIG_AV1_HIGHBITDEPTH 2484 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 8), 2485 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 8), 2486 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 8), 2487 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 8), 2488 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 8), 2489 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 8), 2490 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 8), 2491 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 8), 2492 #if !CONFIG_REALTIME_ONLY 2493 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 8), 2494 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 8), 2495 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 8), 2496 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 8), 2497 #endif 2498 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 10), 2499 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 10), 2500 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 10), 2501 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 10), 2502 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 10), 2503 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 10), 2504 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 10), 2505 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 10), 2506 #if !CONFIG_REALTIME_ONLY 2507 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 10), 2508 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 10), 2509 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 10), 2510 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 10), 2511 #endif 2512 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 12), 2513 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 12), 2514 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 12), 2515 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 12), 2516 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 12), 2517 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 12), 2518 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 12), 2519 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 12), 2520 #if !CONFIG_REALTIME_ONLY 2521 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 12), 2522 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 12), 2523 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 12), 2524 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 12), 2525 #endif 2526 #endif // CONFIG_AV1_HIGHBITDEPTH 2527 }; 2528 INSTANTIATE_TEST_SUITE_P(SSE2, SADSkipx4Test, 2529 ::testing::ValuesIn(skip_x4d_sse2_tests)); 2530 #endif // HAVE_SSE2 2531 2532 #if HAVE_SSE3 2533 // Only functions are x3, which do not have tests. 2534 #endif // HAVE_SSE3 2535 2536 #if HAVE_SSE4_1 2537 // Only functions are x8, which do not have tests. 2538 #endif // HAVE_SSE4_1 2539 2540 #if HAVE_AVX2 2541 const SadMxNParam avx2_tests[] = { 2542 make_tuple(64, 128, &aom_sad64x128_avx2, -1), 2543 make_tuple(128, 64, &aom_sad128x64_avx2, -1), 2544 make_tuple(128, 128, &aom_sad128x128_avx2, -1), 2545 make_tuple(64, 64, &aom_sad64x64_avx2, -1), 2546 make_tuple(64, 32, &aom_sad64x32_avx2, -1), 2547 make_tuple(32, 64, &aom_sad32x64_avx2, -1), 2548 make_tuple(32, 32, &aom_sad32x32_avx2, -1), 2549 make_tuple(32, 16, &aom_sad32x16_avx2, -1), 2550 #if CONFIG_AV1_HIGHBITDEPTH 2551 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 8), 2552 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 10), 2553 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 12), 2554 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 8), 2555 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 10), 2556 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 12), 2557 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 8), 2558 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 10), 2559 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 12), 2560 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 8), 2561 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 10), 2562 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 12), 2563 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 8), 2564 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 10), 2565 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 12), 2566 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 8), 2567 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 10), 2568 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 12), 2569 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 8), 2570 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 10), 2571 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 12), 2572 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 8), 2573 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 10), 2574 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 12), 2575 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 8), 2576 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 10), 2577 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 12), 2578 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 8), 2579 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 10), 2580 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 12), 2581 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 8), 2582 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 10), 2583 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 12), 2584 2585 #if !CONFIG_REALTIME_ONLY 2586 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 8), 2587 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 10), 2588 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 12), 2589 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 8), 2590 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 10), 2591 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 12), 2592 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 8), 2593 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 10), 2594 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 12), 2595 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 8), 2596 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 10), 2597 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 12), 2598 #endif 2599 #endif 2600 }; 2601 INSTANTIATE_TEST_SUITE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests)); 2602 2603 const SadSkipMxNParam skip_avx2_tests[] = { 2604 make_tuple(128, 128, &aom_sad_skip_128x128_avx2, -1), 2605 make_tuple(128, 64, &aom_sad_skip_128x64_avx2, -1), 2606 make_tuple(64, 128, &aom_sad_skip_64x128_avx2, -1), 2607 make_tuple(64, 64, &aom_sad_skip_64x64_avx2, -1), 2608 make_tuple(64, 32, &aom_sad_skip_64x32_avx2, -1), 2609 make_tuple(32, 64, &aom_sad_skip_32x64_avx2, -1), 2610 make_tuple(32, 32, &aom_sad_skip_32x32_avx2, -1), 2611 make_tuple(32, 16, &aom_sad_skip_32x16_avx2, -1), 2612 #if CONFIG_AV1_HIGHBITDEPTH 2613 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 8), 2614 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 8), 2615 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 8), 2616 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 8), 2617 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 8), 2618 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 8), 2619 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 8), 2620 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 8), 2621 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 8), 2622 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 8), 2623 2624 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 10), 2625 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 10), 2626 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 10), 2627 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 10), 2628 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 10), 2629 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 10), 2630 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 10), 2631 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 10), 2632 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 10), 2633 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 10), 2634 2635 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 12), 2636 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 12), 2637 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 12), 2638 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 12), 2639 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 12), 2640 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 12), 2641 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 12), 2642 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 12), 2643 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 12), 2644 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 12), 2645 2646 #if !CONFIG_REALTIME_ONLY 2647 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 8), 2648 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 10), 2649 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 12), 2650 #endif 2651 #endif 2652 }; 2653 INSTANTIATE_TEST_SUITE_P(AVX2, SADSkipTest, 2654 ::testing::ValuesIn(skip_avx2_tests)); 2655 2656 const SadMxNAvgParam avg_avx2_tests[] = { 2657 make_tuple(64, 128, &aom_sad64x128_avg_avx2, -1), 2658 make_tuple(128, 64, &aom_sad128x64_avg_avx2, -1), 2659 make_tuple(128, 128, &aom_sad128x128_avg_avx2, -1), 2660 make_tuple(64, 64, &aom_sad64x64_avg_avx2, -1), 2661 make_tuple(64, 32, &aom_sad64x32_avg_avx2, -1), 2662 make_tuple(32, 64, &aom_sad32x64_avg_avx2, -1), 2663 make_tuple(32, 32, &aom_sad32x32_avg_avx2, -1), 2664 make_tuple(32, 16, &aom_sad32x16_avg_avx2, -1), 2665 #if CONFIG_AV1_HIGHBITDEPTH 2666 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 8), 2667 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 10), 2668 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 12), 2669 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 8), 2670 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 10), 2671 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 12), 2672 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 8), 2673 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 10), 2674 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 12), 2675 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 8), 2676 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 10), 2677 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 12), 2678 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 8), 2679 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 10), 2680 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 12), 2681 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 8), 2682 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 10), 2683 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 12), 2684 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 8), 2685 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 10), 2686 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 12), 2687 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 8), 2688 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 10), 2689 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 12), 2690 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 8), 2691 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 10), 2692 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 12), 2693 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 8), 2694 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 10), 2695 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 12), 2696 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 8), 2697 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 10), 2698 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 12), 2699 2700 #if !CONFIG_REALTIME_ONLY 2701 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 8), 2702 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 10), 2703 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 12), 2704 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 8), 2705 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 10), 2706 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 12), 2707 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 8), 2708 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 10), 2709 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 12), 2710 #endif 2711 #endif 2712 }; 2713 INSTANTIATE_TEST_SUITE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests)); 2714 2715 const SadSkipMxNx4Param skip_x4d_avx2_tests[] = { 2716 make_tuple(128, 128, &aom_sad_skip_128x128x4d_avx2, -1), 2717 make_tuple(128, 64, &aom_sad_skip_128x64x4d_avx2, -1), 2718 make_tuple(64, 128, &aom_sad_skip_64x128x4d_avx2, -1), 2719 make_tuple(64, 64, &aom_sad_skip_64x64x4d_avx2, -1), 2720 make_tuple(64, 32, &aom_sad_skip_64x32x4d_avx2, -1), 2721 make_tuple(32, 64, &aom_sad_skip_32x64x4d_avx2, -1), 2722 make_tuple(32, 32, &aom_sad_skip_32x32x4d_avx2, -1), 2723 make_tuple(32, 16, &aom_sad_skip_32x16x4d_avx2, -1), 2724 make_tuple(16, 32, &aom_sad_skip_16x32x4d_avx2, -1), 2725 make_tuple(16, 16, &aom_sad_skip_16x16x4d_avx2, -1), 2726 2727 #if CONFIG_AV1_HIGHBITDEPTH 2728 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 8), 2729 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 8), 2730 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 8), 2731 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 8), 2732 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 8), 2733 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 8), 2734 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 8), 2735 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 8), 2736 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 8), 2737 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 8), 2738 2739 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 10), 2740 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 10), 2741 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 10), 2742 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 10), 2743 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 10), 2744 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 10), 2745 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 10), 2746 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 10), 2747 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 10), 2748 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 10), 2749 2750 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 12), 2751 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 12), 2752 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 12), 2753 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 12), 2754 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 12), 2755 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 12), 2756 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 12), 2757 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 12), 2758 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 12), 2759 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 12), 2760 2761 #if !CONFIG_REALTIME_ONLY 2762 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 8), 2763 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 8), 2764 2765 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 10), 2766 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 10), 2767 2768 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 12), 2769 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 12), 2770 #endif 2771 #endif 2772 2773 #if !CONFIG_REALTIME_ONLY 2774 make_tuple(64, 16, &aom_sad_skip_64x16x4d_avx2, -1), 2775 2776 make_tuple(16, 64, &aom_sad_skip_16x64x4d_avx2, -1), 2777 #endif 2778 }; 2779 2780 INSTANTIATE_TEST_SUITE_P(AVX2, SADSkipx4Test, 2781 ::testing::ValuesIn(skip_x4d_avx2_tests)); 2782 2783 const SadMxNx4Param x4d_avx2_tests[] = { 2784 make_tuple(16, 32, &aom_sad16x32x4d_avx2, -1), 2785 make_tuple(16, 16, &aom_sad16x16x4d_avx2, -1), 2786 make_tuple(16, 8, &aom_sad16x8x4d_avx2, -1), 2787 make_tuple(32, 64, &aom_sad32x64x4d_avx2, -1), 2788 make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1), 2789 make_tuple(32, 16, &aom_sad32x16x4d_avx2, -1), 2790 make_tuple(64, 128, &aom_sad64x128x4d_avx2, -1), 2791 make_tuple(64, 64, &aom_sad64x64x4d_avx2, -1), 2792 make_tuple(64, 32, &aom_sad64x32x4d_avx2, -1), 2793 make_tuple(128, 128, &aom_sad128x128x4d_avx2, -1), 2794 make_tuple(128, 64, &aom_sad128x64x4d_avx2, -1), 2795 2796 #if !CONFIG_REALTIME_ONLY 2797 make_tuple(16, 64, &aom_sad16x64x4d_avx2, -1), 2798 make_tuple(16, 4, &aom_sad16x4x4d_avx2, -1), 2799 make_tuple(32, 8, &aom_sad32x8x4d_avx2, -1), 2800 make_tuple(64, 16, &aom_sad64x16x4d_avx2, -1), 2801 #endif 2802 2803 #if CONFIG_AV1_HIGHBITDEPTH 2804 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 8), 2805 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 10), 2806 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 12), 2807 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 8), 2808 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 10), 2809 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 12), 2810 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 8), 2811 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 10), 2812 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 12), 2813 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 8), 2814 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 10), 2815 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 12), 2816 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 8), 2817 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 10), 2818 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 12), 2819 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 8), 2820 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 10), 2821 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 12), 2822 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 8), 2823 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 10), 2824 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 12), 2825 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 8), 2826 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 10), 2827 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 12), 2828 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 8), 2829 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 10), 2830 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 12), 2831 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 8), 2832 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 10), 2833 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 12), 2834 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 8), 2835 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 10), 2836 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 12), 2837 2838 #if !CONFIG_REALTIME_ONLY 2839 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 8), 2840 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 10), 2841 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 12), 2842 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 8), 2843 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 10), 2844 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 12), 2845 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 8), 2846 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 10), 2847 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 12), 2848 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 8), 2849 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 10), 2850 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 12), 2851 #endif 2852 #endif 2853 }; 2854 INSTANTIATE_TEST_SUITE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests)); 2855 2856 const SadMxNx4Param x3d_avx2_tests[] = { 2857 make_tuple(32, 64, &aom_sad32x64x3d_avx2, -1), 2858 make_tuple(32, 32, &aom_sad32x32x3d_avx2, -1), 2859 make_tuple(32, 16, &aom_sad32x16x3d_avx2, -1), 2860 make_tuple(64, 128, &aom_sad64x128x3d_avx2, -1), 2861 make_tuple(64, 64, &aom_sad64x64x3d_avx2, -1), 2862 make_tuple(64, 32, &aom_sad64x32x3d_avx2, -1), 2863 make_tuple(128, 128, &aom_sad128x128x3d_avx2, -1), 2864 make_tuple(128, 64, &aom_sad128x64x3d_avx2, -1), 2865 2866 #if !CONFIG_REALTIME_ONLY 2867 make_tuple(32, 8, &aom_sad32x8x3d_avx2, -1), 2868 make_tuple(64, 16, &aom_sad64x16x3d_avx2, -1), 2869 make_tuple(16, 4, &aom_sad16x4x3d_avx2, -1), 2870 #endif // !CONFIG_REALTIME_ONLY 2871 2872 #if CONFIG_AV1_HIGHBITDEPTH 2873 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 8), 2874 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 10), 2875 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 12), 2876 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 8), 2877 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 10), 2878 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 12), 2879 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 8), 2880 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 10), 2881 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 12), 2882 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 8), 2883 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 10), 2884 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 12), 2885 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 8), 2886 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 10), 2887 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 12), 2888 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 8), 2889 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 10), 2890 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 12), 2891 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 8), 2892 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 10), 2893 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 12), 2894 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 8), 2895 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 10), 2896 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 12), 2897 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 8), 2898 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 10), 2899 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 12), 2900 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 8), 2901 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 10), 2902 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 12), 2903 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 8), 2904 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 10), 2905 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 12), 2906 2907 #if !CONFIG_REALTIME_ONLY 2908 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 8), 2909 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 10), 2910 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 12), 2911 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 8), 2912 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 10), 2913 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 12), 2914 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 8), 2915 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 10), 2916 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 12), 2917 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 8), 2918 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 10), 2919 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 12), 2920 #endif // !CONFIG_REALTIME_ONLY 2921 #endif // CONFIG_AV1_HIGHBITDEPTH 2922 }; 2923 INSTANTIATE_TEST_SUITE_P(AVX2, SADx3Test, ::testing::ValuesIn(x3d_avx2_tests)); 2924 #endif // HAVE_AVX2 2925 2926 #if CONFIG_HIGHWAY && HAVE_AVX512 2927 const SadMxNParam avx512_tests[] = { 2928 make_tuple(64, 128, &aom_sad64x128_avx512, -1), 2929 make_tuple(128, 64, &aom_sad128x64_avx512, -1), 2930 make_tuple(128, 128, &aom_sad128x128_avx512, -1), 2931 make_tuple(64, 64, &aom_sad64x64_avx512, -1), 2932 make_tuple(64, 32, &aom_sad64x32_avx512, -1), 2933 }; 2934 INSTANTIATE_TEST_SUITE_P(AVX512, SADTest, ::testing::ValuesIn(avx512_tests)); 2935 2936 const SadSkipMxNParam skip_avx512_tests[] = { 2937 make_tuple(128, 128, &aom_sad_skip_128x128_avx2, -1), 2938 make_tuple(128, 64, &aom_sad_skip_128x64_avx2, -1), 2939 make_tuple(64, 128, &aom_sad_skip_64x128_avx2, -1), 2940 make_tuple(64, 64, &aom_sad_skip_64x64_avx2, -1), 2941 make_tuple(64, 32, &aom_sad_skip_64x32_avx2, -1), 2942 }; 2943 INSTANTIATE_TEST_SUITE_P(AVX512, SADSkipTest, 2944 ::testing::ValuesIn(skip_avx512_tests)); 2945 2946 const SadMxNAvgParam avg_avx512_tests[] = { 2947 make_tuple(64, 128, &aom_sad64x128_avg_avx512, -1), 2948 make_tuple(128, 64, &aom_sad128x64_avg_avx512, -1), 2949 make_tuple(128, 128, &aom_sad128x128_avg_avx512, -1), 2950 make_tuple(64, 64, &aom_sad64x64_avg_avx512, -1), 2951 make_tuple(64, 32, &aom_sad64x32_avg_avx512, -1), 2952 }; 2953 INSTANTIATE_TEST_SUITE_P(AVX512, SADavgTest, 2954 ::testing::ValuesIn(avg_avx512_tests)); 2955 2956 const SadMxNx4Param x4d_avx512_tests[] = { 2957 make_tuple(128, 128, &aom_sad128x128x4d_avx512, -1), 2958 make_tuple(128, 64, &aom_sad128x64x4d_avx512, -1), 2959 make_tuple(64, 128, &aom_sad64x128x4d_avx512, -1), 2960 make_tuple(64, 64, &aom_sad64x64x4d_avx512, -1), 2961 make_tuple(64, 32, &aom_sad64x32x4d_avx512, -1), 2962 }; 2963 INSTANTIATE_TEST_SUITE_P(AVX512, SADx4Test, 2964 ::testing::ValuesIn(x4d_avx512_tests)); 2965 2966 const SadMxNx4Param x3d_avx512_tests[] = { 2967 make_tuple(128, 128, &aom_sad128x128x3d_avx512, -1), 2968 make_tuple(128, 64, &aom_sad128x64x3d_avx512, -1), 2969 make_tuple(64, 128, &aom_sad64x128x3d_avx512, -1), 2970 make_tuple(64, 64, &aom_sad64x64x3d_avx512, -1), 2971 make_tuple(64, 32, &aom_sad64x32x3d_avx512, -1), 2972 }; 2973 INSTANTIATE_TEST_SUITE_P(AVX512, SADx3Test, 2974 ::testing::ValuesIn(x3d_avx512_tests)); 2975 2976 const SadSkipMxNx4Param skip_x4d_avx512_tests[] = { 2977 make_tuple(128, 128, &aom_sad_skip_128x128x4d_avx512, -1), 2978 make_tuple(128, 64, &aom_sad_skip_128x64x4d_avx512, -1), 2979 make_tuple(64, 128, &aom_sad_skip_64x128x4d_avx512, -1), 2980 make_tuple(64, 64, &aom_sad_skip_64x64x4d_avx512, -1), 2981 make_tuple(64, 32, &aom_sad_skip_64x32x4d_avx512, -1), 2982 }; 2983 INSTANTIATE_TEST_SUITE_P(AVX512, SADSkipx4Test, 2984 ::testing::ValuesIn(skip_x4d_avx512_tests)); 2985 #endif // CONFIG_HIGHWAY && HAVE_AVX512 2986 2987 } // namespace