2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved.
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.
16 #include "./vpx_config.h"
17 #include "./vpx_dsp_rtcd.h"
18 #include "vpx_mem/vpx_mem.h"
20 /* Needed for ROUND_POWER_OF_TWO and CONVERT_TO* macros, both of which should be
21 * moved to a more generic location. Alternatively the *avg functions could be
22 * restricted to VP9 builds, but it would be better to avoid that sort of
24 * TODO(johannkoenig): move these macros to a common location.
26 #if CONFIG_VP9_HIGHBITDEPTH
27 #include "vp9/common/vp9_common.h"
28 #endif // CONFIG_VP9_HIGHBITDEPTH
30 #ifndef ROUND_POWER_OF_TWO
31 #define ROUND_POWER_OF_TWO(value, n) \
32 (((value) + (1 << ((n) - 1))) >> (n))
33 #endif // ROUND_POWER_OF_TWO
36 #include "test/acm_random.h"
37 #include "test/clear_system_state.h"
38 #include "test/register_state_check.h"
39 #include "test/util.h"
40 #include "third_party/googletest/src/include/gtest/gtest.h"
41 #include "vpx/vpx_codec.h"
44 typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr,
46 const uint8_t *ref_ptr,
48 typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam;
50 typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr,
52 const uint8_t *ref_ptr,
54 const uint8_t *second_pred);
55 typedef std::tr1::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
57 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr,
59 const uint8_t *const ref_ptr[],
62 typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
64 using libvpx_test::ACMRandom;
67 class SADTestBase : public ::testing::Test {
69 SADTestBase(int width, int height, int bit_depth) :
70 width_(width), height_(height), bd_(bit_depth) {}
72 static void SetUpTestCase() {
73 source_data8_ = reinterpret_cast<uint8_t*>(
74 vpx_memalign(kDataAlignment, kDataBlockSize));
75 reference_data8_ = reinterpret_cast<uint8_t*>(
76 vpx_memalign(kDataAlignment, kDataBufferSize));
77 second_pred8_ = reinterpret_cast<uint8_t*>(
78 vpx_memalign(kDataAlignment, 64*64));
79 source_data16_ = reinterpret_cast<uint16_t*>(
80 vpx_memalign(kDataAlignment, kDataBlockSize*sizeof(uint16_t)));
81 reference_data16_ = reinterpret_cast<uint16_t*>(
82 vpx_memalign(kDataAlignment, kDataBufferSize*sizeof(uint16_t)));
83 second_pred16_ = reinterpret_cast<uint16_t*>(
84 vpx_memalign(kDataAlignment, 64*64*sizeof(uint16_t)));
87 static void TearDownTestCase() {
88 vpx_free(source_data8_);
90 vpx_free(reference_data8_);
91 reference_data8_ = NULL;
92 vpx_free(second_pred8_);
94 vpx_free(source_data16_);
95 source_data16_ = NULL;
96 vpx_free(reference_data16_);
97 reference_data16_ = NULL;
98 vpx_free(second_pred16_);
99 second_pred16_ = NULL;
102 virtual void TearDown() {
103 libvpx_test::ClearSystemState();
107 // Handle blocks up to 4 blocks 64x64 with stride up to 128
108 static const int kDataAlignment = 16;
109 static const int kDataBlockSize = 64 * 128;
110 static const int kDataBufferSize = 4 * kDataBlockSize;
112 virtual void SetUp() {
114 use_high_bit_depth_ = false;
115 bit_depth_ = VPX_BITS_8;
116 source_data_ = source_data8_;
117 reference_data_ = reference_data8_;
118 second_pred_ = second_pred8_;
119 #if CONFIG_VP9_HIGHBITDEPTH
121 use_high_bit_depth_ = true;
122 bit_depth_ = static_cast<vpx_bit_depth_t>(bd_);
123 source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
124 reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
125 second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
126 #endif // CONFIG_VP9_HIGHBITDEPTH
128 mask_ = (1 << bit_depth_) - 1;
129 source_stride_ = (width_ + 31) & ~31;
130 reference_stride_ = width_ * 2;
131 rnd_.Reset(ACMRandom::DeterministicSeed());
134 virtual uint8_t *GetReference(int block_idx) {
135 #if CONFIG_VP9_HIGHBITDEPTH
136 if (use_high_bit_depth_)
137 return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
138 block_idx * kDataBlockSize);
139 #endif // CONFIG_VP9_HIGHBITDEPTH
140 return reference_data_ + block_idx * kDataBlockSize;
143 // Sum of Absolute Differences. Given two blocks, calculate the absolute
144 // difference between two pixels in the same relative location; accumulate.
145 unsigned int ReferenceSAD(int block_idx) {
146 unsigned int sad = 0;
147 const uint8_t *const reference8 = GetReference(block_idx);
148 const uint8_t *const source8 = source_data_;
149 #if CONFIG_VP9_HIGHBITDEPTH
150 const uint16_t *const reference16 =
151 CONVERT_TO_SHORTPTR(GetReference(block_idx));
152 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
153 #endif // CONFIG_VP9_HIGHBITDEPTH
154 for (int h = 0; h < height_; ++h) {
155 for (int w = 0; w < width_; ++w) {
156 if (!use_high_bit_depth_) {
157 sad += abs(source8[h * source_stride_ + w] -
158 reference8[h * reference_stride_ + w]);
159 #if CONFIG_VP9_HIGHBITDEPTH
161 sad += abs(source16[h * source_stride_ + w] -
162 reference16[h * reference_stride_ + w]);
163 #endif // CONFIG_VP9_HIGHBITDEPTH
170 // Sum of Absolute Differences Average. Given two blocks, and a prediction
171 // calculate the absolute difference between one pixel and average of the
172 // corresponding and predicted pixels; accumulate.
173 unsigned int ReferenceSADavg(int block_idx) {
174 unsigned int sad = 0;
175 const uint8_t *const reference8 = GetReference(block_idx);
176 const uint8_t *const source8 = source_data_;
177 const uint8_t *const second_pred8 = second_pred_;
178 #if CONFIG_VP9_HIGHBITDEPTH
179 const uint16_t *const reference16 =
180 CONVERT_TO_SHORTPTR(GetReference(block_idx));
181 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
182 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
183 #endif // CONFIG_VP9_HIGHBITDEPTH
184 for (int h = 0; h < height_; ++h) {
185 for (int w = 0; w < width_; ++w) {
186 if (!use_high_bit_depth_) {
187 const int tmp = second_pred8[h * width_ + w] +
188 reference8[h * reference_stride_ + w];
189 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
190 sad += abs(source8[h * source_stride_ + w] - comp_pred);
191 #if CONFIG_VP9_HIGHBITDEPTH
193 const int tmp = second_pred16[h * width_ + w] +
194 reference16[h * reference_stride_ + w];
195 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
196 sad += abs(source16[h * source_stride_ + w] - comp_pred);
197 #endif // CONFIG_VP9_HIGHBITDEPTH
204 void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) {
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 < height_; ++h) {
210 for (int w = 0; w < width_; ++w) {
211 if (!use_high_bit_depth_) {
212 data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
213 #if CONFIG_VP9_HIGHBITDEPTH
215 data16[h * stride + w] = fill_constant;
216 #endif // CONFIG_VP9_HIGHBITDEPTH
222 void FillRandom(uint8_t *data, int stride) {
223 uint8_t *data8 = data;
224 #if CONFIG_VP9_HIGHBITDEPTH
225 uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
226 #endif // CONFIG_VP9_HIGHBITDEPTH
227 for (int h = 0; h < height_; ++h) {
228 for (int w = 0; w < width_; ++w) {
229 if (!use_high_bit_depth_) {
230 data8[h * stride + w] = rnd_.Rand8();
231 #if CONFIG_VP9_HIGHBITDEPTH
233 data16[h * stride + w] = rnd_.Rand16() & mask_;
234 #endif // CONFIG_VP9_HIGHBITDEPTH
240 int width_, height_, mask_, bd_;
241 vpx_bit_depth_t bit_depth_;
242 static uint8_t *source_data_;
243 static uint8_t *reference_data_;
244 static uint8_t *second_pred_;
246 bool use_high_bit_depth_;
247 static uint8_t *source_data8_;
248 static uint8_t *reference_data8_;
249 static uint8_t *second_pred8_;
250 static uint16_t *source_data16_;
251 static uint16_t *reference_data16_;
252 static uint16_t *second_pred16_;
253 int reference_stride_;
259 : public SADTestBase,
260 public ::testing::WithParamInterface<SadMxNx4Param> {
262 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
265 void SADs(unsigned int *results) {
266 const uint8_t *references[] = {GetReference(0), GetReference(1),
267 GetReference(2), GetReference(3)};
269 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
270 references, reference_stride_,
275 unsigned int reference_sad, exp_sad[4];
278 for (int block = 0; block < 4; ++block) {
279 reference_sad = ReferenceSAD(block);
281 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
287 : public SADTestBase,
288 public ::testing::WithParamInterface<SadMxNParam> {
290 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
293 unsigned int SAD(int block_idx) {
295 const uint8_t *const reference = GetReference(block_idx);
297 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
298 reference, reference_stride_));
303 const unsigned int reference_sad = ReferenceSAD(0);
304 const unsigned int exp_sad = SAD(0);
306 ASSERT_EQ(reference_sad, exp_sad);
311 : public SADTestBase,
312 public ::testing::WithParamInterface<SadMxNAvgParam> {
314 SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
317 unsigned int SAD_avg(int block_idx) {
319 const uint8_t *const reference = GetReference(block_idx);
321 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
322 reference, reference_stride_,
328 const unsigned int reference_sad = ReferenceSADavg(0);
329 const unsigned int exp_sad = SAD_avg(0);
331 ASSERT_EQ(reference_sad, exp_sad);
335 uint8_t *SADTestBase::source_data_ = NULL;
336 uint8_t *SADTestBase::reference_data_ = NULL;
337 uint8_t *SADTestBase::second_pred_ = NULL;
338 uint8_t *SADTestBase::source_data8_ = NULL;
339 uint8_t *SADTestBase::reference_data8_ = NULL;
340 uint8_t *SADTestBase::second_pred8_ = NULL;
341 uint16_t *SADTestBase::source_data16_ = NULL;
342 uint16_t *SADTestBase::reference_data16_ = NULL;
343 uint16_t *SADTestBase::second_pred16_ = NULL;
345 TEST_P(SADTest, MaxRef) {
346 FillConstant(source_data_, source_stride_, 0);
347 FillConstant(reference_data_, reference_stride_, mask_);
351 TEST_P(SADTest, MaxSrc) {
352 FillConstant(source_data_, source_stride_, mask_);
353 FillConstant(reference_data_, reference_stride_, 0);
357 TEST_P(SADTest, ShortRef) {
358 const int tmp_stride = reference_stride_;
359 reference_stride_ >>= 1;
360 FillRandom(source_data_, source_stride_);
361 FillRandom(reference_data_, reference_stride_);
363 reference_stride_ = tmp_stride;
366 TEST_P(SADTest, UnalignedRef) {
367 // The reference frame, but not the source frame, may be unaligned for
368 // certain types of searches.
369 const int tmp_stride = reference_stride_;
370 reference_stride_ -= 1;
371 FillRandom(source_data_, source_stride_);
372 FillRandom(reference_data_, reference_stride_);
374 reference_stride_ = tmp_stride;
377 TEST_P(SADTest, ShortSrc) {
378 const int tmp_stride = source_stride_;
379 source_stride_ >>= 1;
380 FillRandom(source_data_, source_stride_);
381 FillRandom(reference_data_, reference_stride_);
383 source_stride_ = tmp_stride;
386 TEST_P(SADavgTest, MaxRef) {
387 FillConstant(source_data_, source_stride_, 0);
388 FillConstant(reference_data_, reference_stride_, mask_);
389 FillConstant(second_pred_, width_, 0);
392 TEST_P(SADavgTest, MaxSrc) {
393 FillConstant(source_data_, source_stride_, mask_);
394 FillConstant(reference_data_, reference_stride_, 0);
395 FillConstant(second_pred_, width_, 0);
399 TEST_P(SADavgTest, ShortRef) {
400 const int tmp_stride = reference_stride_;
401 reference_stride_ >>= 1;
402 FillRandom(source_data_, source_stride_);
403 FillRandom(reference_data_, reference_stride_);
404 FillRandom(second_pred_, width_);
406 reference_stride_ = tmp_stride;
409 TEST_P(SADavgTest, UnalignedRef) {
410 // The reference frame, but not the source frame, may be unaligned for
411 // certain types of searches.
412 const int tmp_stride = reference_stride_;
413 reference_stride_ -= 1;
414 FillRandom(source_data_, source_stride_);
415 FillRandom(reference_data_, reference_stride_);
416 FillRandom(second_pred_, width_);
418 reference_stride_ = tmp_stride;
421 TEST_P(SADavgTest, ShortSrc) {
422 const int tmp_stride = source_stride_;
423 source_stride_ >>= 1;
424 FillRandom(source_data_, source_stride_);
425 FillRandom(reference_data_, reference_stride_);
426 FillRandom(second_pred_, width_);
428 source_stride_ = tmp_stride;
431 TEST_P(SADx4Test, MaxRef) {
432 FillConstant(source_data_, source_stride_, 0);
433 FillConstant(GetReference(0), reference_stride_, mask_);
434 FillConstant(GetReference(1), reference_stride_, mask_);
435 FillConstant(GetReference(2), reference_stride_, mask_);
436 FillConstant(GetReference(3), reference_stride_, mask_);
440 TEST_P(SADx4Test, MaxSrc) {
441 FillConstant(source_data_, source_stride_, mask_);
442 FillConstant(GetReference(0), reference_stride_, 0);
443 FillConstant(GetReference(1), reference_stride_, 0);
444 FillConstant(GetReference(2), reference_stride_, 0);
445 FillConstant(GetReference(3), reference_stride_, 0);
449 TEST_P(SADx4Test, ShortRef) {
450 int tmp_stride = reference_stride_;
451 reference_stride_ >>= 1;
452 FillRandom(source_data_, source_stride_);
453 FillRandom(GetReference(0), reference_stride_);
454 FillRandom(GetReference(1), reference_stride_);
455 FillRandom(GetReference(2), reference_stride_);
456 FillRandom(GetReference(3), reference_stride_);
458 reference_stride_ = tmp_stride;
461 TEST_P(SADx4Test, UnalignedRef) {
462 // The reference frame, but not the source frame, may be unaligned for
463 // certain types of searches.
464 int tmp_stride = reference_stride_;
465 reference_stride_ -= 1;
466 FillRandom(source_data_, source_stride_);
467 FillRandom(GetReference(0), reference_stride_);
468 FillRandom(GetReference(1), reference_stride_);
469 FillRandom(GetReference(2), reference_stride_);
470 FillRandom(GetReference(3), reference_stride_);
472 reference_stride_ = tmp_stride;
475 TEST_P(SADx4Test, ShortSrc) {
476 int tmp_stride = source_stride_;
477 source_stride_ >>= 1;
478 FillRandom(source_data_, source_stride_);
479 FillRandom(GetReference(0), reference_stride_);
480 FillRandom(GetReference(1), reference_stride_);
481 FillRandom(GetReference(2), reference_stride_);
482 FillRandom(GetReference(3), reference_stride_);
484 source_stride_ = tmp_stride;
487 TEST_P(SADx4Test, SrcAlignedByWidth) {
488 uint8_t * tmp_source_data = source_data_;
489 source_data_ += width_;
490 FillRandom(source_data_, source_stride_);
491 FillRandom(GetReference(0), reference_stride_);
492 FillRandom(GetReference(1), reference_stride_);
493 FillRandom(GetReference(2), reference_stride_);
494 FillRandom(GetReference(3), reference_stride_);
496 source_data_ = tmp_source_data;
499 using std::tr1::make_tuple;
501 //------------------------------------------------------------------------------
503 const SadMxNFunc sad64x64_c = vpx_sad64x64_c;
504 const SadMxNFunc sad64x32_c = vpx_sad64x32_c;
505 const SadMxNFunc sad32x64_c = vpx_sad32x64_c;
506 const SadMxNFunc sad32x32_c = vpx_sad32x32_c;
507 const SadMxNFunc sad32x16_c = vpx_sad32x16_c;
508 const SadMxNFunc sad16x32_c = vpx_sad16x32_c;
509 const SadMxNFunc sad16x16_c = vpx_sad16x16_c;
510 const SadMxNFunc sad16x8_c = vpx_sad16x8_c;
511 const SadMxNFunc sad8x16_c = vpx_sad8x16_c;
512 const SadMxNFunc sad8x8_c = vpx_sad8x8_c;
513 const SadMxNFunc sad8x4_c = vpx_sad8x4_c;
514 const SadMxNFunc sad4x8_c = vpx_sad4x8_c;
515 const SadMxNFunc sad4x4_c = vpx_sad4x4_c;
516 #if CONFIG_VP9_HIGHBITDEPTH
517 const SadMxNFunc highbd_sad64x64_c = vpx_highbd_sad64x64_c;
518 const SadMxNFunc highbd_sad64x32_c = vpx_highbd_sad64x32_c;
519 const SadMxNFunc highbd_sad32x64_c = vpx_highbd_sad32x64_c;
520 const SadMxNFunc highbd_sad32x32_c = vpx_highbd_sad32x32_c;
521 const SadMxNFunc highbd_sad32x16_c = vpx_highbd_sad32x16_c;
522 const SadMxNFunc highbd_sad16x32_c = vpx_highbd_sad16x32_c;
523 const SadMxNFunc highbd_sad16x16_c = vpx_highbd_sad16x16_c;
524 const SadMxNFunc highbd_sad16x8_c = vpx_highbd_sad16x8_c;
525 const SadMxNFunc highbd_sad8x16_c = vpx_highbd_sad8x16_c;
526 const SadMxNFunc highbd_sad8x8_c = vpx_highbd_sad8x8_c;
527 const SadMxNFunc highbd_sad8x4_c = vpx_highbd_sad8x4_c;
528 const SadMxNFunc highbd_sad4x8_c = vpx_highbd_sad4x8_c;
529 const SadMxNFunc highbd_sad4x4_c = vpx_highbd_sad4x4_c;
530 #endif // CONFIG_VP9_HIGHBITDEPTH
531 const SadMxNParam c_tests[] = {
532 make_tuple(64, 64, sad64x64_c, -1),
533 make_tuple(64, 32, sad64x32_c, -1),
534 make_tuple(32, 64, sad32x64_c, -1),
535 make_tuple(32, 32, sad32x32_c, -1),
536 make_tuple(32, 16, sad32x16_c, -1),
537 make_tuple(16, 32, sad16x32_c, -1),
538 make_tuple(16, 16, sad16x16_c, -1),
539 make_tuple(16, 8, sad16x8_c, -1),
540 make_tuple(8, 16, sad8x16_c, -1),
541 make_tuple(8, 8, sad8x8_c, -1),
542 make_tuple(8, 4, sad8x4_c, -1),
543 make_tuple(4, 8, sad4x8_c, -1),
544 make_tuple(4, 4, sad4x4_c, -1),
545 #if CONFIG_VP9_HIGHBITDEPTH
546 make_tuple(64, 64, highbd_sad64x64_c, 8),
547 make_tuple(64, 32, highbd_sad64x32_c, 8),
548 make_tuple(32, 64, highbd_sad32x64_c, 8),
549 make_tuple(32, 32, highbd_sad32x32_c, 8),
550 make_tuple(32, 16, highbd_sad32x16_c, 8),
551 make_tuple(16, 32, highbd_sad16x32_c, 8),
552 make_tuple(16, 16, highbd_sad16x16_c, 8),
553 make_tuple(16, 8, highbd_sad16x8_c, 8),
554 make_tuple(8, 16, highbd_sad8x16_c, 8),
555 make_tuple(8, 8, highbd_sad8x8_c, 8),
556 make_tuple(8, 4, highbd_sad8x4_c, 8),
557 make_tuple(4, 8, highbd_sad4x8_c, 8),
558 make_tuple(4, 4, highbd_sad4x4_c, 8),
559 make_tuple(64, 64, highbd_sad64x64_c, 10),
560 make_tuple(64, 32, highbd_sad64x32_c, 10),
561 make_tuple(32, 64, highbd_sad32x64_c, 10),
562 make_tuple(32, 32, highbd_sad32x32_c, 10),
563 make_tuple(32, 16, highbd_sad32x16_c, 10),
564 make_tuple(16, 32, highbd_sad16x32_c, 10),
565 make_tuple(16, 16, highbd_sad16x16_c, 10),
566 make_tuple(16, 8, highbd_sad16x8_c, 10),
567 make_tuple(8, 16, highbd_sad8x16_c, 10),
568 make_tuple(8, 8, highbd_sad8x8_c, 10),
569 make_tuple(8, 4, highbd_sad8x4_c, 10),
570 make_tuple(4, 8, highbd_sad4x8_c, 10),
571 make_tuple(4, 4, highbd_sad4x4_c, 10),
572 make_tuple(64, 64, highbd_sad64x64_c, 12),
573 make_tuple(64, 32, highbd_sad64x32_c, 12),
574 make_tuple(32, 64, highbd_sad32x64_c, 12),
575 make_tuple(32, 32, highbd_sad32x32_c, 12),
576 make_tuple(32, 16, highbd_sad32x16_c, 12),
577 make_tuple(16, 32, highbd_sad16x32_c, 12),
578 make_tuple(16, 16, highbd_sad16x16_c, 12),
579 make_tuple(16, 8, highbd_sad16x8_c, 12),
580 make_tuple(8, 16, highbd_sad8x16_c, 12),
581 make_tuple(8, 8, highbd_sad8x8_c, 12),
582 make_tuple(8, 4, highbd_sad8x4_c, 12),
583 make_tuple(4, 8, highbd_sad4x8_c, 12),
584 make_tuple(4, 4, highbd_sad4x4_c, 12),
585 #endif // CONFIG_VP9_HIGHBITDEPTH
587 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
589 const SadMxNAvgFunc sad64x64_avg_c = vpx_sad64x64_avg_c;
590 const SadMxNAvgFunc sad64x32_avg_c = vpx_sad64x32_avg_c;
591 const SadMxNAvgFunc sad32x64_avg_c = vpx_sad32x64_avg_c;
592 const SadMxNAvgFunc sad32x32_avg_c = vpx_sad32x32_avg_c;
593 const SadMxNAvgFunc sad32x16_avg_c = vpx_sad32x16_avg_c;
594 const SadMxNAvgFunc sad16x32_avg_c = vpx_sad16x32_avg_c;
595 const SadMxNAvgFunc sad16x16_avg_c = vpx_sad16x16_avg_c;
596 const SadMxNAvgFunc sad16x8_avg_c = vpx_sad16x8_avg_c;
597 const SadMxNAvgFunc sad8x16_avg_c = vpx_sad8x16_avg_c;
598 const SadMxNAvgFunc sad8x8_avg_c = vpx_sad8x8_avg_c;
599 const SadMxNAvgFunc sad8x4_avg_c = vpx_sad8x4_avg_c;
600 const SadMxNAvgFunc sad4x8_avg_c = vpx_sad4x8_avg_c;
601 const SadMxNAvgFunc sad4x4_avg_c = vpx_sad4x4_avg_c;
602 #if CONFIG_VP9_HIGHBITDEPTH
603 const SadMxNAvgFunc highbd_sad64x64_avg_c = vpx_highbd_sad64x64_avg_c;
604 const SadMxNAvgFunc highbd_sad64x32_avg_c = vpx_highbd_sad64x32_avg_c;
605 const SadMxNAvgFunc highbd_sad32x64_avg_c = vpx_highbd_sad32x64_avg_c;
606 const SadMxNAvgFunc highbd_sad32x32_avg_c = vpx_highbd_sad32x32_avg_c;
607 const SadMxNAvgFunc highbd_sad32x16_avg_c = vpx_highbd_sad32x16_avg_c;
608 const SadMxNAvgFunc highbd_sad16x32_avg_c = vpx_highbd_sad16x32_avg_c;
609 const SadMxNAvgFunc highbd_sad16x16_avg_c = vpx_highbd_sad16x16_avg_c;
610 const SadMxNAvgFunc highbd_sad16x8_avg_c = vpx_highbd_sad16x8_avg_c;
611 const SadMxNAvgFunc highbd_sad8x16_avg_c = vpx_highbd_sad8x16_avg_c;
612 const SadMxNAvgFunc highbd_sad8x8_avg_c = vpx_highbd_sad8x8_avg_c;
613 const SadMxNAvgFunc highbd_sad8x4_avg_c = vpx_highbd_sad8x4_avg_c;
614 const SadMxNAvgFunc highbd_sad4x8_avg_c = vpx_highbd_sad4x8_avg_c;
615 const SadMxNAvgFunc highbd_sad4x4_avg_c = vpx_highbd_sad4x4_avg_c;
616 #endif // CONFIG_VP9_HIGHBITDEPTH
617 const SadMxNAvgParam avg_c_tests[] = {
618 make_tuple(64, 64, sad64x64_avg_c, -1),
619 make_tuple(64, 32, sad64x32_avg_c, -1),
620 make_tuple(32, 64, sad32x64_avg_c, -1),
621 make_tuple(32, 32, sad32x32_avg_c, -1),
622 make_tuple(32, 16, sad32x16_avg_c, -1),
623 make_tuple(16, 32, sad16x32_avg_c, -1),
624 make_tuple(16, 16, sad16x16_avg_c, -1),
625 make_tuple(16, 8, sad16x8_avg_c, -1),
626 make_tuple(8, 16, sad8x16_avg_c, -1),
627 make_tuple(8, 8, sad8x8_avg_c, -1),
628 make_tuple(8, 4, sad8x4_avg_c, -1),
629 make_tuple(4, 8, sad4x8_avg_c, -1),
630 make_tuple(4, 4, sad4x4_avg_c, -1),
631 #if CONFIG_VP9_HIGHBITDEPTH
632 make_tuple(64, 64, highbd_sad64x64_avg_c, 8),
633 make_tuple(64, 32, highbd_sad64x32_avg_c, 8),
634 make_tuple(32, 64, highbd_sad32x64_avg_c, 8),
635 make_tuple(32, 32, highbd_sad32x32_avg_c, 8),
636 make_tuple(32, 16, highbd_sad32x16_avg_c, 8),
637 make_tuple(16, 32, highbd_sad16x32_avg_c, 8),
638 make_tuple(16, 16, highbd_sad16x16_avg_c, 8),
639 make_tuple(16, 8, highbd_sad16x8_avg_c, 8),
640 make_tuple(8, 16, highbd_sad8x16_avg_c, 8),
641 make_tuple(8, 8, highbd_sad8x8_avg_c, 8),
642 make_tuple(8, 4, highbd_sad8x4_avg_c, 8),
643 make_tuple(4, 8, highbd_sad4x8_avg_c, 8),
644 make_tuple(4, 4, highbd_sad4x4_avg_c, 8),
645 make_tuple(64, 64, highbd_sad64x64_avg_c, 10),
646 make_tuple(64, 32, highbd_sad64x32_avg_c, 10),
647 make_tuple(32, 64, highbd_sad32x64_avg_c, 10),
648 make_tuple(32, 32, highbd_sad32x32_avg_c, 10),
649 make_tuple(32, 16, highbd_sad32x16_avg_c, 10),
650 make_tuple(16, 32, highbd_sad16x32_avg_c, 10),
651 make_tuple(16, 16, highbd_sad16x16_avg_c, 10),
652 make_tuple(16, 8, highbd_sad16x8_avg_c, 10),
653 make_tuple(8, 16, highbd_sad8x16_avg_c, 10),
654 make_tuple(8, 8, highbd_sad8x8_avg_c, 10),
655 make_tuple(8, 4, highbd_sad8x4_avg_c, 10),
656 make_tuple(4, 8, highbd_sad4x8_avg_c, 10),
657 make_tuple(4, 4, highbd_sad4x4_avg_c, 10),
658 make_tuple(64, 64, highbd_sad64x64_avg_c, 12),
659 make_tuple(64, 32, highbd_sad64x32_avg_c, 12),
660 make_tuple(32, 64, highbd_sad32x64_avg_c, 12),
661 make_tuple(32, 32, highbd_sad32x32_avg_c, 12),
662 make_tuple(32, 16, highbd_sad32x16_avg_c, 12),
663 make_tuple(16, 32, highbd_sad16x32_avg_c, 12),
664 make_tuple(16, 16, highbd_sad16x16_avg_c, 12),
665 make_tuple(16, 8, highbd_sad16x8_avg_c, 12),
666 make_tuple(8, 16, highbd_sad8x16_avg_c, 12),
667 make_tuple(8, 8, highbd_sad8x8_avg_c, 12),
668 make_tuple(8, 4, highbd_sad8x4_avg_c, 12),
669 make_tuple(4, 8, highbd_sad4x8_avg_c, 12),
670 make_tuple(4, 4, highbd_sad4x4_avg_c, 12),
671 #endif // CONFIG_VP9_HIGHBITDEPTH
673 INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
675 const SadMxNx4Func sad64x64x4d_c = vpx_sad64x64x4d_c;
676 const SadMxNx4Func sad64x32x4d_c = vpx_sad64x32x4d_c;
677 const SadMxNx4Func sad32x64x4d_c = vpx_sad32x64x4d_c;
678 const SadMxNx4Func sad32x32x4d_c = vpx_sad32x32x4d_c;
679 const SadMxNx4Func sad32x16x4d_c = vpx_sad32x16x4d_c;
680 const SadMxNx4Func sad16x32x4d_c = vpx_sad16x32x4d_c;
681 const SadMxNx4Func sad16x16x4d_c = vpx_sad16x16x4d_c;
682 const SadMxNx4Func sad16x8x4d_c = vpx_sad16x8x4d_c;
683 const SadMxNx4Func sad8x16x4d_c = vpx_sad8x16x4d_c;
684 const SadMxNx4Func sad8x8x4d_c = vpx_sad8x8x4d_c;
685 const SadMxNx4Func sad8x4x4d_c = vpx_sad8x4x4d_c;
686 const SadMxNx4Func sad4x8x4d_c = vpx_sad4x8x4d_c;
687 const SadMxNx4Func sad4x4x4d_c = vpx_sad4x4x4d_c;
688 #if CONFIG_VP9_HIGHBITDEPTH
689 const SadMxNx4Func highbd_sad64x64x4d_c = vpx_highbd_sad64x64x4d_c;
690 const SadMxNx4Func highbd_sad64x32x4d_c = vpx_highbd_sad64x32x4d_c;
691 const SadMxNx4Func highbd_sad32x64x4d_c = vpx_highbd_sad32x64x4d_c;
692 const SadMxNx4Func highbd_sad32x32x4d_c = vpx_highbd_sad32x32x4d_c;
693 const SadMxNx4Func highbd_sad32x16x4d_c = vpx_highbd_sad32x16x4d_c;
694 const SadMxNx4Func highbd_sad16x32x4d_c = vpx_highbd_sad16x32x4d_c;
695 const SadMxNx4Func highbd_sad16x16x4d_c = vpx_highbd_sad16x16x4d_c;
696 const SadMxNx4Func highbd_sad16x8x4d_c = vpx_highbd_sad16x8x4d_c;
697 const SadMxNx4Func highbd_sad8x16x4d_c = vpx_highbd_sad8x16x4d_c;
698 const SadMxNx4Func highbd_sad8x8x4d_c = vpx_highbd_sad8x8x4d_c;
699 const SadMxNx4Func highbd_sad8x4x4d_c = vpx_highbd_sad8x4x4d_c;
700 const SadMxNx4Func highbd_sad4x8x4d_c = vpx_highbd_sad4x8x4d_c;
701 const SadMxNx4Func highbd_sad4x4x4d_c = vpx_highbd_sad4x4x4d_c;
702 #endif // CONFIG_VP9_HIGHBITDEPTH
703 const SadMxNx4Param x4d_c_tests[] = {
704 make_tuple(64, 64, sad64x64x4d_c, -1),
705 make_tuple(64, 32, sad64x32x4d_c, -1),
706 make_tuple(32, 64, sad32x64x4d_c, -1),
707 make_tuple(32, 32, sad32x32x4d_c, -1),
708 make_tuple(32, 16, sad32x16x4d_c, -1),
709 make_tuple(16, 32, sad16x32x4d_c, -1),
710 make_tuple(16, 16, sad16x16x4d_c, -1),
711 make_tuple(16, 8, sad16x8x4d_c, -1),
712 make_tuple(8, 16, sad8x16x4d_c, -1),
713 make_tuple(8, 8, sad8x8x4d_c, -1),
714 make_tuple(8, 4, sad8x4x4d_c, -1),
715 make_tuple(4, 8, sad4x8x4d_c, -1),
716 make_tuple(4, 4, sad4x4x4d_c, -1),
717 #if CONFIG_VP9_HIGHBITDEPTH
718 make_tuple(64, 64, highbd_sad64x64x4d_c, 8),
719 make_tuple(64, 32, highbd_sad64x32x4d_c, 8),
720 make_tuple(32, 64, highbd_sad32x64x4d_c, 8),
721 make_tuple(32, 32, highbd_sad32x32x4d_c, 8),
722 make_tuple(32, 16, highbd_sad32x16x4d_c, 8),
723 make_tuple(16, 32, highbd_sad16x32x4d_c, 8),
724 make_tuple(16, 16, highbd_sad16x16x4d_c, 8),
725 make_tuple(16, 8, highbd_sad16x8x4d_c, 8),
726 make_tuple(8, 16, highbd_sad8x16x4d_c, 8),
727 make_tuple(8, 8, highbd_sad8x8x4d_c, 8),
728 make_tuple(8, 4, highbd_sad8x4x4d_c, 8),
729 make_tuple(4, 8, highbd_sad4x8x4d_c, 8),
730 make_tuple(4, 4, highbd_sad4x4x4d_c, 8),
731 make_tuple(64, 64, highbd_sad64x64x4d_c, 10),
732 make_tuple(64, 32, highbd_sad64x32x4d_c, 10),
733 make_tuple(32, 64, highbd_sad32x64x4d_c, 10),
734 make_tuple(32, 32, highbd_sad32x32x4d_c, 10),
735 make_tuple(32, 16, highbd_sad32x16x4d_c, 10),
736 make_tuple(16, 32, highbd_sad16x32x4d_c, 10),
737 make_tuple(16, 16, highbd_sad16x16x4d_c, 10),
738 make_tuple(16, 8, highbd_sad16x8x4d_c, 10),
739 make_tuple(8, 16, highbd_sad8x16x4d_c, 10),
740 make_tuple(8, 8, highbd_sad8x8x4d_c, 10),
741 make_tuple(8, 4, highbd_sad8x4x4d_c, 10),
742 make_tuple(4, 8, highbd_sad4x8x4d_c, 10),
743 make_tuple(4, 4, highbd_sad4x4x4d_c, 10),
744 make_tuple(64, 64, highbd_sad64x64x4d_c, 12),
745 make_tuple(64, 32, highbd_sad64x32x4d_c, 12),
746 make_tuple(32, 64, highbd_sad32x64x4d_c, 12),
747 make_tuple(32, 32, highbd_sad32x32x4d_c, 12),
748 make_tuple(32, 16, highbd_sad32x16x4d_c, 12),
749 make_tuple(16, 32, highbd_sad16x32x4d_c, 12),
750 make_tuple(16, 16, highbd_sad16x16x4d_c, 12),
751 make_tuple(16, 8, highbd_sad16x8x4d_c, 12),
752 make_tuple(8, 16, highbd_sad8x16x4d_c, 12),
753 make_tuple(8, 8, highbd_sad8x8x4d_c, 12),
754 make_tuple(8, 4, highbd_sad8x4x4d_c, 12),
755 make_tuple(4, 8, highbd_sad4x8x4d_c, 12),
756 make_tuple(4, 4, highbd_sad4x4x4d_c, 12),
757 #endif // CONFIG_VP9_HIGHBITDEPTH
759 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
761 //------------------------------------------------------------------------------
764 const SadMxNFunc sad16x16_media = vpx_sad16x16_media;
765 const SadMxNParam media_tests[] = {
766 make_tuple(16, 16, sad16x16_media, -1),
768 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests));
772 const SadMxNFunc sad64x64_neon = vpx_sad64x64_neon;
773 const SadMxNFunc sad32x32_neon = vpx_sad32x32_neon;
774 const SadMxNFunc sad16x16_neon = vpx_sad16x16_neon;
775 const SadMxNFunc sad16x8_neon = vpx_sad16x8_neon;
776 const SadMxNFunc sad8x16_neon = vpx_sad8x16_neon;
777 const SadMxNFunc sad8x8_neon = vpx_sad8x8_neon;
778 const SadMxNFunc sad4x4_neon = vpx_sad4x4_neon;
780 const SadMxNParam neon_tests[] = {
781 make_tuple(64, 64, sad64x64_neon, -1),
782 make_tuple(32, 32, sad32x32_neon, -1),
783 make_tuple(16, 16, sad16x16_neon, -1),
784 make_tuple(16, 8, sad16x8_neon, -1),
785 make_tuple(8, 16, sad8x16_neon, -1),
786 make_tuple(8, 8, sad8x8_neon, -1),
787 make_tuple(4, 4, sad4x4_neon, -1),
789 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
791 const SadMxNx4Func sad64x64x4d_neon = vpx_sad64x64x4d_neon;
792 const SadMxNx4Func sad32x32x4d_neon = vpx_sad32x32x4d_neon;
793 const SadMxNx4Func sad16x16x4d_neon = vpx_sad16x16x4d_neon;
794 const SadMxNx4Param x4d_neon_tests[] = {
795 make_tuple(64, 64, sad64x64x4d_neon, -1),
796 make_tuple(32, 32, sad32x32x4d_neon, -1),
797 make_tuple(16, 16, sad16x16x4d_neon, -1),
799 INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
802 //------------------------------------------------------------------------------
805 const SadMxNFunc sad16x16_mmx = vpx_sad16x16_mmx;
806 const SadMxNFunc sad16x8_mmx = vpx_sad16x8_mmx;
807 const SadMxNFunc sad8x16_mmx = vpx_sad8x16_mmx;
808 const SadMxNFunc sad8x8_mmx = vpx_sad8x8_mmx;
809 const SadMxNFunc sad4x4_mmx = vpx_sad4x4_mmx;
810 const SadMxNParam mmx_tests[] = {
811 make_tuple(16, 16, sad16x16_mmx, -1),
812 make_tuple(16, 8, sad16x8_mmx, -1),
813 make_tuple(8, 16, sad8x16_mmx, -1),
814 make_tuple(8, 8, sad8x8_mmx, -1),
815 make_tuple(4, 4, sad4x4_mmx, -1),
817 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests));
821 #if CONFIG_USE_X86INC
822 const SadMxNFunc sad4x8_sse = vpx_sad4x8_sse;
823 const SadMxNFunc sad4x4_sse = vpx_sad4x4_sse;
824 const SadMxNParam sse_tests[] = {
825 make_tuple(4, 8, sad4x8_sse, -1),
826 make_tuple(4, 4, sad4x4_sse, -1),
828 INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::ValuesIn(sse_tests));
830 const SadMxNAvgFunc sad4x8_avg_sse = vpx_sad4x8_avg_sse;
831 const SadMxNAvgFunc sad4x4_avg_sse = vpx_sad4x4_avg_sse;
832 const SadMxNAvgParam avg_sse_tests[] = {
833 make_tuple(4, 8, sad4x8_avg_sse, -1),
834 make_tuple(4, 4, sad4x4_avg_sse, -1),
836 INSTANTIATE_TEST_CASE_P(SSE, SADavgTest, ::testing::ValuesIn(avg_sse_tests));
838 const SadMxNx4Func sad4x8x4d_sse = vpx_sad4x8x4d_sse;
839 const SadMxNx4Func sad4x4x4d_sse = vpx_sad4x4x4d_sse;
840 const SadMxNx4Param x4d_sse_tests[] = {
841 make_tuple(4, 8, sad4x8x4d_sse, -1),
842 make_tuple(4, 4, sad4x4x4d_sse, -1),
844 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::ValuesIn(x4d_sse_tests));
845 #endif // CONFIG_USE_X86INC
849 #if CONFIG_USE_X86INC
850 const SadMxNFunc sad64x64_sse2 = vpx_sad64x64_sse2;
851 const SadMxNFunc sad64x32_sse2 = vpx_sad64x32_sse2;
852 const SadMxNFunc sad32x64_sse2 = vpx_sad32x64_sse2;
853 const SadMxNFunc sad32x32_sse2 = vpx_sad32x32_sse2;
854 const SadMxNFunc sad32x16_sse2 = vpx_sad32x16_sse2;
855 const SadMxNFunc sad16x32_sse2 = vpx_sad16x32_sse2;
856 const SadMxNFunc sad16x16_sse2 = vpx_sad16x16_sse2;
857 const SadMxNFunc sad16x8_sse2 = vpx_sad16x8_sse2;
858 const SadMxNFunc sad8x16_sse2 = vpx_sad8x16_sse2;
859 const SadMxNFunc sad8x8_sse2 = vpx_sad8x8_sse2;
860 const SadMxNFunc sad8x4_sse2 = vpx_sad8x4_sse2;
861 #if CONFIG_VP9_HIGHBITDEPTH
862 const SadMxNFunc highbd_sad64x64_sse2 = vpx_highbd_sad64x64_sse2;
863 const SadMxNFunc highbd_sad64x32_sse2 = vpx_highbd_sad64x32_sse2;
864 const SadMxNFunc highbd_sad32x64_sse2 = vpx_highbd_sad32x64_sse2;
865 const SadMxNFunc highbd_sad32x32_sse2 = vpx_highbd_sad32x32_sse2;
866 const SadMxNFunc highbd_sad32x16_sse2 = vpx_highbd_sad32x16_sse2;
867 const SadMxNFunc highbd_sad16x32_sse2 = vpx_highbd_sad16x32_sse2;
868 const SadMxNFunc highbd_sad16x16_sse2 = vpx_highbd_sad16x16_sse2;
869 const SadMxNFunc highbd_sad16x8_sse2 = vpx_highbd_sad16x8_sse2;
870 const SadMxNFunc highbd_sad8x16_sse2 = vpx_highbd_sad8x16_sse2;
871 const SadMxNFunc highbd_sad8x8_sse2 = vpx_highbd_sad8x8_sse2;
872 const SadMxNFunc highbd_sad8x4_sse2 = vpx_highbd_sad8x4_sse2;
873 #endif // CONFIG_VP9_HIGHBITDEPTH
874 const SadMxNParam sse2_tests[] = {
875 make_tuple(64, 64, sad64x64_sse2, -1),
876 make_tuple(64, 32, sad64x32_sse2, -1),
877 make_tuple(32, 64, sad32x64_sse2, -1),
878 make_tuple(32, 32, sad32x32_sse2, -1),
879 make_tuple(32, 16, sad32x16_sse2, -1),
880 make_tuple(16, 32, sad16x32_sse2, -1),
881 make_tuple(16, 16, sad16x16_sse2, -1),
882 make_tuple(16, 8, sad16x8_sse2, -1),
883 make_tuple(8, 16, sad8x16_sse2, -1),
884 make_tuple(8, 8, sad8x8_sse2, -1),
885 make_tuple(8, 4, sad8x4_sse2, -1),
886 #if CONFIG_VP9_HIGHBITDEPTH
887 make_tuple(64, 64, highbd_sad64x64_sse2, 8),
888 make_tuple(64, 32, highbd_sad64x32_sse2, 8),
889 make_tuple(32, 64, highbd_sad32x64_sse2, 8),
890 make_tuple(32, 32, highbd_sad32x32_sse2, 8),
891 make_tuple(32, 16, highbd_sad32x16_sse2, 8),
892 make_tuple(16, 32, highbd_sad16x32_sse2, 8),
893 make_tuple(16, 16, highbd_sad16x16_sse2, 8),
894 make_tuple(16, 8, highbd_sad16x8_sse2, 8),
895 make_tuple(8, 16, highbd_sad8x16_sse2, 8),
896 make_tuple(8, 8, highbd_sad8x8_sse2, 8),
897 make_tuple(8, 4, highbd_sad8x4_sse2, 8),
898 make_tuple(64, 64, highbd_sad64x64_sse2, 10),
899 make_tuple(64, 32, highbd_sad64x32_sse2, 10),
900 make_tuple(32, 64, highbd_sad32x64_sse2, 10),
901 make_tuple(32, 32, highbd_sad32x32_sse2, 10),
902 make_tuple(32, 16, highbd_sad32x16_sse2, 10),
903 make_tuple(16, 32, highbd_sad16x32_sse2, 10),
904 make_tuple(16, 16, highbd_sad16x16_sse2, 10),
905 make_tuple(16, 8, highbd_sad16x8_sse2, 10),
906 make_tuple(8, 16, highbd_sad8x16_sse2, 10),
907 make_tuple(8, 8, highbd_sad8x8_sse2, 10),
908 make_tuple(8, 4, highbd_sad8x4_sse2, 10),
909 make_tuple(64, 64, highbd_sad64x64_sse2, 12),
910 make_tuple(64, 32, highbd_sad64x32_sse2, 12),
911 make_tuple(32, 64, highbd_sad32x64_sse2, 12),
912 make_tuple(32, 32, highbd_sad32x32_sse2, 12),
913 make_tuple(32, 16, highbd_sad32x16_sse2, 12),
914 make_tuple(16, 32, highbd_sad16x32_sse2, 12),
915 make_tuple(16, 16, highbd_sad16x16_sse2, 12),
916 make_tuple(16, 8, highbd_sad16x8_sse2, 12),
917 make_tuple(8, 16, highbd_sad8x16_sse2, 12),
918 make_tuple(8, 8, highbd_sad8x8_sse2, 12),
919 make_tuple(8, 4, highbd_sad8x4_sse2, 12),
920 #endif // CONFIG_VP9_HIGHBITDEPTH
922 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
924 const SadMxNAvgFunc sad64x64_avg_sse2 = vpx_sad64x64_avg_sse2;
925 const SadMxNAvgFunc sad64x32_avg_sse2 = vpx_sad64x32_avg_sse2;
926 const SadMxNAvgFunc sad32x64_avg_sse2 = vpx_sad32x64_avg_sse2;
927 const SadMxNAvgFunc sad32x32_avg_sse2 = vpx_sad32x32_avg_sse2;
928 const SadMxNAvgFunc sad32x16_avg_sse2 = vpx_sad32x16_avg_sse2;
929 const SadMxNAvgFunc sad16x32_avg_sse2 = vpx_sad16x32_avg_sse2;
930 const SadMxNAvgFunc sad16x16_avg_sse2 = vpx_sad16x16_avg_sse2;
931 const SadMxNAvgFunc sad16x8_avg_sse2 = vpx_sad16x8_avg_sse2;
932 const SadMxNAvgFunc sad8x16_avg_sse2 = vpx_sad8x16_avg_sse2;
933 const SadMxNAvgFunc sad8x8_avg_sse2 = vpx_sad8x8_avg_sse2;
934 const SadMxNAvgFunc sad8x4_avg_sse2 = vpx_sad8x4_avg_sse2;
935 #if CONFIG_VP9_HIGHBITDEPTH
936 const SadMxNAvgFunc highbd_sad64x64_avg_sse2 = vpx_highbd_sad64x64_avg_sse2;
937 const SadMxNAvgFunc highbd_sad64x32_avg_sse2 = vpx_highbd_sad64x32_avg_sse2;
938 const SadMxNAvgFunc highbd_sad32x64_avg_sse2 = vpx_highbd_sad32x64_avg_sse2;
939 const SadMxNAvgFunc highbd_sad32x32_avg_sse2 = vpx_highbd_sad32x32_avg_sse2;
940 const SadMxNAvgFunc highbd_sad32x16_avg_sse2 = vpx_highbd_sad32x16_avg_sse2;
941 const SadMxNAvgFunc highbd_sad16x32_avg_sse2 = vpx_highbd_sad16x32_avg_sse2;
942 const SadMxNAvgFunc highbd_sad16x16_avg_sse2 = vpx_highbd_sad16x16_avg_sse2;
943 const SadMxNAvgFunc highbd_sad16x8_avg_sse2 = vpx_highbd_sad16x8_avg_sse2;
944 const SadMxNAvgFunc highbd_sad8x16_avg_sse2 = vpx_highbd_sad8x16_avg_sse2;
945 const SadMxNAvgFunc highbd_sad8x8_avg_sse2 = vpx_highbd_sad8x8_avg_sse2;
946 const SadMxNAvgFunc highbd_sad8x4_avg_sse2 = vpx_highbd_sad8x4_avg_sse2;
947 #endif // CONFIG_VP9_HIGHBITDEPTH
948 const SadMxNAvgParam avg_sse2_tests[] = {
949 make_tuple(64, 64, sad64x64_avg_sse2, -1),
950 make_tuple(64, 32, sad64x32_avg_sse2, -1),
951 make_tuple(32, 64, sad32x64_avg_sse2, -1),
952 make_tuple(32, 32, sad32x32_avg_sse2, -1),
953 make_tuple(32, 16, sad32x16_avg_sse2, -1),
954 make_tuple(16, 32, sad16x32_avg_sse2, -1),
955 make_tuple(16, 16, sad16x16_avg_sse2, -1),
956 make_tuple(16, 8, sad16x8_avg_sse2, -1),
957 make_tuple(8, 16, sad8x16_avg_sse2, -1),
958 make_tuple(8, 8, sad8x8_avg_sse2, -1),
959 make_tuple(8, 4, sad8x4_avg_sse2, -1),
960 #if CONFIG_VP9_HIGHBITDEPTH
961 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 8),
962 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 8),
963 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 8),
964 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 8),
965 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 8),
966 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 8),
967 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 8),
968 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 8),
969 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 8),
970 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 8),
971 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 8),
972 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 10),
973 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 10),
974 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 10),
975 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 10),
976 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 10),
977 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 10),
978 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 10),
979 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 10),
980 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 10),
981 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 10),
982 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 10),
983 make_tuple(64, 64, highbd_sad64x64_avg_sse2, 12),
984 make_tuple(64, 32, highbd_sad64x32_avg_sse2, 12),
985 make_tuple(32, 64, highbd_sad32x64_avg_sse2, 12),
986 make_tuple(32, 32, highbd_sad32x32_avg_sse2, 12),
987 make_tuple(32, 16, highbd_sad32x16_avg_sse2, 12),
988 make_tuple(16, 32, highbd_sad16x32_avg_sse2, 12),
989 make_tuple(16, 16, highbd_sad16x16_avg_sse2, 12),
990 make_tuple(16, 8, highbd_sad16x8_avg_sse2, 12),
991 make_tuple(8, 16, highbd_sad8x16_avg_sse2, 12),
992 make_tuple(8, 8, highbd_sad8x8_avg_sse2, 12),
993 make_tuple(8, 4, highbd_sad8x4_avg_sse2, 12),
994 #endif // CONFIG_VP9_HIGHBITDEPTH
996 INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
998 const SadMxNx4Func sad64x64x4d_sse2 = vpx_sad64x64x4d_sse2;
999 const SadMxNx4Func sad64x32x4d_sse2 = vpx_sad64x32x4d_sse2;
1000 const SadMxNx4Func sad32x64x4d_sse2 = vpx_sad32x64x4d_sse2;
1001 const SadMxNx4Func sad32x32x4d_sse2 = vpx_sad32x32x4d_sse2;
1002 const SadMxNx4Func sad32x16x4d_sse2 = vpx_sad32x16x4d_sse2;
1003 const SadMxNx4Func sad16x32x4d_sse2 = vpx_sad16x32x4d_sse2;
1004 const SadMxNx4Func sad16x16x4d_sse2 = vpx_sad16x16x4d_sse2;
1005 const SadMxNx4Func sad16x8x4d_sse2 = vpx_sad16x8x4d_sse2;
1006 const SadMxNx4Func sad8x16x4d_sse2 = vpx_sad8x16x4d_sse2;
1007 const SadMxNx4Func sad8x8x4d_sse2 = vpx_sad8x8x4d_sse2;
1008 const SadMxNx4Func sad8x4x4d_sse2 = vpx_sad8x4x4d_sse2;
1009 #if CONFIG_VP9_HIGHBITDEPTH
1010 const SadMxNx4Func highbd_sad64x64x4d_sse2 = vpx_highbd_sad64x64x4d_sse2;
1011 const SadMxNx4Func highbd_sad64x32x4d_sse2 = vpx_highbd_sad64x32x4d_sse2;
1012 const SadMxNx4Func highbd_sad32x64x4d_sse2 = vpx_highbd_sad32x64x4d_sse2;
1013 const SadMxNx4Func highbd_sad32x32x4d_sse2 = vpx_highbd_sad32x32x4d_sse2;
1014 const SadMxNx4Func highbd_sad32x16x4d_sse2 = vpx_highbd_sad32x16x4d_sse2;
1015 const SadMxNx4Func highbd_sad16x32x4d_sse2 = vpx_highbd_sad16x32x4d_sse2;
1016 const SadMxNx4Func highbd_sad16x16x4d_sse2 = vpx_highbd_sad16x16x4d_sse2;
1017 const SadMxNx4Func highbd_sad16x8x4d_sse2 = vpx_highbd_sad16x8x4d_sse2;
1018 const SadMxNx4Func highbd_sad8x16x4d_sse2 = vpx_highbd_sad8x16x4d_sse2;
1019 const SadMxNx4Func highbd_sad8x8x4d_sse2 = vpx_highbd_sad8x8x4d_sse2;
1020 const SadMxNx4Func highbd_sad8x4x4d_sse2 = vpx_highbd_sad8x4x4d_sse2;
1021 const SadMxNx4Func highbd_sad4x8x4d_sse2 = vpx_highbd_sad4x8x4d_sse2;
1022 const SadMxNx4Func highbd_sad4x4x4d_sse2 = vpx_highbd_sad4x4x4d_sse2;
1023 #endif // CONFIG_VP9_HIGHBITDEPTH
1024 const SadMxNx4Param x4d_sse2_tests[] = {
1025 make_tuple(64, 64, sad64x64x4d_sse2, -1),
1026 make_tuple(64, 32, sad64x32x4d_sse2, -1),
1027 make_tuple(32, 64, sad32x64x4d_sse2, -1),
1028 make_tuple(32, 32, sad32x32x4d_sse2, -1),
1029 make_tuple(32, 16, sad32x16x4d_sse2, -1),
1030 make_tuple(16, 32, sad16x32x4d_sse2, -1),
1031 make_tuple(16, 16, sad16x16x4d_sse2, -1),
1032 make_tuple(16, 8, sad16x8x4d_sse2, -1),
1033 make_tuple(8, 16, sad8x16x4d_sse2, -1),
1034 make_tuple(8, 8, sad8x8x4d_sse2, -1),
1035 make_tuple(8, 4, sad8x4x4d_sse2, -1),
1036 #if CONFIG_VP9_HIGHBITDEPTH
1037 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 8),
1038 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 8),
1039 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 8),
1040 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 8),
1041 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 8),
1042 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 8),
1043 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 8),
1044 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 8),
1045 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 8),
1046 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 8),
1047 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 8),
1048 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 8),
1049 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 8),
1050 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 10),
1051 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 10),
1052 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 10),
1053 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 10),
1054 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 10),
1055 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 10),
1056 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 10),
1057 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 10),
1058 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 10),
1059 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 10),
1060 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 10),
1061 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 10),
1062 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 10),
1063 make_tuple(64, 64, highbd_sad64x64x4d_sse2, 12),
1064 make_tuple(64, 32, highbd_sad64x32x4d_sse2, 12),
1065 make_tuple(32, 64, highbd_sad32x64x4d_sse2, 12),
1066 make_tuple(32, 32, highbd_sad32x32x4d_sse2, 12),
1067 make_tuple(32, 16, highbd_sad32x16x4d_sse2, 12),
1068 make_tuple(16, 32, highbd_sad16x32x4d_sse2, 12),
1069 make_tuple(16, 16, highbd_sad16x16x4d_sse2, 12),
1070 make_tuple(16, 8, highbd_sad16x8x4d_sse2, 12),
1071 make_tuple(8, 16, highbd_sad8x16x4d_sse2, 12),
1072 make_tuple(8, 8, highbd_sad8x8x4d_sse2, 12),
1073 make_tuple(8, 4, highbd_sad8x4x4d_sse2, 12),
1074 make_tuple(4, 8, highbd_sad4x8x4d_sse2, 12),
1075 make_tuple(4, 4, highbd_sad4x4x4d_sse2, 12),
1076 #endif // CONFIG_VP9_HIGHBITDEPTH
1078 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
1079 #endif // CONFIG_USE_X86INC
1083 // Only functions are x3, which do not have tests.
1087 // Only functions are x3, which do not have tests.
1088 #endif // HAVE_SSSE3
1091 // Only functions are x8, which do not have tests.
1092 #endif // HAVE_SSE4_1
1095 const SadMxNFunc sad64x64_avx2 = vpx_sad64x64_avx2;
1096 const SadMxNFunc sad64x32_avx2 = vpx_sad64x32_avx2;
1097 const SadMxNFunc sad32x64_avx2 = vpx_sad32x64_avx2;
1098 const SadMxNFunc sad32x32_avx2 = vpx_sad32x32_avx2;
1099 const SadMxNFunc sad32x16_avx2 = vpx_sad32x16_avx2;
1100 const SadMxNParam avx2_tests[] = {
1101 make_tuple(64, 64, sad64x64_avx2, -1),
1102 make_tuple(64, 32, sad64x32_avx2, -1),
1103 make_tuple(32, 64, sad32x64_avx2, -1),
1104 make_tuple(32, 32, sad32x32_avx2, -1),
1105 make_tuple(32, 16, sad32x16_avx2, -1),
1107 INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
1109 const SadMxNAvgFunc sad64x64_avg_avx2 = vpx_sad64x64_avg_avx2;
1110 const SadMxNAvgFunc sad64x32_avg_avx2 = vpx_sad64x32_avg_avx2;
1111 const SadMxNAvgFunc sad32x64_avg_avx2 = vpx_sad32x64_avg_avx2;
1112 const SadMxNAvgFunc sad32x32_avg_avx2 = vpx_sad32x32_avg_avx2;
1113 const SadMxNAvgFunc sad32x16_avg_avx2 = vpx_sad32x16_avg_avx2;
1114 const SadMxNAvgParam avg_avx2_tests[] = {
1115 make_tuple(64, 64, sad64x64_avg_avx2, -1),
1116 make_tuple(64, 32, sad64x32_avg_avx2, -1),
1117 make_tuple(32, 64, sad32x64_avg_avx2, -1),
1118 make_tuple(32, 32, sad32x32_avg_avx2, -1),
1119 make_tuple(32, 16, sad32x16_avg_avx2, -1),
1121 INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
1123 const SadMxNx4Func sad64x64x4d_avx2 = vpx_sad64x64x4d_avx2;
1124 const SadMxNx4Func sad32x32x4d_avx2 = vpx_sad32x32x4d_avx2;
1125 const SadMxNx4Param x4d_avx2_tests[] = {
1126 make_tuple(64, 64, sad64x64x4d_avx2, -1),
1127 make_tuple(32, 32, sad32x32x4d_avx2, -1),
1129 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));