1 /* 2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12 #include <string.h> 13 #include <limits.h> 14 #include <stdio.h> 15 16 #include "third_party/googletest/src/include/gtest/gtest.h" 17 18 #include "./vpx_config.h" 19 #include "./vpx_dsp_rtcd.h" 20 #include "test/acm_random.h" 21 #include "test/clear_system_state.h" 22 #include "test/register_state_check.h" 23 #include "test/util.h" 24 #include "vpx/vpx_codec.h" 25 #include "vpx_mem/vpx_mem.h" 26 #include "vpx_ports/mem.h" 27 28 typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, 29 int src_stride, 30 const uint8_t *ref_ptr, 31 int ref_stride); 32 typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam; 33 34 typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr, 35 int src_stride, 36 const uint8_t *ref_ptr, 37 int ref_stride, 38 const uint8_t *second_pred); 39 typedef std::tr1::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam; 40 41 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, 42 int src_stride, 43 const uint8_t *const ref_ptr[], 44 int ref_stride, 45 uint32_t *sad_array); 46 typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param; 47 48 using libvpx_test::ACMRandom; 49 50 namespace { 51 class SADTestBase : public ::testing::Test { 52 public: 53 SADTestBase(int width, int height, int bit_depth) : 54 width_(width), height_(height), bd_(bit_depth) {} 55 56 static void SetUpTestCase() { 57 source_data8_ = reinterpret_cast<uint8_t*>( 58 vpx_memalign(kDataAlignment, kDataBlockSize)); 59 reference_data8_ = reinterpret_cast<uint8_t*>( 60 vpx_memalign(kDataAlignment, kDataBufferSize)); 61 second_pred8_ = reinterpret_cast<uint8_t*>( 62 vpx_memalign(kDataAlignment, 64*64)); 63 source_data16_ = reinterpret_cast<uint16_t*>( 64 vpx_memalign(kDataAlignment, kDataBlockSize*sizeof(uint16_t))); 65 reference_data16_ = reinterpret_cast<uint16_t*>( 66 vpx_memalign(kDataAlignment, kDataBufferSize*sizeof(uint16_t))); 67 second_pred16_ = reinterpret_cast<uint16_t*>( 68 vpx_memalign(kDataAlignment, 64*64*sizeof(uint16_t))); 69 } 70 71 static void TearDownTestCase() { 72 vpx_free(source_data8_); 73 source_data8_ = NULL; 74 vpx_free(reference_data8_); 75 reference_data8_ = NULL; 76 vpx_free(second_pred8_); 77 second_pred8_ = NULL; 78 vpx_free(source_data16_); 79 source_data16_ = NULL; 80 vpx_free(reference_data16_); 81 reference_data16_ = NULL; 82 vpx_free(second_pred16_); 83 second_pred16_ = NULL; 84 } 85 86 virtual void TearDown() { 87 libvpx_test::ClearSystemState(); 88 } 89 90 protected: 91 // Handle blocks up to 4 blocks 64x64 with stride up to 128 92 static const int kDataAlignment = 16; 93 static const int kDataBlockSize = 64 * 128; 94 static const int kDataBufferSize = 4 * kDataBlockSize; 95 96 virtual void SetUp() { 97 if (bd_ == -1) { 98 use_high_bit_depth_ = false; 99 bit_depth_ = VPX_BITS_8; 100 source_data_ = source_data8_; 101 reference_data_ = reference_data8_; 102 second_pred_ = second_pred8_; 103 #if CONFIG_VP9_HIGHBITDEPTH 104 } else { 105 use_high_bit_depth_ = true; 106 bit_depth_ = static_cast<vpx_bit_depth_t>(bd_); 107 source_data_ = CONVERT_TO_BYTEPTR(source_data16_); 108 reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_); 109 second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_); 110 #endif // CONFIG_VP9_HIGHBITDEPTH 111 } 112 mask_ = (1 << bit_depth_) - 1; 113 source_stride_ = (width_ + 31) & ~31; 114 reference_stride_ = width_ * 2; 115 rnd_.Reset(ACMRandom::DeterministicSeed()); 116 } 117 118 virtual uint8_t *GetReference(int block_idx) { 119 #if CONFIG_VP9_HIGHBITDEPTH 120 if (use_high_bit_depth_) 121 return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) + 122 block_idx * kDataBlockSize); 123 #endif // CONFIG_VP9_HIGHBITDEPTH 124 return reference_data_ + block_idx * kDataBlockSize; 125 } 126 127 // Sum of Absolute Differences. Given two blocks, calculate the absolute 128 // difference between two pixels in the same relative location; accumulate. 129 unsigned int ReferenceSAD(int block_idx) { 130 unsigned int sad = 0; 131 const uint8_t *const reference8 = GetReference(block_idx); 132 const uint8_t *const source8 = source_data_; 133 #if CONFIG_VP9_HIGHBITDEPTH 134 const uint16_t *const reference16 = 135 CONVERT_TO_SHORTPTR(GetReference(block_idx)); 136 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_); 137 #endif // CONFIG_VP9_HIGHBITDEPTH 138 for (int h = 0; h < height_; ++h) { 139 for (int w = 0; w < width_; ++w) { 140 if (!use_high_bit_depth_) { 141 sad += abs(source8[h * source_stride_ + w] - 142 reference8[h * reference_stride_ + w]); 143 #if CONFIG_VP9_HIGHBITDEPTH 144 } else { 145 sad += abs(source16[h * source_stride_ + w] - 146 reference16[h * reference_stride_ + w]); 147 #endif // CONFIG_VP9_HIGHBITDEPTH 148 } 149 } 150 } 151 return sad; 152 } 153 154 // Sum of Absolute Differences Average. Given two blocks, and a prediction 155 // calculate the absolute difference between one pixel and average of the 156 // corresponding and predicted pixels; accumulate. 157 unsigned int ReferenceSADavg(int block_idx) { 158 unsigned int sad = 0; 159 const uint8_t *const reference8 = GetReference(block_idx); 160 const uint8_t *const source8 = source_data_; 161 const uint8_t *const second_pred8 = second_pred_; 162 #if CONFIG_VP9_HIGHBITDEPTH 163 const uint16_t *const reference16 = 164 CONVERT_TO_SHORTPTR(GetReference(block_idx)); 165 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_); 166 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_); 167 #endif // CONFIG_VP9_HIGHBITDEPTH 168 for (int h = 0; h < height_; ++h) { 169 for (int w = 0; w < width_; ++w) { 170 if (!use_high_bit_depth_) { 171 const int tmp = second_pred8[h * width_ + w] + 172 reference8[h * reference_stride_ + w]; 173 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); 174 sad += abs(source8[h * source_stride_ + w] - comp_pred); 175 #if CONFIG_VP9_HIGHBITDEPTH 176 } else { 177 const int tmp = second_pred16[h * width_ + w] + 178 reference16[h * reference_stride_ + w]; 179 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); 180 sad += abs(source16[h * source_stride_ + w] - comp_pred); 181 #endif // CONFIG_VP9_HIGHBITDEPTH 182 } 183 } 184 } 185 return sad; 186 } 187 188 void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) { 189 uint8_t *data8 = data; 190 #if CONFIG_VP9_HIGHBITDEPTH 191 uint16_t *data16 = CONVERT_TO_SHORTPTR(data); 192 #endif // CONFIG_VP9_HIGHBITDEPTH 193 for (int h = 0; h < height_; ++h) { 194 for (int w = 0; w < width_; ++w) { 195 if (!use_high_bit_depth_) { 196 data8[h * stride + w] = static_cast<uint8_t>(fill_constant); 197 #if CONFIG_VP9_HIGHBITDEPTH 198 } else { 199 data16[h * stride + w] = fill_constant; 200 #endif // CONFIG_VP9_HIGHBITDEPTH 201 } 202 } 203 } 204 } 205 206 void FillRandom(uint8_t *data, int stride) { 207 uint8_t *data8 = data; 208 #if CONFIG_VP9_HIGHBITDEPTH 209 uint16_t *data16 = CONVERT_TO_SHORTPTR(data); 210 #endif // CONFIG_VP9_HIGHBITDEPTH 211 for (int h = 0; h < height_; ++h) { 212 for (int w = 0; w < width_; ++w) { 213 if (!use_high_bit_depth_) { 214 data8[h * stride + w] = rnd_.Rand8(); 215 #if CONFIG_VP9_HIGHBITDEPTH 216 } else { 217 data16[h * stride + w] = rnd_.Rand16() & mask_; 218 #endif // CONFIG_VP9_HIGHBITDEPTH 219 } 220 } 221 } 222 } 223 224 int width_, height_, mask_, bd_; 225 vpx_bit_depth_t bit_depth_; 226 static uint8_t *source_data_; 227 static uint8_t *reference_data_; 228 static uint8_t *second_pred_; 229 int source_stride_; 230 bool use_high_bit_depth_; 231 static uint8_t *source_data8_; 232 static uint8_t *reference_data8_; 233 static uint8_t *second_pred8_; 234 static uint16_t *source_data16_; 235 static uint16_t *reference_data16_; 236 static uint16_t *second_pred16_; 237 int reference_stride_; 238 239 ACMRandom rnd_; 240 }; 241 242 class SADx4Test 243 : public SADTestBase, 244 public ::testing::WithParamInterface<SadMxNx4Param> { 245 public: 246 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 247 248 protected: 249 void SADs(unsigned int *results) { 250 const uint8_t *references[] = {GetReference(0), GetReference(1), 251 GetReference(2), GetReference(3)}; 252 253 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_, 254 references, reference_stride_, 255 results)); 256 } 257 258 void CheckSADs() { 259 unsigned int reference_sad, exp_sad[4]; 260 261 SADs(exp_sad); 262 for (int block = 0; block < 4; ++block) { 263 reference_sad = ReferenceSAD(block); 264 265 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; 266 } 267 } 268 }; 269 270 class SADTest 271 : public SADTestBase, 272 public ::testing::WithParamInterface<SadMxNParam> { 273 public: 274 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 275 276 protected: 277 unsigned int SAD(int block_idx) { 278 unsigned int ret; 279 const uint8_t *const reference = GetReference(block_idx); 280 281 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, 282 reference, reference_stride_)); 283 return ret; 284 } 285 286 void CheckSAD() { 287 const unsigned int reference_sad = ReferenceSAD(0); 288 const unsigned int exp_sad = SAD(0); 289 290 ASSERT_EQ(reference_sad, exp_sad); 291 } 292 }; 293 294 class SADavgTest 295 : public SADTestBase, 296 public ::testing::WithParamInterface<SadMxNAvgParam> { 297 public: 298 SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {} 299 300 protected: 301 unsigned int SAD_avg(int block_idx) { 302 unsigned int ret; 303 const uint8_t *const reference = GetReference(block_idx); 304 305 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, 306 reference, reference_stride_, 307 second_pred_)); 308 return ret; 309 } 310 311 void CheckSAD() { 312 const unsigned int reference_sad = ReferenceSADavg(0); 313 const unsigned int exp_sad = SAD_avg(0); 314 315 ASSERT_EQ(reference_sad, exp_sad); 316 } 317 }; 318 319 uint8_t *SADTestBase::source_data_ = NULL; 320 uint8_t *SADTestBase::reference_data_ = NULL; 321 uint8_t *SADTestBase::second_pred_ = NULL; 322 uint8_t *SADTestBase::source_data8_ = NULL; 323 uint8_t *SADTestBase::reference_data8_ = NULL; 324 uint8_t *SADTestBase::second_pred8_ = NULL; 325 uint16_t *SADTestBase::source_data16_ = NULL; 326 uint16_t *SADTestBase::reference_data16_ = NULL; 327 uint16_t *SADTestBase::second_pred16_ = NULL; 328 329 TEST_P(SADTest, MaxRef) { 330 FillConstant(source_data_, source_stride_, 0); 331 FillConstant(reference_data_, reference_stride_, mask_); 332 CheckSAD(); 333 } 334 335 TEST_P(SADTest, MaxSrc) { 336 FillConstant(source_data_, source_stride_, mask_); 337 FillConstant(reference_data_, reference_stride_, 0); 338 CheckSAD(); 339 } 340 341 TEST_P(SADTest, ShortRef) { 342 const int tmp_stride = reference_stride_; 343 reference_stride_ >>= 1; 344 FillRandom(source_data_, source_stride_); 345 FillRandom(reference_data_, reference_stride_); 346 CheckSAD(); 347 reference_stride_ = tmp_stride; 348 } 349 350 TEST_P(SADTest, UnalignedRef) { 351 // The reference frame, but not the source frame, may be unaligned for 352 // certain types of searches. 353 const int tmp_stride = reference_stride_; 354 reference_stride_ -= 1; 355 FillRandom(source_data_, source_stride_); 356 FillRandom(reference_data_, reference_stride_); 357 CheckSAD(); 358 reference_stride_ = tmp_stride; 359 } 360 361 TEST_P(SADTest, ShortSrc) { 362 const int tmp_stride = source_stride_; 363 source_stride_ >>= 1; 364 FillRandom(source_data_, source_stride_); 365 FillRandom(reference_data_, reference_stride_); 366 CheckSAD(); 367 source_stride_ = tmp_stride; 368 } 369 370 TEST_P(SADavgTest, MaxRef) { 371 FillConstant(source_data_, source_stride_, 0); 372 FillConstant(reference_data_, reference_stride_, mask_); 373 FillConstant(second_pred_, width_, 0); 374 CheckSAD(); 375 } 376 TEST_P(SADavgTest, MaxSrc) { 377 FillConstant(source_data_, source_stride_, mask_); 378 FillConstant(reference_data_, reference_stride_, 0); 379 FillConstant(second_pred_, width_, 0); 380 CheckSAD(); 381 } 382 383 TEST_P(SADavgTest, ShortRef) { 384 const int tmp_stride = reference_stride_; 385 reference_stride_ >>= 1; 386 FillRandom(source_data_, source_stride_); 387 FillRandom(reference_data_, reference_stride_); 388 FillRandom(second_pred_, width_); 389 CheckSAD(); 390 reference_stride_ = tmp_stride; 391 } 392 393 TEST_P(SADavgTest, UnalignedRef) { 394 // The reference frame, but not the source frame, may be unaligned for 395 // certain types of searches. 396 const int tmp_stride = reference_stride_; 397 reference_stride_ -= 1; 398 FillRandom(source_data_, source_stride_); 399 FillRandom(reference_data_, reference_stride_); 400 FillRandom(second_pred_, width_); 401 CheckSAD(); 402 reference_stride_ = tmp_stride; 403 } 404 405 TEST_P(SADavgTest, ShortSrc) { 406 const int tmp_stride = source_stride_; 407 source_stride_ >>= 1; 408 FillRandom(source_data_, source_stride_); 409 FillRandom(reference_data_, reference_stride_); 410 FillRandom(second_pred_, width_); 411 CheckSAD(); 412 source_stride_ = tmp_stride; 413 } 414 415 TEST_P(SADx4Test, MaxRef) { 416 FillConstant(source_data_, source_stride_, 0); 417 FillConstant(GetReference(0), reference_stride_, mask_); 418 FillConstant(GetReference(1), reference_stride_, mask_); 419 FillConstant(GetReference(2), reference_stride_, mask_); 420 FillConstant(GetReference(3), reference_stride_, mask_); 421 CheckSADs(); 422 } 423 424 TEST_P(SADx4Test, MaxSrc) { 425 FillConstant(source_data_, source_stride_, mask_); 426 FillConstant(GetReference(0), reference_stride_, 0); 427 FillConstant(GetReference(1), reference_stride_, 0); 428 FillConstant(GetReference(2), reference_stride_, 0); 429 FillConstant(GetReference(3), reference_stride_, 0); 430 CheckSADs(); 431 } 432 433 TEST_P(SADx4Test, ShortRef) { 434 int tmp_stride = reference_stride_; 435 reference_stride_ >>= 1; 436 FillRandom(source_data_, source_stride_); 437 FillRandom(GetReference(0), reference_stride_); 438 FillRandom(GetReference(1), reference_stride_); 439 FillRandom(GetReference(2), reference_stride_); 440 FillRandom(GetReference(3), reference_stride_); 441 CheckSADs(); 442 reference_stride_ = tmp_stride; 443 } 444 445 TEST_P(SADx4Test, UnalignedRef) { 446 // The reference frame, but not the source frame, may be unaligned for 447 // certain types of searches. 448 int tmp_stride = reference_stride_; 449 reference_stride_ -= 1; 450 FillRandom(source_data_, source_stride_); 451 FillRandom(GetReference(0), reference_stride_); 452 FillRandom(GetReference(1), reference_stride_); 453 FillRandom(GetReference(2), reference_stride_); 454 FillRandom(GetReference(3), reference_stride_); 455 CheckSADs(); 456 reference_stride_ = tmp_stride; 457 } 458 459 TEST_P(SADx4Test, ShortSrc) { 460 int tmp_stride = source_stride_; 461 source_stride_ >>= 1; 462 FillRandom(source_data_, source_stride_); 463 FillRandom(GetReference(0), reference_stride_); 464 FillRandom(GetReference(1), reference_stride_); 465 FillRandom(GetReference(2), reference_stride_); 466 FillRandom(GetReference(3), reference_stride_); 467 CheckSADs(); 468 source_stride_ = tmp_stride; 469 } 470 471 TEST_P(SADx4Test, SrcAlignedByWidth) { 472 uint8_t * tmp_source_data = source_data_; 473 source_data_ += width_; 474 FillRandom(source_data_, source_stride_); 475 FillRandom(GetReference(0), reference_stride_); 476 FillRandom(GetReference(1), reference_stride_); 477 FillRandom(GetReference(2), reference_stride_); 478 FillRandom(GetReference(3), reference_stride_); 479 CheckSADs(); 480 source_data_ = tmp_source_data; 481 } 482 483 using std::tr1::make_tuple; 484 485 //------------------------------------------------------------------------------ 486 // C functions 487 const SadMxNFunc sad64x64_c = vpx_sad64x64_c; 488 const SadMxNFunc sad64x32_c = vpx_sad64x32_c; 489 const SadMxNFunc sad32x64_c = vpx_sad32x64_c; 490 const SadMxNFunc sad32x32_c = vpx_sad32x32_c; 491 const SadMxNFunc sad32x16_c = vpx_sad32x16_c; 492 const SadMxNFunc sad16x32_c = vpx_sad16x32_c; 493 const SadMxNFunc sad16x16_c = vpx_sad16x16_c; 494 const SadMxNFunc sad16x8_c = vpx_sad16x8_c; 495 const SadMxNFunc sad8x16_c = vpx_sad8x16_c; 496 const SadMxNFunc sad8x8_c = vpx_sad8x8_c; 497 const SadMxNFunc sad8x4_c = vpx_sad8x4_c; 498 const SadMxNFunc sad4x8_c = vpx_sad4x8_c; 499 const SadMxNFunc sad4x4_c = vpx_sad4x4_c; 500 #if CONFIG_VP9_HIGHBITDEPTH 501 const SadMxNFunc highbd_sad64x64_c = vpx_highbd_sad64x64_c; 502 const SadMxNFunc highbd_sad64x32_c = vpx_highbd_sad64x32_c; 503 const SadMxNFunc highbd_sad32x64_c = vpx_highbd_sad32x64_c; 504 const SadMxNFunc highbd_sad32x32_c = vpx_highbd_sad32x32_c; 505 const SadMxNFunc highbd_sad32x16_c = vpx_highbd_sad32x16_c; 506 const SadMxNFunc highbd_sad16x32_c = vpx_highbd_sad16x32_c; 507 const SadMxNFunc highbd_sad16x16_c = vpx_highbd_sad16x16_c; 508 const SadMxNFunc highbd_sad16x8_c = vpx_highbd_sad16x8_c; 509 const SadMxNFunc highbd_sad8x16_c = vpx_highbd_sad8x16_c; 510 const SadMxNFunc highbd_sad8x8_c = vpx_highbd_sad8x8_c; 511 const SadMxNFunc highbd_sad8x4_c = vpx_highbd_sad8x4_c; 512 const SadMxNFunc highbd_sad4x8_c = vpx_highbd_sad4x8_c; 513 const SadMxNFunc highbd_sad4x4_c = vpx_highbd_sad4x4_c; 514 #endif // CONFIG_VP9_HIGHBITDEPTH 515 const SadMxNParam c_tests[] = { 516 make_tuple(64, 64, sad64x64_c, -1), 517 make_tuple(64, 32, sad64x32_c, -1), 518 make_tuple(32, 64, sad32x64_c, -1), 519 make_tuple(32, 32, sad32x32_c, -1), 520 make_tuple(32, 16, sad32x16_c, -1), 521 make_tuple(16, 32, sad16x32_c, -1), 522 make_tuple(16, 16, sad16x16_c, -1), 523 make_tuple(16, 8, sad16x8_c, -1), 524 make_tuple(8, 16, sad8x16_c, -1), 525 make_tuple(8, 8, sad8x8_c, -1), 526 make_tuple(8, 4, sad8x4_c, -1), 527 make_tuple(4, 8, sad4x8_c, -1), 528 make_tuple(4, 4, sad4x4_c, -1), 529 #if CONFIG_VP9_HIGHBITDEPTH 530 make_tuple(64, 64, highbd_sad64x64_c, 8), 531 make_tuple(64, 32, highbd_sad64x32_c, 8), 532 make_tuple(32, 64, highbd_sad32x64_c, 8), 533 make_tuple(32, 32, highbd_sad32x32_c, 8), 534 make_tuple(32, 16, highbd_sad32x16_c, 8), 535 make_tuple(16, 32, highbd_sad16x32_c, 8), 536 make_tuple(16, 16, highbd_sad16x16_c, 8), 537 make_tuple(16, 8, highbd_sad16x8_c, 8), 538 make_tuple(8, 16, highbd_sad8x16_c, 8), 539 make_tuple(8, 8, highbd_sad8x8_c, 8), 540 make_tuple(8, 4, highbd_sad8x4_c, 8), 541 make_tuple(4, 8, highbd_sad4x8_c, 8), 542 make_tuple(4, 4, highbd_sad4x4_c, 8), 543 make_tuple(64, 64, highbd_sad64x64_c, 10), 544 make_tuple(64, 32, highbd_sad64x32_c, 10), 545 make_tuple(32, 64, highbd_sad32x64_c, 10), 546 make_tuple(32, 32, highbd_sad32x32_c, 10), 547 make_tuple(32, 16, highbd_sad32x16_c, 10), 548 make_tuple(16, 32, highbd_sad16x32_c, 10), 549 make_tuple(16, 16, highbd_sad16x16_c, 10), 550 make_tuple(16, 8, highbd_sad16x8_c, 10), 551 make_tuple(8, 16, highbd_sad8x16_c, 10), 552 make_tuple(8, 8, highbd_sad8x8_c, 10), 553 make_tuple(8, 4, highbd_sad8x4_c, 10), 554 make_tuple(4, 8, highbd_sad4x8_c, 10), 555 make_tuple(4, 4, highbd_sad4x4_c, 10), 556 make_tuple(64, 64, highbd_sad64x64_c, 12), 557 make_tuple(64, 32, highbd_sad64x32_c, 12), 558 make_tuple(32, 64, highbd_sad32x64_c, 12), 559 make_tuple(32, 32, highbd_sad32x32_c, 12), 560 make_tuple(32, 16, highbd_sad32x16_c, 12), 561 make_tuple(16, 32, highbd_sad16x32_c, 12), 562 make_tuple(16, 16, highbd_sad16x16_c, 12), 563 make_tuple(16, 8, highbd_sad16x8_c, 12), 564 make_tuple(8, 16, highbd_sad8x16_c, 12), 565 make_tuple(8, 8, highbd_sad8x8_c, 12), 566 make_tuple(8, 4, highbd_sad8x4_c, 12), 567 make_tuple(4, 8, highbd_sad4x8_c, 12), 568 make_tuple(4, 4, highbd_sad4x4_c, 12), 569 #endif // CONFIG_VP9_HIGHBITDEPTH 570 }; 571 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); 572 573 const SadMxNAvgFunc sad64x64_avg_c = vpx_sad64x64_avg_c; 574 const SadMxNAvgFunc sad64x32_avg_c = vpx_sad64x32_avg_c; 575 const SadMxNAvgFunc sad32x64_avg_c = vpx_sad32x64_avg_c; 576 const SadMxNAvgFunc sad32x32_avg_c = vpx_sad32x32_avg_c; 577 const SadMxNAvgFunc sad32x16_avg_c = vpx_sad32x16_avg_c; 578 const SadMxNAvgFunc sad16x32_avg_c = vpx_sad16x32_avg_c; 579 const SadMxNAvgFunc sad16x16_avg_c = vpx_sad16x16_avg_c; 580 const SadMxNAvgFunc sad16x8_avg_c = vpx_sad16x8_avg_c; 581 const SadMxNAvgFunc sad8x16_avg_c = vpx_sad8x16_avg_c; 582 const SadMxNAvgFunc sad8x8_avg_c = vpx_sad8x8_avg_c; 583 const SadMxNAvgFunc sad8x4_avg_c = vpx_sad8x4_avg_c; 584 const SadMxNAvgFunc sad4x8_avg_c = vpx_sad4x8_avg_c; 585 const SadMxNAvgFunc sad4x4_avg_c = vpx_sad4x4_avg_c; 586 #if CONFIG_VP9_HIGHBITDEPTH 587 const SadMxNAvgFunc highbd_sad64x64_avg_c = vpx_highbd_sad64x64_avg_c; 588 const SadMxNAvgFunc highbd_sad64x32_avg_c = vpx_highbd_sad64x32_avg_c; 589 const SadMxNAvgFunc highbd_sad32x64_avg_c = vpx_highbd_sad32x64_avg_c; 590 const SadMxNAvgFunc highbd_sad32x32_avg_c = vpx_highbd_sad32x32_avg_c; 591 const SadMxNAvgFunc highbd_sad32x16_avg_c = vpx_highbd_sad32x16_avg_c; 592 const SadMxNAvgFunc highbd_sad16x32_avg_c = vpx_highbd_sad16x32_avg_c; 593 const SadMxNAvgFunc highbd_sad16x16_avg_c = vpx_highbd_sad16x16_avg_c; 594 const SadMxNAvgFunc highbd_sad16x8_avg_c = vpx_highbd_sad16x8_avg_c; 595 const SadMxNAvgFunc highbd_sad8x16_avg_c = vpx_highbd_sad8x16_avg_c; 596 const SadMxNAvgFunc highbd_sad8x8_avg_c = vpx_highbd_sad8x8_avg_c; 597 const SadMxNAvgFunc highbd_sad8x4_avg_c = vpx_highbd_sad8x4_avg_c; 598 const SadMxNAvgFunc highbd_sad4x8_avg_c = vpx_highbd_sad4x8_avg_c; 599 const SadMxNAvgFunc highbd_sad4x4_avg_c = vpx_highbd_sad4x4_avg_c; 600 #endif // CONFIG_VP9_HIGHBITDEPTH 601 const SadMxNAvgParam avg_c_tests[] = { 602 make_tuple(64, 64, sad64x64_avg_c, -1), 603 make_tuple(64, 32, sad64x32_avg_c, -1), 604 make_tuple(32, 64, sad32x64_avg_c, -1), 605 make_tuple(32, 32, sad32x32_avg_c, -1), 606 make_tuple(32, 16, sad32x16_avg_c, -1), 607 make_tuple(16, 32, sad16x32_avg_c, -1), 608 make_tuple(16, 16, sad16x16_avg_c, -1), 609 make_tuple(16, 8, sad16x8_avg_c, -1), 610 make_tuple(8, 16, sad8x16_avg_c, -1), 611 make_tuple(8, 8, sad8x8_avg_c, -1), 612 make_tuple(8, 4, sad8x4_avg_c, -1), 613 make_tuple(4, 8, sad4x8_avg_c, -1), 614 make_tuple(4, 4, sad4x4_avg_c, -1), 615 #if CONFIG_VP9_HIGHBITDEPTH 616 make_tuple(64, 64, highbd_sad64x64_avg_c, 8), 617 make_tuple(64, 32, highbd_sad64x32_avg_c, 8), 618 make_tuple(32, 64, highbd_sad32x64_avg_c, 8), 619 make_tuple(32, 32, highbd_sad32x32_avg_c, 8), 620 make_tuple(32, 16, highbd_sad32x16_avg_c, 8), 621 make_tuple(16, 32, highbd_sad16x32_avg_c, 8), 622 make_tuple(16, 16, highbd_sad16x16_avg_c, 8), 623 make_tuple(16, 8, highbd_sad16x8_avg_c, 8), 624 make_tuple(8, 16, highbd_sad8x16_avg_c, 8), 625 make_tuple(8, 8, highbd_sad8x8_avg_c, 8), 626 make_tuple(8, 4, highbd_sad8x4_avg_c, 8), 627 make_tuple(4, 8, highbd_sad4x8_avg_c, 8), 628 make_tuple(4, 4, highbd_sad4x4_avg_c, 8), 629 make_tuple(64, 64, highbd_sad64x64_avg_c, 10), 630 make_tuple(64, 32, highbd_sad64x32_avg_c, 10), 631 make_tuple(32, 64, highbd_sad32x64_avg_c, 10), 632 make_tuple(32, 32, highbd_sad32x32_avg_c, 10), 633 make_tuple(32, 16, highbd_sad32x16_avg_c, 10), 634 make_tuple(16, 32, highbd_sad16x32_avg_c, 10), 635 make_tuple(16, 16, highbd_sad16x16_avg_c, 10), 636 make_tuple(16, 8, highbd_sad16x8_avg_c, 10), 637 make_tuple(8, 16, highbd_sad8x16_avg_c, 10), 638 make_tuple(8, 8, highbd_sad8x8_avg_c, 10), 639 make_tuple(8, 4, highbd_sad8x4_avg_c, 10), 640 make_tuple(4, 8, highbd_sad4x8_avg_c, 10), 641 make_tuple(4, 4, highbd_sad4x4_avg_c, 10), 642 make_tuple(64, 64, highbd_sad64x64_avg_c, 12), 643 make_tuple(64, 32, highbd_sad64x32_avg_c, 12), 644 make_tuple(32, 64, highbd_sad32x64_avg_c, 12), 645 make_tuple(32, 32, highbd_sad32x32_avg_c, 12), 646 make_tuple(32, 16, highbd_sad32x16_avg_c, 12), 647 make_tuple(16, 32, highbd_sad16x32_avg_c, 12), 648 make_tuple(16, 16, highbd_sad16x16_avg_c, 12), 649 make_tuple(16, 8, highbd_sad16x8_avg_c, 12), 650 make_tuple(8, 16, highbd_sad8x16_avg_c, 12), 651 make_tuple(8, 8, highbd_sad8x8_avg_c, 12), 652 make_tuple(8, 4, highbd_sad8x4_avg_c, 12), 653 make_tuple(4, 8, highbd_sad4x8_avg_c, 12), 654 make_tuple(4, 4, highbd_sad4x4_avg_c, 12), 655 #endif // CONFIG_VP9_HIGHBITDEPTH 656 }; 657 INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests)); 658 659 const SadMxNx4Func sad64x64x4d_c = vpx_sad64x64x4d_c; 660 const SadMxNx4Func sad64x32x4d_c = vpx_sad64x32x4d_c; 661 const SadMxNx4Func sad32x64x4d_c = vpx_sad32x64x4d_c; 662 const SadMxNx4Func sad32x32x4d_c = vpx_sad32x32x4d_c; 663 const SadMxNx4Func sad32x16x4d_c = vpx_sad32x16x4d_c; 664 const SadMxNx4Func sad16x32x4d_c = vpx_sad16x32x4d_c; 665 const SadMxNx4Func sad16x16x4d_c = vpx_sad16x16x4d_c; 666 const SadMxNx4Func sad16x8x4d_c = vpx_sad16x8x4d_c; 667 const SadMxNx4Func sad8x16x4d_c = vpx_sad8x16x4d_c; 668 const SadMxNx4Func sad8x8x4d_c = vpx_sad8x8x4d_c; 669 const SadMxNx4Func sad8x4x4d_c = vpx_sad8x4x4d_c; 670 const SadMxNx4Func sad4x8x4d_c = vpx_sad4x8x4d_c; 671 const SadMxNx4Func sad4x4x4d_c = vpx_sad4x4x4d_c; 672 #if CONFIG_VP9_HIGHBITDEPTH 673 const SadMxNx4Func highbd_sad64x64x4d_c = vpx_highbd_sad64x64x4d_c; 674 const SadMxNx4Func highbd_sad64x32x4d_c = vpx_highbd_sad64x32x4d_c; 675 const SadMxNx4Func highbd_sad32x64x4d_c = vpx_highbd_sad32x64x4d_c; 676 const SadMxNx4Func highbd_sad32x32x4d_c = vpx_highbd_sad32x32x4d_c; 677 const SadMxNx4Func highbd_sad32x16x4d_c = vpx_highbd_sad32x16x4d_c; 678 const SadMxNx4Func highbd_sad16x32x4d_c = vpx_highbd_sad16x32x4d_c; 679 const SadMxNx4Func highbd_sad16x16x4d_c = vpx_highbd_sad16x16x4d_c; 680 const SadMxNx4Func highbd_sad16x8x4d_c = vpx_highbd_sad16x8x4d_c; 681 const SadMxNx4Func highbd_sad8x16x4d_c = vpx_highbd_sad8x16x4d_c; 682 const SadMxNx4Func highbd_sad8x8x4d_c = vpx_highbd_sad8x8x4d_c; 683 const SadMxNx4Func highbd_sad8x4x4d_c = vpx_highbd_sad8x4x4d_c; 684 const SadMxNx4Func highbd_sad4x8x4d_c = vpx_highbd_sad4x8x4d_c; 685 const SadMxNx4Func highbd_sad4x4x4d_c = vpx_highbd_sad4x4x4d_c; 686 #endif // CONFIG_VP9_HIGHBITDEPTH 687 const SadMxNx4Param x4d_c_tests[] = { 688 make_tuple(64, 64, sad64x64x4d_c, -1), 689 make_tuple(64, 32, sad64x32x4d_c, -1), 690 make_tuple(32, 64, sad32x64x4d_c, -1), 691 make_tuple(32, 32, sad32x32x4d_c, -1), 692 make_tuple(32, 16, sad32x16x4d_c, -1), 693 make_tuple(16, 32, sad16x32x4d_c, -1), 694 make_tuple(16, 16, sad16x16x4d_c, -1), 695 make_tuple(16, 8, sad16x8x4d_c, -1), 696 make_tuple(8, 16, sad8x16x4d_c, -1), 697 make_tuple(8, 8, sad8x8x4d_c, -1), 698 make_tuple(8, 4, sad8x4x4d_c, -1), 699 make_tuple(4, 8, sad4x8x4d_c, -1), 700 make_tuple(4, 4, sad4x4x4d_c, -1), 701 #if CONFIG_VP9_HIGHBITDEPTH 702 make_tuple(64, 64, highbd_sad64x64x4d_c, 8), 703 make_tuple(64, 32, highbd_sad64x32x4d_c, 8), 704 make_tuple(32, 64, highbd_sad32x64x4d_c, 8), 705 make_tuple(32, 32, highbd_sad32x32x4d_c, 8), 706 make_tuple(32, 16, highbd_sad32x16x4d_c, 8), 707 make_tuple(16, 32, highbd_sad16x32x4d_c, 8), 708 make_tuple(16, 16, highbd_sad16x16x4d_c, 8), 709 make_tuple(16, 8, highbd_sad16x8x4d_c, 8), 710 make_tuple(8, 16, highbd_sad8x16x4d_c, 8), 711 make_tuple(8, 8, highbd_sad8x8x4d_c, 8), 712 make_tuple(8, 4, highbd_sad8x4x4d_c, 8), 713 make_tuple(4, 8, highbd_sad4x8x4d_c, 8), 714 make_tuple(4, 4, highbd_sad4x4x4d_c, 8), 715 make_tuple(64, 64, highbd_sad64x64x4d_c, 10), 716 make_tuple(64, 32, highbd_sad64x32x4d_c, 10), 717 make_tuple(32, 64, highbd_sad32x64x4d_c, 10), 718 make_tuple(32, 32, highbd_sad32x32x4d_c, 10), 719 make_tuple(32, 16, highbd_sad32x16x4d_c, 10), 720 make_tuple(16, 32, highbd_sad16x32x4d_c, 10), 721 make_tuple(16, 16, highbd_sad16x16x4d_c, 10), 722 make_tuple(16, 8, highbd_sad16x8x4d_c, 10), 723 make_tuple(8, 16, highbd_sad8x16x4d_c, 10), 724 make_tuple(8, 8, highbd_sad8x8x4d_c, 10), 725 make_tuple(8, 4, highbd_sad8x4x4d_c, 10), 726 make_tuple(4, 8, highbd_sad4x8x4d_c, 10), 727 make_tuple(4, 4, highbd_sad4x4x4d_c, 10), 728 make_tuple(64, 64, highbd_sad64x64x4d_c, 12), 729 make_tuple(64, 32, highbd_sad64x32x4d_c, 12), 730 make_tuple(32, 64, highbd_sad32x64x4d_c, 12), 731 make_tuple(32, 32, highbd_sad32x32x4d_c, 12), 732 make_tuple(32, 16, highbd_sad32x16x4d_c, 12), 733 make_tuple(16, 32, highbd_sad16x32x4d_c, 12), 734 make_tuple(16, 16, highbd_sad16x16x4d_c, 12), 735 make_tuple(16, 8, highbd_sad16x8x4d_c, 12), 736 make_tuple(8, 16, highbd_sad8x16x4d_c, 12), 737 make_tuple(8, 8, highbd_sad8x8x4d_c, 12), 738 make_tuple(8, 4, highbd_sad8x4x4d_c, 12), 739 make_tuple(4, 8, highbd_sad4x8x4d_c, 12), 740 make_tuple(4, 4, highbd_sad4x4x4d_c, 12), 741 #endif // CONFIG_VP9_HIGHBITDEPTH 742 }; 743 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests)); 744 745 //------------------------------------------------------------------------------ 746 // ARM functions 747 #if HAVE_MEDIA 748 const SadMxNFunc sad16x16_media = vpx_sad16x16_media; 749 const SadMxNParam media_tests[] = { 750 make_tuple(16, 16, sad16x16_media, -1), 751 }; 752 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests)); 753 #endif // HAVE_MEDIA 754 755 #if HAVE_NEON 756 const SadMxNFunc sad64x64_neon = vpx_sad64x64_neon; 757 const SadMxNFunc sad32x32_neon = vpx_sad32x32_neon; 758 const SadMxNFunc sad16x16_neon = vpx_sad16x16_neon; 759 const SadMxNFunc sad16x8_neon = vpx_sad16x8_neon; 760 const SadMxNFunc sad8x16_neon = vpx_sad8x16_neon; 761 const SadMxNFunc sad8x8_neon = vpx_sad8x8_neon; 762 const SadMxNFunc sad4x4_neon = vpx_sad4x4_neon; 763 764 const SadMxNParam neon_tests[] = { 765 make_tuple(64, 64, sad64x64_neon, -1), 766 make_tuple(32, 32, sad32x32_neon, -1), 767 make_tuple(16, 16, sad16x16_neon, -1), 768 make_tuple(16, 8, sad16x8_neon, -1), 769 make_tuple(8, 16, sad8x16_neon, -1), 770 make_tuple(8, 8, sad8x8_neon, -1), 771 make_tuple(4, 4, sad4x4_neon, -1), 772 }; 773 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests)); 774 775 const SadMxNx4Func sad64x64x4d_neon = vpx_sad64x64x4d_neon; 776 const SadMxNx4Func sad32x32x4d_neon = vpx_sad32x32x4d_neon; 777 const SadMxNx4Func sad16x16x4d_neon = vpx_sad16x16x4d_neon; 778 const SadMxNx4Param x4d_neon_tests[] = { 779 make_tuple(64, 64, sad64x64x4d_neon, -1), 780 make_tuple(32, 32, sad32x32x4d_neon, -1), 781 make_tuple(16, 16, sad16x16x4d_neon, -1), 782 }; 783 INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests)); 784 #endif // HAVE_NEON 785 786 //------------------------------------------------------------------------------ 787 // x86 functions 788 #if HAVE_MMX 789 const SadMxNFunc sad16x16_mmx = vpx_sad16x16_mmx; 790 const SadMxNFunc sad16x8_mmx = vpx_sad16x8_mmx; 791 const SadMxNFunc sad8x16_mmx = vpx_sad8x16_mmx; 792 const SadMxNFunc sad8x8_mmx = vpx_sad8x8_mmx; 793 const SadMxNFunc sad4x4_mmx = vpx_sad4x4_mmx; 794 const SadMxNParam mmx_tests[] = { 795 make_tuple(16, 16, sad16x16_mmx, -1), 796 make_tuple(16, 8, sad16x8_mmx, -1), 797 make_tuple(8, 16, sad8x16_mmx, -1), 798 make_tuple(8, 8, sad8x8_mmx, -1), 799 make_tuple(4, 4, sad4x4_mmx, -1), 800 }; 801 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); 802 #endif // HAVE_MMX 803 804 #if HAVE_SSE 805 #if CONFIG_USE_X86INC 806 const SadMxNFunc sad4x8_sse = vpx_sad4x8_sse; 807 const SadMxNFunc sad4x4_sse = vpx_sad4x4_sse; 808 const SadMxNParam sse_tests[] = { 809 make_tuple(4, 8, sad4x8_sse, -1), 810 make_tuple(4, 4, sad4x4_sse, -1), 811 }; 812 INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::ValuesIn(sse_tests)); 813 814 const SadMxNAvgFunc sad4x8_avg_sse = vpx_sad4x8_avg_sse; 815 const SadMxNAvgFunc sad4x4_avg_sse = vpx_sad4x4_avg_sse; 816 const SadMxNAvgParam avg_sse_tests[] = { 817 make_tuple(4, 8, sad4x8_avg_sse, -1), 818 make_tuple(4, 4, sad4x4_avg_sse, -1), 819 }; 820 INSTANTIATE_TEST_CASE_P(SSE, SADavgTest, ::testing::ValuesIn(avg_sse_tests)); 821 822 const SadMxNx4Func sad4x8x4d_sse = vpx_sad4x8x4d_sse; 823 const SadMxNx4Func sad4x4x4d_sse = vpx_sad4x4x4d_sse; 824 const SadMxNx4Param x4d_sse_tests[] = { 825 make_tuple(4, 8, sad4x8x4d_sse, -1), 826 make_tuple(4, 4, sad4x4x4d_sse, -1), 827 }; 828 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::ValuesIn(x4d_sse_tests)); 829 #endif // CONFIG_USE_X86INC 830 #endif // HAVE_SSE 831 832 #if HAVE_SSE2 833 #if CONFIG_USE_X86INC 834 const SadMxNFunc sad64x64_sse2 = vpx_sad64x64_sse2; 835 const SadMxNFunc sad64x32_sse2 = vpx_sad64x32_sse2; 836 const SadMxNFunc sad32x64_sse2 = vpx_sad32x64_sse2; 837 const SadMxNFunc sad32x32_sse2 = vpx_sad32x32_sse2; 838 const SadMxNFunc sad32x16_sse2 = vpx_sad32x16_sse2; 839 const SadMxNFunc sad16x32_sse2 = vpx_sad16x32_sse2; 840 const SadMxNFunc sad16x16_sse2 = vpx_sad16x16_sse2; 841 const SadMxNFunc sad16x8_sse2 = vpx_sad16x8_sse2; 842 const SadMxNFunc sad8x16_sse2 = vpx_sad8x16_sse2; 843 const SadMxNFunc sad8x8_sse2 = vpx_sad8x8_sse2; 844 const SadMxNFunc sad8x4_sse2 = vpx_sad8x4_sse2; 845 #if CONFIG_VP9_HIGHBITDEPTH 846 const SadMxNFunc highbd_sad64x64_sse2 = vpx_highbd_sad64x64_sse2; 847 const SadMxNFunc highbd_sad64x32_sse2 = vpx_highbd_sad64x32_sse2; 848 const SadMxNFunc highbd_sad32x64_sse2 = vpx_highbd_sad32x64_sse2; 849 const SadMxNFunc highbd_sad32x32_sse2 = vpx_highbd_sad32x32_sse2; 850 const SadMxNFunc highbd_sad32x16_sse2 = vpx_highbd_sad32x16_sse2; 851 const SadMxNFunc highbd_sad16x32_sse2 = vpx_highbd_sad16x32_sse2; 852 const SadMxNFunc highbd_sad16x16_sse2 = vpx_highbd_sad16x16_sse2; 853 const SadMxNFunc highbd_sad16x8_sse2 = vpx_highbd_sad16x8_sse2; 854 const SadMxNFunc highbd_sad8x16_sse2 = vpx_highbd_sad8x16_sse2; 855 const SadMxNFunc highbd_sad8x8_sse2 = vpx_highbd_sad8x8_sse2; 856 const SadMxNFunc highbd_sad8x4_sse2 = vpx_highbd_sad8x4_sse2; 857 #endif // CONFIG_VP9_HIGHBITDEPTH 858 const SadMxNParam sse2_tests[] = { 859 make_tuple(64, 64, sad64x64_sse2, -1), 860 make_tuple(64, 32, sad64x32_sse2, -1), 861 make_tuple(32, 64, sad32x64_sse2, -1), 862 make_tuple(32, 32, sad32x32_sse2, -1), 863 make_tuple(32, 16, sad32x16_sse2, -1), 864 make_tuple(16, 32, sad16x32_sse2, -1), 865 make_tuple(16, 16, sad16x16_sse2, -1), 866 make_tuple(16, 8, sad16x8_sse2, -1), 867 make_tuple(8, 16, sad8x16_sse2, -1), 868 make_tuple(8, 8, sad8x8_sse2, -1), 869 make_tuple(8, 4, sad8x4_sse2, -1), 870 #if CONFIG_VP9_HIGHBITDEPTH 871 make_tuple(64, 64, highbd_sad64x64_sse2, 8), 872 make_tuple(64, 32, highbd_sad64x32_sse2, 8), 873 make_tuple(32, 64, highbd_sad32x64_sse2, 8), 874 make_tuple(32, 32, highbd_sad32x32_sse2, 8), 875 make_tuple(32, 16, highbd_sad32x16_sse2, 8), 876 make_tuple(16, 32, highbd_sad16x32_sse2, 8), 877 make_tuple(16, 16, highbd_sad16x16_sse2, 8), 878 make_tuple(16, 8, highbd_sad16x8_sse2, 8), 879 make_tuple(8, 16, highbd_sad8x16_sse2, 8), 880 make_tuple(8, 8, highbd_sad8x8_sse2, 8), 881 make_tuple(8, 4, highbd_sad8x4_sse2, 8), 882 make_tuple(64, 64, highbd_sad64x64_sse2, 10), 883 make_tuple(64, 32, highbd_sad64x32_sse2, 10), 884 make_tuple(32, 64, highbd_sad32x64_sse2, 10), 885 make_tuple(32, 32, highbd_sad32x32_sse2, 10), 886 make_tuple(32, 16, highbd_sad32x16_sse2, 10), 887 make_tuple(16, 32, highbd_sad16x32_sse2, 10), 888 make_tuple(16, 16, highbd_sad16x16_sse2, 10), 889 make_tuple(16, 8, highbd_sad16x8_sse2, 10), 890 make_tuple(8, 16, highbd_sad8x16_sse2, 10), 891 make_tuple(8, 8, highbd_sad8x8_sse2, 10), 892 make_tuple(8, 4, highbd_sad8x4_sse2, 10), 893 make_tuple(64, 64, highbd_sad64x64_sse2, 12), 894 make_tuple(64, 32, highbd_sad64x32_sse2, 12), 895 make_tuple(32, 64, highbd_sad32x64_sse2, 12), 896 make_tuple(32, 32, highbd_sad32x32_sse2, 12), 897 make_tuple(32, 16, highbd_sad32x16_sse2, 12), 898 make_tuple(16, 32, highbd_sad16x32_sse2, 12), 899 make_tuple(16, 16, highbd_sad16x16_sse2, 12), 900 make_tuple(16, 8, highbd_sad16x8_sse2, 12), 901 make_tuple(8, 16, highbd_sad8x16_sse2, 12), 902 make_tuple(8, 8, highbd_sad8x8_sse2, 12), 903 make_tuple(8, 4, highbd_sad8x4_sse2, 12), 904 #endif // CONFIG_VP9_HIGHBITDEPTH 905 }; 906 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); 907 908 const SadMxNAvgFunc sad64x64_avg_sse2 = vpx_sad64x64_avg_sse2; 909 const SadMxNAvgFunc sad64x32_avg_sse2 = vpx_sad64x32_avg_sse2; 910 const SadMxNAvgFunc sad32x64_avg_sse2 = vpx_sad32x64_avg_sse2; 911 const SadMxNAvgFunc sad32x32_avg_sse2 = vpx_sad32x32_avg_sse2; 912 const SadMxNAvgFunc sad32x16_avg_sse2 = vpx_sad32x16_avg_sse2; 913 const SadMxNAvgFunc sad16x32_avg_sse2 = vpx_sad16x32_avg_sse2; 914 const SadMxNAvgFunc sad16x16_avg_sse2 = vpx_sad16x16_avg_sse2; 915 const SadMxNAvgFunc sad16x8_avg_sse2 = vpx_sad16x8_avg_sse2; 916 const SadMxNAvgFunc sad8x16_avg_sse2 = vpx_sad8x16_avg_sse2; 917 const SadMxNAvgFunc sad8x8_avg_sse2 = vpx_sad8x8_avg_sse2; 918 const SadMxNAvgFunc sad8x4_avg_sse2 = vpx_sad8x4_avg_sse2; 919 #if CONFIG_VP9_HIGHBITDEPTH 920 const SadMxNAvgFunc highbd_sad64x64_avg_sse2 = vpx_highbd_sad64x64_avg_sse2; 921 const SadMxNAvgFunc highbd_sad64x32_avg_sse2 = vpx_highbd_sad64x32_avg_sse2; 922 const SadMxNAvgFunc highbd_sad32x64_avg_sse2 = vpx_highbd_sad32x64_avg_sse2; 923 const SadMxNAvgFunc highbd_sad32x32_avg_sse2 = vpx_highbd_sad32x32_avg_sse2; 924 const SadMxNAvgFunc highbd_sad32x16_avg_sse2 = vpx_highbd_sad32x16_avg_sse2; 925 const SadMxNAvgFunc highbd_sad16x32_avg_sse2 = vpx_highbd_sad16x32_avg_sse2; 926 const SadMxNAvgFunc highbd_sad16x16_avg_sse2 = vpx_highbd_sad16x16_avg_sse2; 927 const SadMxNAvgFunc highbd_sad16x8_avg_sse2 = vpx_highbd_sad16x8_avg_sse2; 928 const SadMxNAvgFunc highbd_sad8x16_avg_sse2 = vpx_highbd_sad8x16_avg_sse2; 929 const SadMxNAvgFunc highbd_sad8x8_avg_sse2 = vpx_highbd_sad8x8_avg_sse2; 930 const SadMxNAvgFunc highbd_sad8x4_avg_sse2 = vpx_highbd_sad8x4_avg_sse2; 931 #endif // CONFIG_VP9_HIGHBITDEPTH 932 const SadMxNAvgParam avg_sse2_tests[] = { 933 make_tuple(64, 64, sad64x64_avg_sse2, -1), 934 make_tuple(64, 32, sad64x32_avg_sse2, -1), 935 make_tuple(32, 64, sad32x64_avg_sse2, -1), 936 make_tuple(32, 32, sad32x32_avg_sse2, -1), 937 make_tuple(32, 16, sad32x16_avg_sse2, -1), 938 make_tuple(16, 32, sad16x32_avg_sse2, -1), 939 make_tuple(16, 16, sad16x16_avg_sse2, -1), 940 make_tuple(16, 8, sad16x8_avg_sse2, -1), 941 make_tuple(8, 16, sad8x16_avg_sse2, -1), 942 make_tuple(8, 8, sad8x8_avg_sse2, -1), 943 make_tuple(8, 4, sad8x4_avg_sse2, -1), 944 #if CONFIG_VP9_HIGHBITDEPTH 945 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 8), 946 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 8), 947 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 8), 948 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 8), 949 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 8), 950 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 8), 951 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 8), 952 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 8), 953 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 8), 954 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 8), 955 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 8), 956 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 10), 957 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 10), 958 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 10), 959 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 10), 960 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 10), 961 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 10), 962 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 10), 963 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 10), 964 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 10), 965 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 10), 966 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 10), 967 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 12), 968 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 12), 969 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 12), 970 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 12), 971 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 12), 972 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 12), 973 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 12), 974 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 12), 975 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 12), 976 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 12), 977 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 12), 978 #endif // CONFIG_VP9_HIGHBITDEPTH 979 }; 980 INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests)); 981 982 const SadMxNx4Func sad64x64x4d_sse2 = vpx_sad64x64x4d_sse2; 983 const SadMxNx4Func sad64x32x4d_sse2 = vpx_sad64x32x4d_sse2; 984 const SadMxNx4Func sad32x64x4d_sse2 = vpx_sad32x64x4d_sse2; 985 const SadMxNx4Func sad32x32x4d_sse2 = vpx_sad32x32x4d_sse2; 986 const SadMxNx4Func sad32x16x4d_sse2 = vpx_sad32x16x4d_sse2; 987 const SadMxNx4Func sad16x32x4d_sse2 = vpx_sad16x32x4d_sse2; 988 const SadMxNx4Func sad16x16x4d_sse2 = vpx_sad16x16x4d_sse2; 989 const SadMxNx4Func sad16x8x4d_sse2 = vpx_sad16x8x4d_sse2; 990 const SadMxNx4Func sad8x16x4d_sse2 = vpx_sad8x16x4d_sse2; 991 const SadMxNx4Func sad8x8x4d_sse2 = vpx_sad8x8x4d_sse2; 992 const SadMxNx4Func sad8x4x4d_sse2 = vpx_sad8x4x4d_sse2; 993 #if CONFIG_VP9_HIGHBITDEPTH 994 const SadMxNx4Func highbd_sad64x64x4d_sse2 = vpx_highbd_sad64x64x4d_sse2; 995 const SadMxNx4Func highbd_sad64x32x4d_sse2 = vpx_highbd_sad64x32x4d_sse2; 996 const SadMxNx4Func highbd_sad32x64x4d_sse2 = vpx_highbd_sad32x64x4d_sse2; 997 const SadMxNx4Func highbd_sad32x32x4d_sse2 = vpx_highbd_sad32x32x4d_sse2; 998 const SadMxNx4Func highbd_sad32x16x4d_sse2 = vpx_highbd_sad32x16x4d_sse2; 999 const SadMxNx4Func highbd_sad16x32x4d_sse2 = vpx_highbd_sad16x32x4d_sse2; 1000 const SadMxNx4Func highbd_sad16x16x4d_sse2 = vpx_highbd_sad16x16x4d_sse2; 1001 const SadMxNx4Func highbd_sad16x8x4d_sse2 = vpx_highbd_sad16x8x4d_sse2; 1002 const SadMxNx4Func highbd_sad8x16x4d_sse2 = vpx_highbd_sad8x16x4d_sse2; 1003 const SadMxNx4Func highbd_sad8x8x4d_sse2 = vpx_highbd_sad8x8x4d_sse2; 1004 const SadMxNx4Func highbd_sad8x4x4d_sse2 = vpx_highbd_sad8x4x4d_sse2; 1005 const SadMxNx4Func highbd_sad4x8x4d_sse2 = vpx_highbd_sad4x8x4d_sse2; 1006 const SadMxNx4Func highbd_sad4x4x4d_sse2 = vpx_highbd_sad4x4x4d_sse2; 1007 #endif // CONFIG_VP9_HIGHBITDEPTH 1008 const SadMxNx4Param x4d_sse2_tests[] = { 1009 make_tuple(64, 64, sad64x64x4d_sse2, -1), 1010 make_tuple(64, 32, sad64x32x4d_sse2, -1), 1011 make_tuple(32, 64, sad32x64x4d_sse2, -1), 1012 make_tuple(32, 32, sad32x32x4d_sse2, -1), 1013 make_tuple(32, 16, sad32x16x4d_sse2, -1), 1014 make_tuple(16, 32, sad16x32x4d_sse2, -1), 1015 make_tuple(16, 16, sad16x16x4d_sse2, -1), 1016 make_tuple(16, 8, sad16x8x4d_sse2, -1), 1017 make_tuple(8, 16, sad8x16x4d_sse2, -1), 1018 make_tuple(8, 8, sad8x8x4d_sse2, -1), 1019 make_tuple(8, 4, sad8x4x4d_sse2, -1), 1020 #if CONFIG_VP9_HIGHBITDEPTH 1021 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 8), 1022 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 8), 1023 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 8), 1024 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 8), 1025 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 8), 1026 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 8), 1027 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 8), 1028 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 8), 1029 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 8), 1030 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 8), 1031 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 8), 1032 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 8), 1033 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 8), 1034 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 10), 1035 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 10), 1036 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 10), 1037 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 10), 1038 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 10), 1039 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 10), 1040 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 10), 1041 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 10), 1042 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 10), 1043 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 10), 1044 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 10), 1045 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 10), 1046 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 10), 1047 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 12), 1048 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 12), 1049 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 12), 1050 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 12), 1051 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 12), 1052 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 12), 1053 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 12), 1054 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 12), 1055 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 12), 1056 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 12), 1057 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 12), 1058 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 12), 1059 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 12), 1060 #endif // CONFIG_VP9_HIGHBITDEPTH 1061 }; 1062 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests)); 1063 #endif // CONFIG_USE_X86INC 1064 #endif // HAVE_SSE2 1065 1066 #if HAVE_SSE3 1067 // Only functions are x3, which do not have tests. 1068 #endif // HAVE_SSE3 1069 1070 #if HAVE_SSSE3 1071 // Only functions are x3, which do not have tests. 1072 #endif // HAVE_SSSE3 1073 1074 #if HAVE_SSE4_1 1075 // Only functions are x8, which do not have tests. 1076 #endif // HAVE_SSE4_1 1077 1078 #if HAVE_AVX2 1079 const SadMxNFunc sad64x64_avx2 = vpx_sad64x64_avx2; 1080 const SadMxNFunc sad64x32_avx2 = vpx_sad64x32_avx2; 1081 const SadMxNFunc sad32x64_avx2 = vpx_sad32x64_avx2; 1082 const SadMxNFunc sad32x32_avx2 = vpx_sad32x32_avx2; 1083 const SadMxNFunc sad32x16_avx2 = vpx_sad32x16_avx2; 1084 const SadMxNParam avx2_tests[] = { 1085 make_tuple(64, 64, sad64x64_avx2, -1), 1086 make_tuple(64, 32, sad64x32_avx2, -1), 1087 make_tuple(32, 64, sad32x64_avx2, -1), 1088 make_tuple(32, 32, sad32x32_avx2, -1), 1089 make_tuple(32, 16, sad32x16_avx2, -1), 1090 }; 1091 INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests)); 1092 1093 const SadMxNAvgFunc sad64x64_avg_avx2 = vpx_sad64x64_avg_avx2; 1094 const SadMxNAvgFunc sad64x32_avg_avx2 = vpx_sad64x32_avg_avx2; 1095 const SadMxNAvgFunc sad32x64_avg_avx2 = vpx_sad32x64_avg_avx2; 1096 const SadMxNAvgFunc sad32x32_avg_avx2 = vpx_sad32x32_avg_avx2; 1097 const SadMxNAvgFunc sad32x16_avg_avx2 = vpx_sad32x16_avg_avx2; 1098 const SadMxNAvgParam avg_avx2_tests[] = { 1099 make_tuple(64, 64, sad64x64_avg_avx2, -1), 1100 make_tuple(64, 32, sad64x32_avg_avx2, -1), 1101 make_tuple(32, 64, sad32x64_avg_avx2, -1), 1102 make_tuple(32, 32, sad32x32_avg_avx2, -1), 1103 make_tuple(32, 16, sad32x16_avg_avx2, -1), 1104 }; 1105 INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests)); 1106 1107 const SadMxNx4Func sad64x64x4d_avx2 = vpx_sad64x64x4d_avx2; 1108 const SadMxNx4Func sad32x32x4d_avx2 = vpx_sad32x32x4d_avx2; 1109 const SadMxNx4Param x4d_avx2_tests[] = { 1110 make_tuple(64, 64, sad64x64x4d_avx2, -1), 1111 make_tuple(32, 32, sad32x32x4d_avx2, -1), 1112 }; 1113 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests)); 1114 #endif // HAVE_AVX2 1115 1116 //------------------------------------------------------------------------------ 1117 // MIPS functions 1118 #if HAVE_MSA 1119 const SadMxNFunc sad64x64_msa = vpx_sad64x64_msa; 1120 const SadMxNFunc sad64x32_msa = vpx_sad64x32_msa; 1121 const SadMxNFunc sad32x64_msa = vpx_sad32x64_msa; 1122 const SadMxNFunc sad32x32_msa = vpx_sad32x32_msa; 1123 const SadMxNFunc sad32x16_msa = vpx_sad32x16_msa; 1124 const SadMxNFunc sad16x32_msa = vpx_sad16x32_msa; 1125 const SadMxNFunc sad16x16_msa = vpx_sad16x16_msa; 1126 const SadMxNFunc sad16x8_msa = vpx_sad16x8_msa; 1127 const SadMxNFunc sad8x16_msa = vpx_sad8x16_msa; 1128 const SadMxNFunc sad8x8_msa = vpx_sad8x8_msa; 1129 const SadMxNFunc sad8x4_msa = vpx_sad8x4_msa; 1130 const SadMxNFunc sad4x8_msa = vpx_sad4x8_msa; 1131 const SadMxNFunc sad4x4_msa = vpx_sad4x4_msa; 1132 const SadMxNParam msa_tests[] = { 1133 make_tuple(64, 64, sad64x64_msa, -1), 1134 make_tuple(64, 32, sad64x32_msa, -1), 1135 make_tuple(32, 64, sad32x64_msa, -1), 1136 make_tuple(32, 32, sad32x32_msa, -1), 1137 make_tuple(32, 16, sad32x16_msa, -1), 1138 make_tuple(16, 32, sad16x32_msa, -1), 1139 make_tuple(16, 16, sad16x16_msa, -1), 1140 make_tuple(16, 8, sad16x8_msa, -1), 1141 make_tuple(8, 16, sad8x16_msa, -1), 1142 make_tuple(8, 8, sad8x8_msa, -1), 1143 make_tuple(8, 4, sad8x4_msa, -1), 1144 make_tuple(4, 8, sad4x8_msa, -1), 1145 make_tuple(4, 4, sad4x4_msa, -1), 1146 }; 1147 INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests)); 1148 1149 const SadMxNAvgFunc sad64x64_avg_msa = vpx_sad64x64_avg_msa; 1150 const SadMxNAvgFunc sad64x32_avg_msa = vpx_sad64x32_avg_msa; 1151 const SadMxNAvgFunc sad32x64_avg_msa = vpx_sad32x64_avg_msa; 1152 const SadMxNAvgFunc sad32x32_avg_msa = vpx_sad32x32_avg_msa; 1153 const SadMxNAvgFunc sad32x16_avg_msa = vpx_sad32x16_avg_msa; 1154 const SadMxNAvgFunc sad16x32_avg_msa = vpx_sad16x32_avg_msa; 1155 const SadMxNAvgFunc sad16x16_avg_msa = vpx_sad16x16_avg_msa; 1156 const SadMxNAvgFunc sad16x8_avg_msa = vpx_sad16x8_avg_msa; 1157 const SadMxNAvgFunc sad8x16_avg_msa = vpx_sad8x16_avg_msa; 1158 const SadMxNAvgFunc sad8x8_avg_msa = vpx_sad8x8_avg_msa; 1159 const SadMxNAvgFunc sad8x4_avg_msa = vpx_sad8x4_avg_msa; 1160 const SadMxNAvgFunc sad4x8_avg_msa = vpx_sad4x8_avg_msa; 1161 const SadMxNAvgFunc sad4x4_avg_msa = vpx_sad4x4_avg_msa; 1162 const SadMxNAvgParam avg_msa_tests[] = { 1163 make_tuple(64, 64, sad64x64_avg_msa, -1), 1164 make_tuple(64, 32, sad64x32_avg_msa, -1), 1165 make_tuple(32, 64, sad32x64_avg_msa, -1), 1166 make_tuple(32, 32, sad32x32_avg_msa, -1), 1167 make_tuple(32, 16, sad32x16_avg_msa, -1), 1168 make_tuple(16, 32, sad16x32_avg_msa, -1), 1169 make_tuple(16, 16, sad16x16_avg_msa, -1), 1170 make_tuple(16, 8, sad16x8_avg_msa, -1), 1171 make_tuple(8, 16, sad8x16_avg_msa, -1), 1172 make_tuple(8, 8, sad8x8_avg_msa, -1), 1173 make_tuple(8, 4, sad8x4_avg_msa, -1), 1174 make_tuple(4, 8, sad4x8_avg_msa, -1), 1175 make_tuple(4, 4, sad4x4_avg_msa, -1), 1176 }; 1177 INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests)); 1178 1179 const SadMxNx4Func sad64x64x4d_msa = vpx_sad64x64x4d_msa; 1180 const SadMxNx4Func sad64x32x4d_msa = vpx_sad64x32x4d_msa; 1181 const SadMxNx4Func sad32x64x4d_msa = vpx_sad32x64x4d_msa; 1182 const SadMxNx4Func sad32x32x4d_msa = vpx_sad32x32x4d_msa; 1183 const SadMxNx4Func sad32x16x4d_msa = vpx_sad32x16x4d_msa; 1184 const SadMxNx4Func sad16x32x4d_msa = vpx_sad16x32x4d_msa; 1185 const SadMxNx4Func sad16x16x4d_msa = vpx_sad16x16x4d_msa; 1186 const SadMxNx4Func sad16x8x4d_msa = vpx_sad16x8x4d_msa; 1187 const SadMxNx4Func sad8x16x4d_msa = vpx_sad8x16x4d_msa; 1188 const SadMxNx4Func sad8x8x4d_msa = vpx_sad8x8x4d_msa; 1189 const SadMxNx4Func sad8x4x4d_msa = vpx_sad8x4x4d_msa; 1190 const SadMxNx4Func sad4x8x4d_msa = vpx_sad4x8x4d_msa; 1191 const SadMxNx4Func sad4x4x4d_msa = vpx_sad4x4x4d_msa; 1192 const SadMxNx4Param x4d_msa_tests[] = { 1193 make_tuple(64, 64, sad64x64x4d_msa, -1), 1194 make_tuple(64, 32, sad64x32x4d_msa, -1), 1195 make_tuple(32, 64, sad32x64x4d_msa, -1), 1196 make_tuple(32, 32, sad32x32x4d_msa, -1), 1197 make_tuple(32, 16, sad32x16x4d_msa, -1), 1198 make_tuple(16, 32, sad16x32x4d_msa, -1), 1199 make_tuple(16, 16, sad16x16x4d_msa, -1), 1200 make_tuple(16, 8, sad16x8x4d_msa, -1), 1201 make_tuple(8, 16, sad8x16x4d_msa, -1), 1202 make_tuple(8, 8, sad8x8x4d_msa, -1), 1203 make_tuple(8, 4, sad8x4x4d_msa, -1), 1204 make_tuple(4, 8, sad4x8x4d_msa, -1), 1205 make_tuple(4, 4, sad4x4x4d_msa, -1), 1206 }; 1207 INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests)); 1208 #endif // HAVE_MSA 1209 1210 } // namespace 1211
