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