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 28typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, 29 int src_stride, 30 const uint8_t *ref_ptr, 31 int ref_stride); 32typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam; 33 34typedef 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); 39typedef std::tr1::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam; 40 41typedef 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); 46typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param; 47 48using libvpx_test::ACMRandom; 49 50namespace { 51class 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 242class 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 270class 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 294class 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 319uint8_t *SADTestBase::source_data_ = NULL; 320uint8_t *SADTestBase::reference_data_ = NULL; 321uint8_t *SADTestBase::second_pred_ = NULL; 322uint8_t *SADTestBase::source_data8_ = NULL; 323uint8_t *SADTestBase::reference_data8_ = NULL; 324uint8_t *SADTestBase::second_pred8_ = NULL; 325uint16_t *SADTestBase::source_data16_ = NULL; 326uint16_t *SADTestBase::reference_data16_ = NULL; 327uint16_t *SADTestBase::second_pred16_ = NULL; 328 329TEST_P(SADTest, MaxRef) { 330 FillConstant(source_data_, source_stride_, 0); 331 FillConstant(reference_data_, reference_stride_, mask_); 332 CheckSAD(); 333} 334 335TEST_P(SADTest, MaxSrc) { 336 FillConstant(source_data_, source_stride_, mask_); 337 FillConstant(reference_data_, reference_stride_, 0); 338 CheckSAD(); 339} 340 341TEST_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 350TEST_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 361TEST_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 370TEST_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} 376TEST_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 383TEST_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 393TEST_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 405TEST_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 415TEST_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 424TEST_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 433TEST_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 445TEST_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 459TEST_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 471TEST_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 483using std::tr1::make_tuple; 484 485//------------------------------------------------------------------------------ 486// C functions 487const SadMxNFunc sad64x64_c = vpx_sad64x64_c; 488const SadMxNFunc sad64x32_c = vpx_sad64x32_c; 489const SadMxNFunc sad32x64_c = vpx_sad32x64_c; 490const SadMxNFunc sad32x32_c = vpx_sad32x32_c; 491const SadMxNFunc sad32x16_c = vpx_sad32x16_c; 492const SadMxNFunc sad16x32_c = vpx_sad16x32_c; 493const SadMxNFunc sad16x16_c = vpx_sad16x16_c; 494const SadMxNFunc sad16x8_c = vpx_sad16x8_c; 495const SadMxNFunc sad8x16_c = vpx_sad8x16_c; 496const SadMxNFunc sad8x8_c = vpx_sad8x8_c; 497const SadMxNFunc sad8x4_c = vpx_sad8x4_c; 498const SadMxNFunc sad4x8_c = vpx_sad4x8_c; 499const SadMxNFunc sad4x4_c = vpx_sad4x4_c; 500#if CONFIG_VP9_HIGHBITDEPTH 501const SadMxNFunc highbd_sad64x64_c = vpx_highbd_sad64x64_c; 502const SadMxNFunc highbd_sad64x32_c = vpx_highbd_sad64x32_c; 503const SadMxNFunc highbd_sad32x64_c = vpx_highbd_sad32x64_c; 504const SadMxNFunc highbd_sad32x32_c = vpx_highbd_sad32x32_c; 505const SadMxNFunc highbd_sad32x16_c = vpx_highbd_sad32x16_c; 506const SadMxNFunc highbd_sad16x32_c = vpx_highbd_sad16x32_c; 507const SadMxNFunc highbd_sad16x16_c = vpx_highbd_sad16x16_c; 508const SadMxNFunc highbd_sad16x8_c = vpx_highbd_sad16x8_c; 509const SadMxNFunc highbd_sad8x16_c = vpx_highbd_sad8x16_c; 510const SadMxNFunc highbd_sad8x8_c = vpx_highbd_sad8x8_c; 511const SadMxNFunc highbd_sad8x4_c = vpx_highbd_sad8x4_c; 512const SadMxNFunc highbd_sad4x8_c = vpx_highbd_sad4x8_c; 513const SadMxNFunc highbd_sad4x4_c = vpx_highbd_sad4x4_c; 514#endif // CONFIG_VP9_HIGHBITDEPTH 515const 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}; 571INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); 572 573const SadMxNAvgFunc sad64x64_avg_c = vpx_sad64x64_avg_c; 574const SadMxNAvgFunc sad64x32_avg_c = vpx_sad64x32_avg_c; 575const SadMxNAvgFunc sad32x64_avg_c = vpx_sad32x64_avg_c; 576const SadMxNAvgFunc sad32x32_avg_c = vpx_sad32x32_avg_c; 577const SadMxNAvgFunc sad32x16_avg_c = vpx_sad32x16_avg_c; 578const SadMxNAvgFunc sad16x32_avg_c = vpx_sad16x32_avg_c; 579const SadMxNAvgFunc sad16x16_avg_c = vpx_sad16x16_avg_c; 580const SadMxNAvgFunc sad16x8_avg_c = vpx_sad16x8_avg_c; 581const SadMxNAvgFunc sad8x16_avg_c = vpx_sad8x16_avg_c; 582const SadMxNAvgFunc sad8x8_avg_c = vpx_sad8x8_avg_c; 583const SadMxNAvgFunc sad8x4_avg_c = vpx_sad8x4_avg_c; 584const SadMxNAvgFunc sad4x8_avg_c = vpx_sad4x8_avg_c; 585const SadMxNAvgFunc sad4x4_avg_c = vpx_sad4x4_avg_c; 586#if CONFIG_VP9_HIGHBITDEPTH 587const SadMxNAvgFunc highbd_sad64x64_avg_c = vpx_highbd_sad64x64_avg_c; 588const SadMxNAvgFunc highbd_sad64x32_avg_c = vpx_highbd_sad64x32_avg_c; 589const SadMxNAvgFunc highbd_sad32x64_avg_c = vpx_highbd_sad32x64_avg_c; 590const SadMxNAvgFunc highbd_sad32x32_avg_c = vpx_highbd_sad32x32_avg_c; 591const SadMxNAvgFunc highbd_sad32x16_avg_c = vpx_highbd_sad32x16_avg_c; 592const SadMxNAvgFunc highbd_sad16x32_avg_c = vpx_highbd_sad16x32_avg_c; 593const SadMxNAvgFunc highbd_sad16x16_avg_c = vpx_highbd_sad16x16_avg_c; 594const SadMxNAvgFunc highbd_sad16x8_avg_c = vpx_highbd_sad16x8_avg_c; 595const SadMxNAvgFunc highbd_sad8x16_avg_c = vpx_highbd_sad8x16_avg_c; 596const SadMxNAvgFunc highbd_sad8x8_avg_c = vpx_highbd_sad8x8_avg_c; 597const SadMxNAvgFunc highbd_sad8x4_avg_c = vpx_highbd_sad8x4_avg_c; 598const SadMxNAvgFunc highbd_sad4x8_avg_c = vpx_highbd_sad4x8_avg_c; 599const SadMxNAvgFunc highbd_sad4x4_avg_c = vpx_highbd_sad4x4_avg_c; 600#endif // CONFIG_VP9_HIGHBITDEPTH 601const 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}; 657INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests)); 658 659const SadMxNx4Func sad64x64x4d_c = vpx_sad64x64x4d_c; 660const SadMxNx4Func sad64x32x4d_c = vpx_sad64x32x4d_c; 661const SadMxNx4Func sad32x64x4d_c = vpx_sad32x64x4d_c; 662const SadMxNx4Func sad32x32x4d_c = vpx_sad32x32x4d_c; 663const SadMxNx4Func sad32x16x4d_c = vpx_sad32x16x4d_c; 664const SadMxNx4Func sad16x32x4d_c = vpx_sad16x32x4d_c; 665const SadMxNx4Func sad16x16x4d_c = vpx_sad16x16x4d_c; 666const SadMxNx4Func sad16x8x4d_c = vpx_sad16x8x4d_c; 667const SadMxNx4Func sad8x16x4d_c = vpx_sad8x16x4d_c; 668const SadMxNx4Func sad8x8x4d_c = vpx_sad8x8x4d_c; 669const SadMxNx4Func sad8x4x4d_c = vpx_sad8x4x4d_c; 670const SadMxNx4Func sad4x8x4d_c = vpx_sad4x8x4d_c; 671const SadMxNx4Func sad4x4x4d_c = vpx_sad4x4x4d_c; 672#if CONFIG_VP9_HIGHBITDEPTH 673const SadMxNx4Func highbd_sad64x64x4d_c = vpx_highbd_sad64x64x4d_c; 674const SadMxNx4Func highbd_sad64x32x4d_c = vpx_highbd_sad64x32x4d_c; 675const SadMxNx4Func highbd_sad32x64x4d_c = vpx_highbd_sad32x64x4d_c; 676const SadMxNx4Func highbd_sad32x32x4d_c = vpx_highbd_sad32x32x4d_c; 677const SadMxNx4Func highbd_sad32x16x4d_c = vpx_highbd_sad32x16x4d_c; 678const SadMxNx4Func highbd_sad16x32x4d_c = vpx_highbd_sad16x32x4d_c; 679const SadMxNx4Func highbd_sad16x16x4d_c = vpx_highbd_sad16x16x4d_c; 680const SadMxNx4Func highbd_sad16x8x4d_c = vpx_highbd_sad16x8x4d_c; 681const SadMxNx4Func highbd_sad8x16x4d_c = vpx_highbd_sad8x16x4d_c; 682const SadMxNx4Func highbd_sad8x8x4d_c = vpx_highbd_sad8x8x4d_c; 683const SadMxNx4Func highbd_sad8x4x4d_c = vpx_highbd_sad8x4x4d_c; 684const SadMxNx4Func highbd_sad4x8x4d_c = vpx_highbd_sad4x8x4d_c; 685const SadMxNx4Func highbd_sad4x4x4d_c = vpx_highbd_sad4x4x4d_c; 686#endif // CONFIG_VP9_HIGHBITDEPTH 687const 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}; 743INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests)); 744 745//------------------------------------------------------------------------------ 746// ARM functions 747#if HAVE_MEDIA 748const SadMxNFunc sad16x16_media = vpx_sad16x16_media; 749const SadMxNParam media_tests[] = { 750 make_tuple(16, 16, sad16x16_media, -1), 751}; 752INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests)); 753#endif // HAVE_MEDIA 754 755#if HAVE_NEON 756const SadMxNFunc sad64x64_neon = vpx_sad64x64_neon; 757const SadMxNFunc sad32x32_neon = vpx_sad32x32_neon; 758const SadMxNFunc sad16x16_neon = vpx_sad16x16_neon; 759const SadMxNFunc sad16x8_neon = vpx_sad16x8_neon; 760const SadMxNFunc sad8x16_neon = vpx_sad8x16_neon; 761const SadMxNFunc sad8x8_neon = vpx_sad8x8_neon; 762const SadMxNFunc sad4x4_neon = vpx_sad4x4_neon; 763 764const 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}; 773INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests)); 774 775const SadMxNx4Func sad64x64x4d_neon = vpx_sad64x64x4d_neon; 776const SadMxNx4Func sad32x32x4d_neon = vpx_sad32x32x4d_neon; 777const SadMxNx4Func sad16x16x4d_neon = vpx_sad16x16x4d_neon; 778const 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}; 783INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests)); 784#endif // HAVE_NEON 785 786//------------------------------------------------------------------------------ 787// x86 functions 788#if HAVE_MMX 789const SadMxNFunc sad16x16_mmx = vpx_sad16x16_mmx; 790const SadMxNFunc sad16x8_mmx = vpx_sad16x8_mmx; 791const SadMxNFunc sad8x16_mmx = vpx_sad8x16_mmx; 792const SadMxNFunc sad8x8_mmx = vpx_sad8x8_mmx; 793const SadMxNFunc sad4x4_mmx = vpx_sad4x4_mmx; 794const 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}; 801INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); 802#endif // HAVE_MMX 803 804#if HAVE_SSE 805#if CONFIG_USE_X86INC 806const SadMxNFunc sad4x8_sse = vpx_sad4x8_sse; 807const SadMxNFunc sad4x4_sse = vpx_sad4x4_sse; 808const SadMxNParam sse_tests[] = { 809 make_tuple(4, 8, sad4x8_sse, -1), 810 make_tuple(4, 4, sad4x4_sse, -1), 811}; 812INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::ValuesIn(sse_tests)); 813 814const SadMxNAvgFunc sad4x8_avg_sse = vpx_sad4x8_avg_sse; 815const SadMxNAvgFunc sad4x4_avg_sse = vpx_sad4x4_avg_sse; 816const SadMxNAvgParam avg_sse_tests[] = { 817 make_tuple(4, 8, sad4x8_avg_sse, -1), 818 make_tuple(4, 4, sad4x4_avg_sse, -1), 819}; 820INSTANTIATE_TEST_CASE_P(SSE, SADavgTest, ::testing::ValuesIn(avg_sse_tests)); 821 822const SadMxNx4Func sad4x8x4d_sse = vpx_sad4x8x4d_sse; 823const SadMxNx4Func sad4x4x4d_sse = vpx_sad4x4x4d_sse; 824const SadMxNx4Param x4d_sse_tests[] = { 825 make_tuple(4, 8, sad4x8x4d_sse, -1), 826 make_tuple(4, 4, sad4x4x4d_sse, -1), 827}; 828INSTANTIATE_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 834const SadMxNFunc sad64x64_sse2 = vpx_sad64x64_sse2; 835const SadMxNFunc sad64x32_sse2 = vpx_sad64x32_sse2; 836const SadMxNFunc sad32x64_sse2 = vpx_sad32x64_sse2; 837const SadMxNFunc sad32x32_sse2 = vpx_sad32x32_sse2; 838const SadMxNFunc sad32x16_sse2 = vpx_sad32x16_sse2; 839const SadMxNFunc sad16x32_sse2 = vpx_sad16x32_sse2; 840const SadMxNFunc sad16x16_sse2 = vpx_sad16x16_sse2; 841const SadMxNFunc sad16x8_sse2 = vpx_sad16x8_sse2; 842const SadMxNFunc sad8x16_sse2 = vpx_sad8x16_sse2; 843const SadMxNFunc sad8x8_sse2 = vpx_sad8x8_sse2; 844const SadMxNFunc sad8x4_sse2 = vpx_sad8x4_sse2; 845#if CONFIG_VP9_HIGHBITDEPTH 846const SadMxNFunc highbd_sad64x64_sse2 = vpx_highbd_sad64x64_sse2; 847const SadMxNFunc highbd_sad64x32_sse2 = vpx_highbd_sad64x32_sse2; 848const SadMxNFunc highbd_sad32x64_sse2 = vpx_highbd_sad32x64_sse2; 849const SadMxNFunc highbd_sad32x32_sse2 = vpx_highbd_sad32x32_sse2; 850const SadMxNFunc highbd_sad32x16_sse2 = vpx_highbd_sad32x16_sse2; 851const SadMxNFunc highbd_sad16x32_sse2 = vpx_highbd_sad16x32_sse2; 852const SadMxNFunc highbd_sad16x16_sse2 = vpx_highbd_sad16x16_sse2; 853const SadMxNFunc highbd_sad16x8_sse2 = vpx_highbd_sad16x8_sse2; 854const SadMxNFunc highbd_sad8x16_sse2 = vpx_highbd_sad8x16_sse2; 855const SadMxNFunc highbd_sad8x8_sse2 = vpx_highbd_sad8x8_sse2; 856const SadMxNFunc highbd_sad8x4_sse2 = vpx_highbd_sad8x4_sse2; 857#endif // CONFIG_VP9_HIGHBITDEPTH 858const 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}; 906INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); 907 908const SadMxNAvgFunc sad64x64_avg_sse2 = vpx_sad64x64_avg_sse2; 909const SadMxNAvgFunc sad64x32_avg_sse2 = vpx_sad64x32_avg_sse2; 910const SadMxNAvgFunc sad32x64_avg_sse2 = vpx_sad32x64_avg_sse2; 911const SadMxNAvgFunc sad32x32_avg_sse2 = vpx_sad32x32_avg_sse2; 912const SadMxNAvgFunc sad32x16_avg_sse2 = vpx_sad32x16_avg_sse2; 913const SadMxNAvgFunc sad16x32_avg_sse2 = vpx_sad16x32_avg_sse2; 914const SadMxNAvgFunc sad16x16_avg_sse2 = vpx_sad16x16_avg_sse2; 915const SadMxNAvgFunc sad16x8_avg_sse2 = vpx_sad16x8_avg_sse2; 916const SadMxNAvgFunc sad8x16_avg_sse2 = vpx_sad8x16_avg_sse2; 917const SadMxNAvgFunc sad8x8_avg_sse2 = vpx_sad8x8_avg_sse2; 918const SadMxNAvgFunc sad8x4_avg_sse2 = vpx_sad8x4_avg_sse2; 919#if CONFIG_VP9_HIGHBITDEPTH 920const SadMxNAvgFunc highbd_sad64x64_avg_sse2 = vpx_highbd_sad64x64_avg_sse2; 921const SadMxNAvgFunc highbd_sad64x32_avg_sse2 = vpx_highbd_sad64x32_avg_sse2; 922const SadMxNAvgFunc highbd_sad32x64_avg_sse2 = vpx_highbd_sad32x64_avg_sse2; 923const SadMxNAvgFunc highbd_sad32x32_avg_sse2 = vpx_highbd_sad32x32_avg_sse2; 924const SadMxNAvgFunc highbd_sad32x16_avg_sse2 = vpx_highbd_sad32x16_avg_sse2; 925const SadMxNAvgFunc highbd_sad16x32_avg_sse2 = vpx_highbd_sad16x32_avg_sse2; 926const SadMxNAvgFunc highbd_sad16x16_avg_sse2 = vpx_highbd_sad16x16_avg_sse2; 927const SadMxNAvgFunc highbd_sad16x8_avg_sse2 = vpx_highbd_sad16x8_avg_sse2; 928const SadMxNAvgFunc highbd_sad8x16_avg_sse2 = vpx_highbd_sad8x16_avg_sse2; 929const SadMxNAvgFunc highbd_sad8x8_avg_sse2 = vpx_highbd_sad8x8_avg_sse2; 930const SadMxNAvgFunc highbd_sad8x4_avg_sse2 = vpx_highbd_sad8x4_avg_sse2; 931#endif // CONFIG_VP9_HIGHBITDEPTH 932const 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}; 980INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests)); 981 982const SadMxNx4Func sad64x64x4d_sse2 = vpx_sad64x64x4d_sse2; 983const SadMxNx4Func sad64x32x4d_sse2 = vpx_sad64x32x4d_sse2; 984const SadMxNx4Func sad32x64x4d_sse2 = vpx_sad32x64x4d_sse2; 985const SadMxNx4Func sad32x32x4d_sse2 = vpx_sad32x32x4d_sse2; 986const SadMxNx4Func sad32x16x4d_sse2 = vpx_sad32x16x4d_sse2; 987const SadMxNx4Func sad16x32x4d_sse2 = vpx_sad16x32x4d_sse2; 988const SadMxNx4Func sad16x16x4d_sse2 = vpx_sad16x16x4d_sse2; 989const SadMxNx4Func sad16x8x4d_sse2 = vpx_sad16x8x4d_sse2; 990const SadMxNx4Func sad8x16x4d_sse2 = vpx_sad8x16x4d_sse2; 991const SadMxNx4Func sad8x8x4d_sse2 = vpx_sad8x8x4d_sse2; 992const SadMxNx4Func sad8x4x4d_sse2 = vpx_sad8x4x4d_sse2; 993#if CONFIG_VP9_HIGHBITDEPTH 994const SadMxNx4Func highbd_sad64x64x4d_sse2 = vpx_highbd_sad64x64x4d_sse2; 995const SadMxNx4Func highbd_sad64x32x4d_sse2 = vpx_highbd_sad64x32x4d_sse2; 996const SadMxNx4Func highbd_sad32x64x4d_sse2 = vpx_highbd_sad32x64x4d_sse2; 997const SadMxNx4Func highbd_sad32x32x4d_sse2 = vpx_highbd_sad32x32x4d_sse2; 998const SadMxNx4Func highbd_sad32x16x4d_sse2 = vpx_highbd_sad32x16x4d_sse2; 999const SadMxNx4Func highbd_sad16x32x4d_sse2 = vpx_highbd_sad16x32x4d_sse2; 1000const SadMxNx4Func highbd_sad16x16x4d_sse2 = vpx_highbd_sad16x16x4d_sse2; 1001const SadMxNx4Func highbd_sad16x8x4d_sse2 = vpx_highbd_sad16x8x4d_sse2; 1002const SadMxNx4Func highbd_sad8x16x4d_sse2 = vpx_highbd_sad8x16x4d_sse2; 1003const SadMxNx4Func highbd_sad8x8x4d_sse2 = vpx_highbd_sad8x8x4d_sse2; 1004const SadMxNx4Func highbd_sad8x4x4d_sse2 = vpx_highbd_sad8x4x4d_sse2; 1005const SadMxNx4Func highbd_sad4x8x4d_sse2 = vpx_highbd_sad4x8x4d_sse2; 1006const SadMxNx4Func highbd_sad4x4x4d_sse2 = vpx_highbd_sad4x4x4d_sse2; 1007#endif // CONFIG_VP9_HIGHBITDEPTH 1008const 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}; 1062INSTANTIATE_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 1079const SadMxNFunc sad64x64_avx2 = vpx_sad64x64_avx2; 1080const SadMxNFunc sad64x32_avx2 = vpx_sad64x32_avx2; 1081const SadMxNFunc sad32x64_avx2 = vpx_sad32x64_avx2; 1082const SadMxNFunc sad32x32_avx2 = vpx_sad32x32_avx2; 1083const SadMxNFunc sad32x16_avx2 = vpx_sad32x16_avx2; 1084const 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}; 1091INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests)); 1092 1093const SadMxNAvgFunc sad64x64_avg_avx2 = vpx_sad64x64_avg_avx2; 1094const SadMxNAvgFunc sad64x32_avg_avx2 = vpx_sad64x32_avg_avx2; 1095const SadMxNAvgFunc sad32x64_avg_avx2 = vpx_sad32x64_avg_avx2; 1096const SadMxNAvgFunc sad32x32_avg_avx2 = vpx_sad32x32_avg_avx2; 1097const SadMxNAvgFunc sad32x16_avg_avx2 = vpx_sad32x16_avg_avx2; 1098const 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}; 1105INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests)); 1106 1107const SadMxNx4Func sad64x64x4d_avx2 = vpx_sad64x64x4d_avx2; 1108const SadMxNx4Func sad32x32x4d_avx2 = vpx_sad32x32x4d_avx2; 1109const SadMxNx4Param x4d_avx2_tests[] = { 1110 make_tuple(64, 64, sad64x64x4d_avx2, -1), 1111 make_tuple(32, 32, sad32x32x4d_avx2, -1), 1112}; 1113INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests)); 1114#endif // HAVE_AVX2 1115 1116//------------------------------------------------------------------------------ 1117// MIPS functions 1118#if HAVE_MSA 1119const SadMxNFunc sad64x64_msa = vpx_sad64x64_msa; 1120const SadMxNFunc sad64x32_msa = vpx_sad64x32_msa; 1121const SadMxNFunc sad32x64_msa = vpx_sad32x64_msa; 1122const SadMxNFunc sad32x32_msa = vpx_sad32x32_msa; 1123const SadMxNFunc sad32x16_msa = vpx_sad32x16_msa; 1124const SadMxNFunc sad16x32_msa = vpx_sad16x32_msa; 1125const SadMxNFunc sad16x16_msa = vpx_sad16x16_msa; 1126const SadMxNFunc sad16x8_msa = vpx_sad16x8_msa; 1127const SadMxNFunc sad8x16_msa = vpx_sad8x16_msa; 1128const SadMxNFunc sad8x8_msa = vpx_sad8x8_msa; 1129const SadMxNFunc sad8x4_msa = vpx_sad8x4_msa; 1130const SadMxNFunc sad4x8_msa = vpx_sad4x8_msa; 1131const SadMxNFunc sad4x4_msa = vpx_sad4x4_msa; 1132const 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}; 1147INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests)); 1148 1149const SadMxNAvgFunc sad64x64_avg_msa = vpx_sad64x64_avg_msa; 1150const SadMxNAvgFunc sad64x32_avg_msa = vpx_sad64x32_avg_msa; 1151const SadMxNAvgFunc sad32x64_avg_msa = vpx_sad32x64_avg_msa; 1152const SadMxNAvgFunc sad32x32_avg_msa = vpx_sad32x32_avg_msa; 1153const SadMxNAvgFunc sad32x16_avg_msa = vpx_sad32x16_avg_msa; 1154const SadMxNAvgFunc sad16x32_avg_msa = vpx_sad16x32_avg_msa; 1155const SadMxNAvgFunc sad16x16_avg_msa = vpx_sad16x16_avg_msa; 1156const SadMxNAvgFunc sad16x8_avg_msa = vpx_sad16x8_avg_msa; 1157const SadMxNAvgFunc sad8x16_avg_msa = vpx_sad8x16_avg_msa; 1158const SadMxNAvgFunc sad8x8_avg_msa = vpx_sad8x8_avg_msa; 1159const SadMxNAvgFunc sad8x4_avg_msa = vpx_sad8x4_avg_msa; 1160const SadMxNAvgFunc sad4x8_avg_msa = vpx_sad4x8_avg_msa; 1161const SadMxNAvgFunc sad4x4_avg_msa = vpx_sad4x4_avg_msa; 1162const 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}; 1177INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests)); 1178 1179const SadMxNx4Func sad64x64x4d_msa = vpx_sad64x64x4d_msa; 1180const SadMxNx4Func sad64x32x4d_msa = vpx_sad64x32x4d_msa; 1181const SadMxNx4Func sad32x64x4d_msa = vpx_sad32x64x4d_msa; 1182const SadMxNx4Func sad32x32x4d_msa = vpx_sad32x32x4d_msa; 1183const SadMxNx4Func sad32x16x4d_msa = vpx_sad32x16x4d_msa; 1184const SadMxNx4Func sad16x32x4d_msa = vpx_sad16x32x4d_msa; 1185const SadMxNx4Func sad16x16x4d_msa = vpx_sad16x16x4d_msa; 1186const SadMxNx4Func sad16x8x4d_msa = vpx_sad16x8x4d_msa; 1187const SadMxNx4Func sad8x16x4d_msa = vpx_sad8x16x4d_msa; 1188const SadMxNx4Func sad8x8x4d_msa = vpx_sad8x8x4d_msa; 1189const SadMxNx4Func sad8x4x4d_msa = vpx_sad8x4x4d_msa; 1190const SadMxNx4Func sad4x8x4d_msa = vpx_sad4x8x4d_msa; 1191const SadMxNx4Func sad4x4x4d_msa = vpx_sad4x4x4d_msa; 1192const 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}; 1207INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests)); 1208#endif // HAVE_MSA 1209 1210} // namespace 1211