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 #if CONFIG_VP8_ENCODER
18 #include "./vp8_rtcd.h"
20 #if CONFIG_VP9_ENCODER
21 #include "./vp9_rtcd.h"
23 #include "vpx_mem/vpx_mem.h"
25 #include "test/acm_random.h"
26 #include "test/clear_system_state.h"
27 #include "test/register_state_check.h"
28 #include "test/util.h"
29 #include "third_party/googletest/src/include/gtest/gtest.h"
30 #include "vpx/vpx_codec.h"
33 #if CONFIG_VP8_ENCODER
34 typedef unsigned int (*SadMxNFunc)(const unsigned char *source_ptr,
36 const unsigned char *reference_ptr,
38 unsigned int max_sad);
39 typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam;
41 #if CONFIG_VP9_ENCODER
42 typedef unsigned int (*SadMxNVp9Func)(const unsigned char *source_ptr,
44 const unsigned char *reference_ptr,
45 int reference_stride);
46 typedef std::tr1::tuple<int, int, SadMxNVp9Func, int> SadMxNVp9Param;
47 typedef uint32_t (*SadMxNAvgVp9Func)(const uint8_t *source_ptr,
49 const uint8_t *reference_ptr,
51 const uint8_t *second_pred);
52 typedef std::tr1::tuple<int, int, SadMxNAvgVp9Func, int> SadMxNAvgVp9Param;
55 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr,
57 const uint8_t *const ref_ptr[],
60 typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
62 using libvpx_test::ACMRandom;
65 class SADTestBase : public ::testing::Test {
67 SADTestBase(int width, int height, int bit_depth) :
68 width_(width), height_(height), bd_(bit_depth) {}
70 static void SetUpTestCase() {
71 #if CONFIG_VP9_HIGHBITDEPTH
72 source_data8_ = reinterpret_cast<uint8_t*>(
73 vpx_memalign(kDataAlignment, kDataBlockSize));
74 reference_data8_ = reinterpret_cast<uint8_t*>(
75 vpx_memalign(kDataAlignment, kDataBufferSize));
76 second_pred8_ = reinterpret_cast<uint8_t*>(
77 vpx_memalign(kDataAlignment, 64*64));
78 source_data16_ = reinterpret_cast<uint16_t*>(
79 vpx_memalign(kDataAlignment, kDataBlockSize*sizeof(uint16_t)));
80 reference_data16_ = reinterpret_cast<uint16_t*>(
81 vpx_memalign(kDataAlignment, kDataBufferSize*sizeof(uint16_t)));
82 second_pred16_ = reinterpret_cast<uint16_t*>(
83 vpx_memalign(kDataAlignment, 64*64*sizeof(uint16_t)));
85 source_data_ = reinterpret_cast<uint8_t*>(
86 vpx_memalign(kDataAlignment, kDataBlockSize));
87 reference_data_ = reinterpret_cast<uint8_t*>(
88 vpx_memalign(kDataAlignment, kDataBufferSize));
89 second_pred_ = reinterpret_cast<uint8_t*>(
90 vpx_memalign(kDataAlignment, 64*64));
94 static void TearDownTestCase() {
95 #if CONFIG_VP9_HIGHBITDEPTH
96 vpx_free(source_data8_);
98 vpx_free(reference_data8_);
99 reference_data8_ = NULL;
100 vpx_free(second_pred8_);
101 second_pred8_ = NULL;
102 vpx_free(source_data16_);
103 source_data16_ = NULL;
104 vpx_free(reference_data16_);
105 reference_data16_ = NULL;
106 vpx_free(second_pred16_);
107 second_pred16_ = NULL;
109 vpx_free(source_data_);
111 vpx_free(reference_data_);
112 reference_data_ = NULL;
113 vpx_free(second_pred_);
118 virtual void TearDown() {
119 libvpx_test::ClearSystemState();
123 // Handle blocks up to 4 blocks 64x64 with stride up to 128
124 static const int kDataAlignment = 16;
125 static const int kDataBlockSize = 64 * 128;
126 static const int kDataBufferSize = 4 * kDataBlockSize;
128 virtual void SetUp() {
129 #if CONFIG_VP9_HIGHBITDEPTH
131 use_high_bit_depth_ = false;
132 bit_depth_ = VPX_BITS_8;
133 source_data_ = source_data8_;
134 reference_data_ = reference_data8_;
135 second_pred_ = second_pred8_;
137 use_high_bit_depth_ = true;
138 bit_depth_ = static_cast<vpx_bit_depth_t>(bd_);
139 source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
140 reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
141 second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
144 bit_depth_ = VPX_BITS_8;
146 mask_ = (1 << bit_depth_) - 1;
147 source_stride_ = (width_ + 31) & ~31;
148 reference_stride_ = width_ * 2;
149 rnd_.Reset(ACMRandom::DeterministicSeed());
152 virtual uint8_t *GetReference(int block_idx) {
153 #if CONFIG_VP9_HIGHBITDEPTH
154 if (!use_high_bit_depth_) {
155 return reference_data_ + block_idx * kDataBlockSize;
157 return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
158 block_idx * kDataBlockSize);
161 return reference_data_ + block_idx * kDataBlockSize;
165 // Sum of Absolute Differences. Given two blocks, calculate the absolute
166 // difference between two pixels in the same relative location; accumulate.
167 unsigned int ReferenceSAD(unsigned int max_sad, int block_idx) {
168 unsigned int sad = 0;
169 #if CONFIG_VP9_HIGHBITDEPTH
170 const uint8_t *const reference8 = GetReference(block_idx);
171 const uint8_t *const source8 = source_data_;
172 const uint16_t *const reference16 =
173 CONVERT_TO_SHORTPTR(GetReference(block_idx));
174 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
176 const uint8_t *const reference = GetReference(block_idx);
177 const uint8_t *const source = source_data_;
179 for (int h = 0; h < height_; ++h) {
180 for (int w = 0; w < width_; ++w) {
181 #if CONFIG_VP9_HIGHBITDEPTH
182 if (!use_high_bit_depth_) {
184 abs(source8[h * source_stride_ + w] -
185 reference8[h * reference_stride_ + w]);
188 abs(source16[h * source_stride_ + w] -
189 reference16[h * reference_stride_ + w]);
193 abs(source[h * source_stride_ + w] -
194 reference[h * reference_stride_ + w]);
204 // Sum of Absolute Differences Average. Given two blocks, and a prediction
205 // calculate the absolute difference between one pixel and average of the
206 // corresponding and predicted pixels; accumulate.
207 unsigned int ReferenceSADavg(unsigned int max_sad, int block_idx) {
208 unsigned int sad = 0;
209 #if CONFIG_VP9_HIGHBITDEPTH
210 const uint8_t *const reference8 = GetReference(block_idx);
211 const uint8_t *const source8 = source_data_;
212 const uint8_t *const second_pred8 = second_pred_;
213 const uint16_t *const reference16 =
214 CONVERT_TO_SHORTPTR(GetReference(block_idx));
215 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
216 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
218 const uint8_t *const reference = GetReference(block_idx);
219 const uint8_t *const source = source_data_;
220 const uint8_t *const second_pred = second_pred_;
222 for (int h = 0; h < height_; ++h) {
223 for (int w = 0; w < width_; ++w) {
224 #if CONFIG_VP9_HIGHBITDEPTH
225 if (!use_high_bit_depth_) {
226 const int tmp = second_pred8[h * width_ + w] +
227 reference8[h * reference_stride_ + w];
228 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
229 sad += abs(source8[h * source_stride_ + w] - comp_pred);
231 const int tmp = second_pred16[h * width_ + w] +
232 reference16[h * reference_stride_ + w];
233 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
234 sad += abs(source16[h * source_stride_ + w] - comp_pred);
237 const int tmp = second_pred[h * width_ + w] +
238 reference[h * reference_stride_ + w];
239 const uint8_t comp_pred = (tmp + 1) >> 1;
240 sad += abs(source[h * source_stride_ + w] - comp_pred);
250 void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) {
251 #if CONFIG_VP9_HIGHBITDEPTH
252 uint8_t *data8 = data;
253 uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
255 for (int h = 0; h < height_; ++h) {
256 for (int w = 0; w < width_; ++w) {
257 #if CONFIG_VP9_HIGHBITDEPTH
258 if (!use_high_bit_depth_) {
259 data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
261 data16[h * stride + w] = fill_constant;
264 data[h * stride + w] = static_cast<uint8_t>(fill_constant);
270 void FillRandom(uint8_t *data, int stride) {
271 #if CONFIG_VP9_HIGHBITDEPTH
272 uint8_t *data8 = data;
273 uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
275 for (int h = 0; h < height_; ++h) {
276 for (int w = 0; w < width_; ++w) {
277 #if CONFIG_VP9_HIGHBITDEPTH
278 if (!use_high_bit_depth_) {
279 data8[h * stride + w] = rnd_.Rand8();
281 data16[h * stride + w] = rnd_.Rand16() & mask_;
284 data[h * stride + w] = rnd_.Rand8();
290 int width_, height_, mask_, bd_;
291 vpx_bit_depth_t bit_depth_;
292 static uint8_t *source_data_;
293 static uint8_t *reference_data_;
294 static uint8_t *second_pred_;
296 #if CONFIG_VP9_HIGHBITDEPTH
297 bool use_high_bit_depth_;
298 static uint8_t *source_data8_;
299 static uint8_t *reference_data8_;
300 static uint8_t *second_pred8_;
301 static uint16_t *source_data16_;
302 static uint16_t *reference_data16_;
303 static uint16_t *second_pred16_;
305 int reference_stride_;
311 : public SADTestBase,
312 public ::testing::WithParamInterface<SadMxNx4Param> {
314 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
317 void SADs(unsigned int *results) {
318 const uint8_t *refs[] = {GetReference(0), GetReference(1),
319 GetReference(2), GetReference(3)};
321 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
322 refs, reference_stride_,
327 unsigned int reference_sad, exp_sad[4];
330 for (int block = 0; block < 4; ++block) {
331 reference_sad = ReferenceSAD(UINT_MAX, block);
333 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
338 #if CONFIG_VP8_ENCODER
340 : public SADTestBase,
341 public ::testing::WithParamInterface<SadMxNParam> {
343 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
346 unsigned int SAD(unsigned int max_sad, int block_idx) {
348 const uint8_t *const reference = GetReference(block_idx);
350 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
351 reference, reference_stride_,
356 void CheckSAD(unsigned int max_sad) {
357 const unsigned int reference_sad = ReferenceSAD(max_sad, 0);
358 const unsigned int exp_sad = SAD(max_sad, 0);
360 if (reference_sad <= max_sad) {
361 ASSERT_EQ(exp_sad, reference_sad);
363 // Alternative implementations are not required to check max_sad
364 ASSERT_GE(exp_sad, reference_sad);
368 #endif // CONFIG_VP8_ENCODER
370 #if CONFIG_VP9_ENCODER
372 : public SADTestBase,
373 public ::testing::WithParamInterface<SadMxNVp9Param> {
375 SADVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
378 unsigned int SAD(int block_idx) {
380 const uint8_t *const reference = GetReference(block_idx);
382 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
383 reference, reference_stride_));
388 const unsigned int reference_sad = ReferenceSAD(UINT_MAX, 0);
389 const unsigned int exp_sad = SAD(0);
391 ASSERT_EQ(reference_sad, exp_sad);
396 : public SADTestBase,
397 public ::testing::WithParamInterface<SadMxNAvgVp9Param> {
399 SADavgVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
402 unsigned int SAD_avg(int block_idx) {
404 const uint8_t *const reference = GetReference(block_idx);
406 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
407 reference, reference_stride_,
413 const unsigned int reference_sad = ReferenceSADavg(UINT_MAX, 0);
414 const unsigned int exp_sad = SAD_avg(0);
416 ASSERT_EQ(reference_sad, exp_sad);
419 #endif // CONFIG_VP9_ENCODER
421 uint8_t *SADTestBase::source_data_ = NULL;
422 uint8_t *SADTestBase::reference_data_ = NULL;
423 uint8_t *SADTestBase::second_pred_ = NULL;
424 #if CONFIG_VP9_ENCODER && CONFIG_VP9_HIGHBITDEPTH
425 uint8_t *SADTestBase::source_data8_ = NULL;
426 uint8_t *SADTestBase::reference_data8_ = NULL;
427 uint8_t *SADTestBase::second_pred8_ = NULL;
428 uint16_t *SADTestBase::source_data16_ = NULL;
429 uint16_t *SADTestBase::reference_data16_ = NULL;
430 uint16_t *SADTestBase::second_pred16_ = NULL;
433 #if CONFIG_VP8_ENCODER
434 TEST_P(SADTest, MaxRef) {
435 FillConstant(source_data_, source_stride_, 0);
436 FillConstant(reference_data_, reference_stride_, mask_);
440 TEST_P(SADTest, MaxSrc) {
441 FillConstant(source_data_, source_stride_, mask_);
442 FillConstant(reference_data_, reference_stride_, 0);
446 TEST_P(SADTest, ShortRef) {
447 int tmp_stride = reference_stride_;
448 reference_stride_ >>= 1;
449 FillRandom(source_data_, source_stride_);
450 FillRandom(reference_data_, reference_stride_);
452 reference_stride_ = tmp_stride;
455 TEST_P(SADTest, UnalignedRef) {
456 // The reference frame, but not the source frame, may be unaligned for
457 // certain types of searches.
458 const int tmp_stride = reference_stride_;
459 reference_stride_ -= 1;
460 FillRandom(source_data_, source_stride_);
461 FillRandom(reference_data_, reference_stride_);
463 reference_stride_ = tmp_stride;
466 TEST_P(SADTest, ShortSrc) {
467 const int tmp_stride = source_stride_;
468 source_stride_ >>= 1;
469 FillRandom(source_data_, source_stride_);
470 FillRandom(reference_data_, reference_stride_);
472 source_stride_ = tmp_stride;
475 TEST_P(SADTest, MaxSAD) {
476 // Verify that, when max_sad is set, the implementation does not return a
477 // value lower than the reference.
478 FillConstant(source_data_, source_stride_, mask_);
479 FillConstant(reference_data_, reference_stride_, 0);
482 #endif // CONFIG_VP8_ENCODER
484 #if CONFIG_VP9_ENCODER
485 TEST_P(SADVP9Test, MaxRef) {
486 FillConstant(source_data_, source_stride_, 0);
487 FillConstant(reference_data_, reference_stride_, mask_);
491 TEST_P(SADVP9Test, MaxSrc) {
492 FillConstant(source_data_, source_stride_, mask_);
493 FillConstant(reference_data_, reference_stride_, 0);
497 TEST_P(SADVP9Test, ShortRef) {
498 const int tmp_stride = reference_stride_;
499 reference_stride_ >>= 1;
500 FillRandom(source_data_, source_stride_);
501 FillRandom(reference_data_, reference_stride_);
503 reference_stride_ = tmp_stride;
506 TEST_P(SADVP9Test, UnalignedRef) {
507 // The reference frame, but not the source frame, may be unaligned for
508 // certain types of searches.
509 const int tmp_stride = reference_stride_;
510 reference_stride_ -= 1;
511 FillRandom(source_data_, source_stride_);
512 FillRandom(reference_data_, reference_stride_);
514 reference_stride_ = tmp_stride;
517 TEST_P(SADVP9Test, ShortSrc) {
518 const int tmp_stride = source_stride_;
519 source_stride_ >>= 1;
520 FillRandom(source_data_, source_stride_);
521 FillRandom(reference_data_, reference_stride_);
523 source_stride_ = tmp_stride;
526 TEST_P(SADavgVP9Test, MaxRef) {
527 FillConstant(source_data_, source_stride_, 0);
528 FillConstant(reference_data_, reference_stride_, mask_);
529 FillConstant(second_pred_, width_, 0);
532 TEST_P(SADavgVP9Test, MaxSrc) {
533 FillConstant(source_data_, source_stride_, mask_);
534 FillConstant(reference_data_, reference_stride_, 0);
535 FillConstant(second_pred_, width_, 0);
539 TEST_P(SADavgVP9Test, ShortRef) {
540 const int tmp_stride = reference_stride_;
541 reference_stride_ >>= 1;
542 FillRandom(source_data_, source_stride_);
543 FillRandom(reference_data_, reference_stride_);
544 FillRandom(second_pred_, width_);
546 reference_stride_ = tmp_stride;
549 TEST_P(SADavgVP9Test, UnalignedRef) {
550 // The reference frame, but not the source frame, may be unaligned for
551 // certain types of searches.
552 const int tmp_stride = reference_stride_;
553 reference_stride_ -= 1;
554 FillRandom(source_data_, source_stride_);
555 FillRandom(reference_data_, reference_stride_);
556 FillRandom(second_pred_, width_);
558 reference_stride_ = tmp_stride;
561 TEST_P(SADavgVP9Test, ShortSrc) {
562 const int tmp_stride = source_stride_;
563 source_stride_ >>= 1;
564 FillRandom(source_data_, source_stride_);
565 FillRandom(reference_data_, reference_stride_);
566 FillRandom(second_pred_, width_);
568 source_stride_ = tmp_stride;
570 #endif // CONFIG_VP9_ENCODER
572 TEST_P(SADx4Test, MaxRef) {
573 FillConstant(source_data_, source_stride_, 0);
574 FillConstant(GetReference(0), reference_stride_, mask_);
575 FillConstant(GetReference(1), reference_stride_, mask_);
576 FillConstant(GetReference(2), reference_stride_, mask_);
577 FillConstant(GetReference(3), reference_stride_, mask_);
581 TEST_P(SADx4Test, MaxSrc) {
582 FillConstant(source_data_, source_stride_, mask_);
583 FillConstant(GetReference(0), reference_stride_, 0);
584 FillConstant(GetReference(1), reference_stride_, 0);
585 FillConstant(GetReference(2), reference_stride_, 0);
586 FillConstant(GetReference(3), reference_stride_, 0);
590 TEST_P(SADx4Test, ShortRef) {
591 int tmp_stride = reference_stride_;
592 reference_stride_ >>= 1;
593 FillRandom(source_data_, source_stride_);
594 FillRandom(GetReference(0), reference_stride_);
595 FillRandom(GetReference(1), reference_stride_);
596 FillRandom(GetReference(2), reference_stride_);
597 FillRandom(GetReference(3), reference_stride_);
599 reference_stride_ = tmp_stride;
602 TEST_P(SADx4Test, UnalignedRef) {
603 // The reference frame, but not the source frame, may be unaligned for
604 // certain types of searches.
605 int tmp_stride = reference_stride_;
606 reference_stride_ -= 1;
607 FillRandom(source_data_, source_stride_);
608 FillRandom(GetReference(0), reference_stride_);
609 FillRandom(GetReference(1), reference_stride_);
610 FillRandom(GetReference(2), reference_stride_);
611 FillRandom(GetReference(3), reference_stride_);
613 reference_stride_ = tmp_stride;
616 TEST_P(SADx4Test, ShortSrc) {
617 int tmp_stride = source_stride_;
618 source_stride_ >>= 1;
619 FillRandom(source_data_, source_stride_);
620 FillRandom(GetReference(0), reference_stride_);
621 FillRandom(GetReference(1), reference_stride_);
622 FillRandom(GetReference(2), reference_stride_);
623 FillRandom(GetReference(3), reference_stride_);
625 source_stride_ = tmp_stride;
628 TEST_P(SADx4Test, SrcAlignedByWidth) {
629 uint8_t * tmp_source_data = source_data_;
630 source_data_ += width_;
631 FillRandom(source_data_, source_stride_);
632 FillRandom(GetReference(0), reference_stride_);
633 FillRandom(GetReference(1), reference_stride_);
634 FillRandom(GetReference(2), reference_stride_);
635 FillRandom(GetReference(3), reference_stride_);
637 source_data_ = tmp_source_data;
640 using std::tr1::make_tuple;
642 //------------------------------------------------------------------------------
644 #if CONFIG_VP8_ENCODER
645 const SadMxNFunc sad_16x16_c = vp8_sad16x16_c;
646 const SadMxNFunc sad_8x16_c = vp8_sad8x16_c;
647 const SadMxNFunc sad_16x8_c = vp8_sad16x8_c;
648 const SadMxNFunc sad_8x8_c = vp8_sad8x8_c;
649 const SadMxNFunc sad_4x4_c = vp8_sad4x4_c;
650 const SadMxNParam c_tests[] = {
651 make_tuple(16, 16, sad_16x16_c, -1),
652 make_tuple(8, 16, sad_8x16_c, -1),
653 make_tuple(16, 8, sad_16x8_c, -1),
654 make_tuple(8, 8, sad_8x8_c, -1),
655 make_tuple(4, 4, sad_4x4_c, -1),
657 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
658 #endif // CONFIG_VP8_ENCODER
660 #if CONFIG_VP9_ENCODER
661 const SadMxNVp9Func sad_64x64_c_vp9 = vp9_sad64x64_c;
662 const SadMxNVp9Func sad_32x32_c_vp9 = vp9_sad32x32_c;
663 const SadMxNVp9Func sad_16x16_c_vp9 = vp9_sad16x16_c;
664 const SadMxNVp9Func sad_8x16_c_vp9 = vp9_sad8x16_c;
665 const SadMxNVp9Func sad_16x8_c_vp9 = vp9_sad16x8_c;
666 const SadMxNVp9Func sad_8x8_c_vp9 = vp9_sad8x8_c;
667 const SadMxNVp9Func sad_8x4_c_vp9 = vp9_sad8x4_c;
668 const SadMxNVp9Func sad_4x8_c_vp9 = vp9_sad4x8_c;
669 const SadMxNVp9Func sad_4x4_c_vp9 = vp9_sad4x4_c;
670 const SadMxNVp9Param c_vp9_tests[] = {
671 make_tuple(64, 64, sad_64x64_c_vp9, -1),
672 make_tuple(32, 32, sad_32x32_c_vp9, -1),
673 make_tuple(16, 16, sad_16x16_c_vp9, -1),
674 make_tuple(8, 16, sad_8x16_c_vp9, -1),
675 make_tuple(16, 8, sad_16x8_c_vp9, -1),
676 make_tuple(8, 8, sad_8x8_c_vp9, -1),
677 make_tuple(8, 4, sad_8x4_c_vp9, -1),
678 make_tuple(4, 8, sad_4x8_c_vp9, -1),
679 make_tuple(4, 4, sad_4x4_c_vp9, -1),
681 INSTANTIATE_TEST_CASE_P(C, SADVP9Test, ::testing::ValuesIn(c_vp9_tests));
683 const SadMxNx4Func sad_64x64x4d_c = vp9_sad64x64x4d_c;
684 const SadMxNx4Func sad_64x32x4d_c = vp9_sad64x32x4d_c;
685 const SadMxNx4Func sad_32x64x4d_c = vp9_sad32x64x4d_c;
686 const SadMxNx4Func sad_32x32x4d_c = vp9_sad32x32x4d_c;
687 const SadMxNx4Func sad_32x16x4d_c = vp9_sad32x16x4d_c;
688 const SadMxNx4Func sad_16x32x4d_c = vp9_sad16x32x4d_c;
689 const SadMxNx4Func sad_16x16x4d_c = vp9_sad16x16x4d_c;
690 const SadMxNx4Func sad_16x8x4d_c = vp9_sad16x8x4d_c;
691 const SadMxNx4Func sad_8x16x4d_c = vp9_sad8x16x4d_c;
692 const SadMxNx4Func sad_8x8x4d_c = vp9_sad8x8x4d_c;
693 const SadMxNx4Func sad_8x4x4d_c = vp9_sad8x4x4d_c;
694 const SadMxNx4Func sad_4x8x4d_c = vp9_sad4x8x4d_c;
695 const SadMxNx4Func sad_4x4x4d_c = vp9_sad4x4x4d_c;
696 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values(
697 make_tuple(64, 64, sad_64x64x4d_c, -1),
698 make_tuple(64, 32, sad_64x32x4d_c, -1),
699 make_tuple(32, 64, sad_32x64x4d_c, -1),
700 make_tuple(32, 32, sad_32x32x4d_c, -1),
701 make_tuple(32, 16, sad_32x16x4d_c, -1),
702 make_tuple(16, 32, sad_16x32x4d_c, -1),
703 make_tuple(16, 16, sad_16x16x4d_c, -1),
704 make_tuple(16, 8, sad_16x8x4d_c, -1),
705 make_tuple(8, 16, sad_8x16x4d_c, -1),
706 make_tuple(8, 8, sad_8x8x4d_c, -1),
707 make_tuple(8, 4, sad_8x4x4d_c, -1),
708 make_tuple(4, 8, sad_4x8x4d_c, -1),
709 make_tuple(4, 4, sad_4x4x4d_c, -1)));
711 #if CONFIG_VP9_HIGHBITDEPTH
712 const SadMxNVp9Func highbd_sad_64x64_c_vp9 = vp9_highbd_sad64x64_c;
713 const SadMxNVp9Func highbd_sad_32x32_c_vp9 = vp9_highbd_sad32x32_c;
714 const SadMxNVp9Func highbd_sad_16x16_c_vp9 = vp9_highbd_sad16x16_c;
715 const SadMxNVp9Func highbd_sad_8x16_c_vp9 = vp9_highbd_sad8x16_c;
716 const SadMxNVp9Func highbd_sad_16x8_c_vp9 = vp9_highbd_sad16x8_c;
717 const SadMxNVp9Func highbd_sad_8x8_c_vp9 = vp9_highbd_sad8x8_c;
718 const SadMxNVp9Func highbd_sad_8x4_c_vp9 = vp9_highbd_sad8x4_c;
719 const SadMxNVp9Func highbd_sad_4x8_c_vp9 = vp9_highbd_sad4x8_c;
720 const SadMxNVp9Func highbd_sad_4x4_c_vp9 = vp9_highbd_sad4x4_c;
721 const SadMxNVp9Param c_vp9_highbd_8_tests[] = {
722 make_tuple(64, 64, highbd_sad_64x64_c_vp9, 8),
723 make_tuple(32, 32, highbd_sad_32x32_c_vp9, 8),
724 make_tuple(16, 16, highbd_sad_16x16_c_vp9, 8),
725 make_tuple(8, 16, highbd_sad_8x16_c_vp9, 8),
726 make_tuple(16, 8, highbd_sad_16x8_c_vp9, 8),
727 make_tuple(8, 8, highbd_sad_8x8_c_vp9, 8),
728 make_tuple(8, 4, highbd_sad_8x4_c_vp9, 8),
729 make_tuple(4, 8, highbd_sad_4x8_c_vp9, 8),
730 make_tuple(4, 4, highbd_sad_4x4_c_vp9, 8),
732 INSTANTIATE_TEST_CASE_P(C_8, SADVP9Test,
733 ::testing::ValuesIn(c_vp9_highbd_8_tests));
735 const SadMxNVp9Param c_vp9_highbd_10_tests[] = {
736 make_tuple(64, 64, highbd_sad_64x64_c_vp9, 10),
737 make_tuple(32, 32, highbd_sad_32x32_c_vp9, 10),
738 make_tuple(16, 16, highbd_sad_16x16_c_vp9, 10),
739 make_tuple(8, 16, highbd_sad_8x16_c_vp9, 10),
740 make_tuple(16, 8, highbd_sad_16x8_c_vp9, 10),
741 make_tuple(8, 8, highbd_sad_8x8_c_vp9, 10),
742 make_tuple(8, 4, highbd_sad_8x4_c_vp9, 10),
743 make_tuple(4, 8, highbd_sad_4x8_c_vp9, 10),
744 make_tuple(4, 4, highbd_sad_4x4_c_vp9, 10),
746 INSTANTIATE_TEST_CASE_P(C_10, SADVP9Test,
747 ::testing::ValuesIn(c_vp9_highbd_10_tests));
749 const SadMxNVp9Param c_vp9_highbd_12_tests[] = {
750 make_tuple(64, 64, highbd_sad_64x64_c_vp9, 12),
751 make_tuple(32, 32, highbd_sad_32x32_c_vp9, 12),
752 make_tuple(16, 16, highbd_sad_16x16_c_vp9, 12),
753 make_tuple(8, 16, highbd_sad_8x16_c_vp9, 12),
754 make_tuple(16, 8, highbd_sad_16x8_c_vp9, 12),
755 make_tuple(8, 8, highbd_sad_8x8_c_vp9, 12),
756 make_tuple(8, 4, highbd_sad_8x4_c_vp9, 12),
757 make_tuple(4, 8, highbd_sad_4x8_c_vp9, 12),
758 make_tuple(4, 4, highbd_sad_4x4_c_vp9, 12),
760 INSTANTIATE_TEST_CASE_P(C_12, SADVP9Test,
761 ::testing::ValuesIn(c_vp9_highbd_12_tests));
763 const SadMxNAvgVp9Func highbd_sad8x4_avg_c_vp9 = vp9_highbd_sad8x4_avg_c;
764 const SadMxNAvgVp9Func highbd_sad8x8_avg_c_vp9 = vp9_highbd_sad8x8_avg_c;
765 const SadMxNAvgVp9Func highbd_sad8x16_avg_c_vp9 = vp9_highbd_sad8x16_avg_c;
766 const SadMxNAvgVp9Func highbd_sad16x8_avg_c_vp9 = vp9_highbd_sad16x8_avg_c;
767 const SadMxNAvgVp9Func highbd_sad16x16_avg_c_vp9 = vp9_highbd_sad16x16_avg_c;
768 const SadMxNAvgVp9Func highbd_sad16x32_avg_c_vp9 = vp9_highbd_sad16x32_avg_c;
769 const SadMxNAvgVp9Func highbd_sad32x16_avg_c_vp9 = vp9_highbd_sad32x16_avg_c;
770 const SadMxNAvgVp9Func highbd_sad32x32_avg_c_vp9 = vp9_highbd_sad32x32_avg_c;
771 const SadMxNAvgVp9Func highbd_sad32x64_avg_c_vp9 = vp9_highbd_sad32x64_avg_c;
772 const SadMxNAvgVp9Func highbd_sad64x32_avg_c_vp9 = vp9_highbd_sad64x32_avg_c;
773 const SadMxNAvgVp9Func highbd_sad64x64_avg_c_vp9 = vp9_highbd_sad64x64_avg_c;
774 SadMxNAvgVp9Param avg_c_vp9_highbd_8_tests[] = {
775 make_tuple(8, 4, highbd_sad8x4_avg_c_vp9, 8),
776 make_tuple(8, 8, highbd_sad8x8_avg_c_vp9, 8),
777 make_tuple(8, 16, highbd_sad8x16_avg_c_vp9, 8),
778 make_tuple(16, 8, highbd_sad16x8_avg_c_vp9, 8),
779 make_tuple(16, 16, highbd_sad16x16_avg_c_vp9, 8),
780 make_tuple(16, 32, highbd_sad16x32_avg_c_vp9, 8),
781 make_tuple(32, 16, highbd_sad32x16_avg_c_vp9, 8),
782 make_tuple(32, 32, highbd_sad32x32_avg_c_vp9, 8),
783 make_tuple(32, 64, highbd_sad32x64_avg_c_vp9, 8),
784 make_tuple(64, 32, highbd_sad64x32_avg_c_vp9, 8),
785 make_tuple(64, 64, highbd_sad64x64_avg_c_vp9, 8)};
786 INSTANTIATE_TEST_CASE_P(C_8, SADavgVP9Test,
787 ::testing::ValuesIn(avg_c_vp9_highbd_8_tests));
789 SadMxNAvgVp9Param avg_c_vp9_highbd_10_tests[] = {
790 make_tuple(8, 4, highbd_sad8x4_avg_c_vp9, 10),
791 make_tuple(8, 8, highbd_sad8x8_avg_c_vp9, 10),
792 make_tuple(8, 16, highbd_sad8x16_avg_c_vp9, 10),
793 make_tuple(16, 8, highbd_sad16x8_avg_c_vp9, 10),
794 make_tuple(16, 16, highbd_sad16x16_avg_c_vp9, 10),
795 make_tuple(16, 32, highbd_sad16x32_avg_c_vp9, 10),
796 make_tuple(32, 16, highbd_sad32x16_avg_c_vp9, 10),
797 make_tuple(32, 32, highbd_sad32x32_avg_c_vp9, 10),
798 make_tuple(32, 64, highbd_sad32x64_avg_c_vp9, 10),
799 make_tuple(64, 32, highbd_sad64x32_avg_c_vp9, 10),
800 make_tuple(64, 64, highbd_sad64x64_avg_c_vp9, 10)};
801 INSTANTIATE_TEST_CASE_P(C_10, SADavgVP9Test,
802 ::testing::ValuesIn(avg_c_vp9_highbd_10_tests));
804 SadMxNAvgVp9Param avg_c_vp9_highbd_12_tests[] = {
805 make_tuple(8, 4, highbd_sad8x4_avg_c_vp9, 12),
806 make_tuple(8, 8, highbd_sad8x8_avg_c_vp9, 12),
807 make_tuple(8, 16, highbd_sad8x16_avg_c_vp9, 12),
808 make_tuple(16, 8, highbd_sad16x8_avg_c_vp9, 12),
809 make_tuple(16, 16, highbd_sad16x16_avg_c_vp9, 12),
810 make_tuple(16, 32, highbd_sad16x32_avg_c_vp9, 12),
811 make_tuple(32, 16, highbd_sad32x16_avg_c_vp9, 12),
812 make_tuple(32, 32, highbd_sad32x32_avg_c_vp9, 12),
813 make_tuple(32, 64, highbd_sad32x64_avg_c_vp9, 12),
814 make_tuple(64, 32, highbd_sad64x32_avg_c_vp9, 12),
815 make_tuple(64, 64, highbd_sad64x64_avg_c_vp9, 12)};
816 INSTANTIATE_TEST_CASE_P(C_12, SADavgVP9Test,
817 ::testing::ValuesIn(avg_c_vp9_highbd_12_tests));
819 const SadMxNx4Func highbd_sad_64x64x4d_c = vp9_highbd_sad64x64x4d_c;
820 const SadMxNx4Func highbd_sad_64x32x4d_c = vp9_highbd_sad64x32x4d_c;
821 const SadMxNx4Func highbd_sad_32x64x4d_c = vp9_highbd_sad32x64x4d_c;
822 const SadMxNx4Func highbd_sad_32x32x4d_c = vp9_highbd_sad32x32x4d_c;
823 const SadMxNx4Func highbd_sad_32x16x4d_c = vp9_highbd_sad32x16x4d_c;
824 const SadMxNx4Func highbd_sad_16x32x4d_c = vp9_highbd_sad16x32x4d_c;
825 const SadMxNx4Func highbd_sad_16x16x4d_c = vp9_highbd_sad16x16x4d_c;
826 const SadMxNx4Func highbd_sad_16x8x4d_c = vp9_highbd_sad16x8x4d_c;
827 const SadMxNx4Func highbd_sad_8x16x4d_c = vp9_highbd_sad8x16x4d_c;
828 const SadMxNx4Func highbd_sad_8x8x4d_c = vp9_highbd_sad8x8x4d_c;
829 const SadMxNx4Func highbd_sad_8x4x4d_c = vp9_highbd_sad8x4x4d_c;
830 const SadMxNx4Func highbd_sad_4x8x4d_c = vp9_highbd_sad4x8x4d_c;
831 const SadMxNx4Func highbd_sad_4x4x4d_c = vp9_highbd_sad4x4x4d_c;
832 INSTANTIATE_TEST_CASE_P(C_8, SADx4Test, ::testing::Values(
833 make_tuple(64, 64, highbd_sad_64x64x4d_c, 8),
834 make_tuple(64, 32, highbd_sad_64x32x4d_c, 8),
835 make_tuple(32, 64, highbd_sad_32x64x4d_c, 8),
836 make_tuple(32, 32, highbd_sad_32x32x4d_c, 8),
837 make_tuple(32, 16, highbd_sad_32x16x4d_c, 8),
838 make_tuple(16, 32, highbd_sad_16x32x4d_c, 8),
839 make_tuple(16, 16, highbd_sad_16x16x4d_c, 8),
840 make_tuple(16, 8, highbd_sad_16x8x4d_c, 8),
841 make_tuple(8, 16, highbd_sad_8x16x4d_c, 8),
842 make_tuple(8, 8, highbd_sad_8x8x4d_c, 8),
843 make_tuple(8, 4, highbd_sad_8x4x4d_c, 8),
844 make_tuple(4, 8, highbd_sad_4x8x4d_c, 8),
845 make_tuple(4, 4, highbd_sad_4x4x4d_c, 8)));
847 INSTANTIATE_TEST_CASE_P(C_10, SADx4Test, ::testing::Values(
848 make_tuple(64, 64, highbd_sad_64x64x4d_c, 10),
849 make_tuple(64, 32, highbd_sad_64x32x4d_c, 10),
850 make_tuple(32, 64, highbd_sad_32x64x4d_c, 10),
851 make_tuple(32, 32, highbd_sad_32x32x4d_c, 10),
852 make_tuple(32, 16, highbd_sad_32x16x4d_c, 10),
853 make_tuple(16, 32, highbd_sad_16x32x4d_c, 10),
854 make_tuple(16, 16, highbd_sad_16x16x4d_c, 10),
855 make_tuple(16, 8, highbd_sad_16x8x4d_c, 10),
856 make_tuple(8, 16, highbd_sad_8x16x4d_c, 10),
857 make_tuple(8, 8, highbd_sad_8x8x4d_c, 10),
858 make_tuple(8, 4, highbd_sad_8x4x4d_c, 10),
859 make_tuple(4, 8, highbd_sad_4x8x4d_c, 10),
860 make_tuple(4, 4, highbd_sad_4x4x4d_c, 10)));
862 INSTANTIATE_TEST_CASE_P(C_12, SADx4Test, ::testing::Values(
863 make_tuple(64, 64, highbd_sad_64x64x4d_c, 12),
864 make_tuple(64, 32, highbd_sad_64x32x4d_c, 12),
865 make_tuple(32, 64, highbd_sad_32x64x4d_c, 12),
866 make_tuple(32, 32, highbd_sad_32x32x4d_c, 12),
867 make_tuple(32, 16, highbd_sad_32x16x4d_c, 12),
868 make_tuple(16, 32, highbd_sad_16x32x4d_c, 12),
869 make_tuple(16, 16, highbd_sad_16x16x4d_c, 12),
870 make_tuple(16, 8, highbd_sad_16x8x4d_c, 12),
871 make_tuple(8, 16, highbd_sad_8x16x4d_c, 12),
872 make_tuple(8, 8, highbd_sad_8x8x4d_c, 12),
873 make_tuple(8, 4, highbd_sad_8x4x4d_c, 12),
874 make_tuple(4, 8, highbd_sad_4x8x4d_c, 12),
875 make_tuple(4, 4, highbd_sad_4x4x4d_c, 12)));
876 #endif // CONFIG_VP9_HIGHBITDEPTH
877 #endif // CONFIG_VP9_ENCODER
879 //------------------------------------------------------------------------------
882 #if CONFIG_VP8_ENCODER
883 const SadMxNFunc sad_16x16_armv6 = vp8_sad16x16_armv6;
884 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values(
885 make_tuple(16, 16, sad_16x16_armv6, -1)));
886 #endif // CONFIG_VP8_ENCODER
890 #if CONFIG_VP8_ENCODER
891 const SadMxNFunc sad_16x16_neon = vp8_sad16x16_neon;
892 const SadMxNFunc sad_8x16_neon = vp8_sad8x16_neon;
893 const SadMxNFunc sad_16x8_neon = vp8_sad16x8_neon;
894 const SadMxNFunc sad_8x8_neon = vp8_sad8x8_neon;
895 const SadMxNFunc sad_4x4_neon = vp8_sad4x4_neon;
896 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values(
897 make_tuple(16, 16, sad_16x16_neon, -1),
898 make_tuple(8, 16, sad_8x16_neon, -1),
899 make_tuple(16, 8, sad_16x8_neon, -1),
900 make_tuple(8, 8, sad_8x8_neon, -1),
901 make_tuple(4, 4, sad_4x4_neon, -1)));
902 #endif // CONFIG_VP8_ENCODER
903 #if CONFIG_VP9_ENCODER
904 const SadMxNVp9Func sad_64x64_neon_vp9 = vp9_sad64x64_neon;
905 const SadMxNVp9Func sad_32x32_neon_vp9 = vp9_sad32x32_neon;
906 const SadMxNVp9Func sad_16x16_neon_vp9 = vp9_sad16x16_neon;
907 const SadMxNVp9Func sad_8x8_neon_vp9 = vp9_sad8x8_neon;
908 const SadMxNVp9Param neon_vp9_tests[] = {
909 make_tuple(64, 64, sad_64x64_neon_vp9, -1),
910 make_tuple(32, 32, sad_32x32_neon_vp9, -1),
911 make_tuple(16, 16, sad_16x16_neon_vp9, -1),
912 make_tuple(8, 8, sad_8x8_neon_vp9, -1),
914 INSTANTIATE_TEST_CASE_P(NEON, SADVP9Test, ::testing::ValuesIn(neon_vp9_tests));
915 #endif // CONFIG_VP9_ENCODER
918 //------------------------------------------------------------------------------
921 #if CONFIG_VP8_ENCODER
922 const SadMxNFunc sad_16x16_mmx = vp8_sad16x16_mmx;
923 const SadMxNFunc sad_8x16_mmx = vp8_sad8x16_mmx;
924 const SadMxNFunc sad_16x8_mmx = vp8_sad16x8_mmx;
925 const SadMxNFunc sad_8x8_mmx = vp8_sad8x8_mmx;
926 const SadMxNFunc sad_4x4_mmx = vp8_sad4x4_mmx;
927 const SadMxNParam mmx_tests[] = {
928 make_tuple(16, 16, sad_16x16_mmx, -1),
929 make_tuple(8, 16, sad_8x16_mmx, -1),
930 make_tuple(16, 8, sad_16x8_mmx, -1),
931 make_tuple(8, 8, sad_8x8_mmx, -1),
932 make_tuple(4, 4, sad_4x4_mmx, -1),
934 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests));
935 #endif // CONFIG_VP8_ENCODER
940 #if CONFIG_VP9_ENCODER
941 #if CONFIG_USE_X86INC
942 const SadMxNVp9Func sad_4x4_sse_vp9 = vp9_sad4x4_sse;
943 const SadMxNVp9Func sad_4x8_sse_vp9 = vp9_sad4x8_sse;
944 INSTANTIATE_TEST_CASE_P(SSE, SADVP9Test, ::testing::Values(
945 make_tuple(4, 4, sad_4x4_sse_vp9, -1),
946 make_tuple(4, 8, sad_4x8_sse_vp9, -1)));
948 const SadMxNx4Func sad_4x8x4d_sse = vp9_sad4x8x4d_sse;
949 const SadMxNx4Func sad_4x4x4d_sse = vp9_sad4x4x4d_sse;
950 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::Values(
951 make_tuple(4, 8, sad_4x8x4d_sse, -1),
952 make_tuple(4, 4, sad_4x4x4d_sse, -1)));
953 #endif // CONFIG_USE_X86INC
954 #endif // CONFIG_VP9_ENCODER
958 #if CONFIG_VP8_ENCODER
959 const SadMxNFunc sad_16x16_wmt = vp8_sad16x16_wmt;
960 const SadMxNFunc sad_8x16_wmt = vp8_sad8x16_wmt;
961 const SadMxNFunc sad_16x8_wmt = vp8_sad16x8_wmt;
962 const SadMxNFunc sad_8x8_wmt = vp8_sad8x8_wmt;
963 const SadMxNFunc sad_4x4_wmt = vp8_sad4x4_wmt;
964 const SadMxNParam sse2_tests[] = {
965 make_tuple(16, 16, sad_16x16_wmt, -1),
966 make_tuple(8, 16, sad_8x16_wmt, -1),
967 make_tuple(16, 8, sad_16x8_wmt, -1),
968 make_tuple(8, 8, sad_8x8_wmt, -1),
969 make_tuple(4, 4, sad_4x4_wmt, -1),
971 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
972 #endif // CONFIG_VP8_ENCODER
974 #if CONFIG_VP9_ENCODER
975 #if CONFIG_USE_X86INC
976 const SadMxNVp9Func sad_64x64_sse2_vp9 = vp9_sad64x64_sse2;
977 const SadMxNVp9Func sad_64x32_sse2_vp9 = vp9_sad64x32_sse2;
978 const SadMxNVp9Func sad_32x64_sse2_vp9 = vp9_sad32x64_sse2;
979 const SadMxNVp9Func sad_32x32_sse2_vp9 = vp9_sad32x32_sse2;
980 const SadMxNVp9Func sad_32x16_sse2_vp9 = vp9_sad32x16_sse2;
981 const SadMxNVp9Func sad_16x32_sse2_vp9 = vp9_sad16x32_sse2;
982 const SadMxNVp9Func sad_16x16_sse2_vp9 = vp9_sad16x16_sse2;
983 const SadMxNVp9Func sad_16x8_sse2_vp9 = vp9_sad16x8_sse2;
984 const SadMxNVp9Func sad_8x16_sse2_vp9 = vp9_sad8x16_sse2;
985 const SadMxNVp9Func sad_8x8_sse2_vp9 = vp9_sad8x8_sse2;
986 const SadMxNVp9Func sad_8x4_sse2_vp9 = vp9_sad8x4_sse2;
988 const SadMxNx4Func sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2;
989 const SadMxNx4Func sad_64x32x4d_sse2 = vp9_sad64x32x4d_sse2;
990 const SadMxNx4Func sad_32x64x4d_sse2 = vp9_sad32x64x4d_sse2;
991 const SadMxNx4Func sad_32x32x4d_sse2 = vp9_sad32x32x4d_sse2;
992 const SadMxNx4Func sad_32x16x4d_sse2 = vp9_sad32x16x4d_sse2;
993 const SadMxNx4Func sad_16x32x4d_sse2 = vp9_sad16x32x4d_sse2;
994 const SadMxNx4Func sad_16x16x4d_sse2 = vp9_sad16x16x4d_sse2;
995 const SadMxNx4Func sad_16x8x4d_sse2 = vp9_sad16x8x4d_sse2;
996 const SadMxNx4Func sad_8x16x4d_sse2 = vp9_sad8x16x4d_sse2;
997 const SadMxNx4Func sad_8x8x4d_sse2 = vp9_sad8x8x4d_sse2;
998 const SadMxNx4Func sad_8x4x4d_sse2 = vp9_sad8x4x4d_sse2;
1000 #if CONFIG_VP9_HIGHBITDEPTH
1001 const SadMxNVp9Func highbd_sad8x4_sse2_vp9 = vp9_highbd_sad8x4_sse2;
1002 const SadMxNVp9Func highbd_sad8x8_sse2_vp9 = vp9_highbd_sad8x8_sse2;
1003 const SadMxNVp9Func highbd_sad8x16_sse2_vp9 = vp9_highbd_sad8x16_sse2;
1004 const SadMxNVp9Func highbd_sad16x8_sse2_vp9 = vp9_highbd_sad16x8_sse2;
1005 const SadMxNVp9Func highbd_sad16x16_sse2_vp9 = vp9_highbd_sad16x16_sse2;
1006 const SadMxNVp9Func highbd_sad16x32_sse2_vp9 = vp9_highbd_sad16x32_sse2;
1007 const SadMxNVp9Func highbd_sad32x16_sse2_vp9 = vp9_highbd_sad32x16_sse2;
1008 const SadMxNVp9Func highbd_sad32x32_sse2_vp9 = vp9_highbd_sad32x32_sse2;
1009 const SadMxNVp9Func highbd_sad32x64_sse2_vp9 = vp9_highbd_sad32x64_sse2;
1010 const SadMxNVp9Func highbd_sad64x32_sse2_vp9 = vp9_highbd_sad64x32_sse2;
1011 const SadMxNVp9Func highbd_sad64x64_sse2_vp9 = vp9_highbd_sad64x64_sse2;
1013 INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::Values(
1014 make_tuple(64, 64, sad_64x64_sse2_vp9, -1),
1015 make_tuple(64, 32, sad_64x32_sse2_vp9, -1),
1016 make_tuple(32, 64, sad_32x64_sse2_vp9, -1),
1017 make_tuple(32, 32, sad_32x32_sse2_vp9, -1),
1018 make_tuple(32, 16, sad_32x16_sse2_vp9, -1),
1019 make_tuple(16, 32, sad_16x32_sse2_vp9, -1),
1020 make_tuple(16, 16, sad_16x16_sse2_vp9, -1),
1021 make_tuple(16, 8, sad_16x8_sse2_vp9, -1),
1022 make_tuple(8, 16, sad_8x16_sse2_vp9, -1),
1023 make_tuple(8, 8, sad_8x8_sse2_vp9, -1),
1024 make_tuple(8, 4, sad_8x4_sse2_vp9, -1),
1025 make_tuple(8, 4, highbd_sad8x4_sse2_vp9, 8),
1026 make_tuple(8, 8, highbd_sad8x8_sse2_vp9, 8),
1027 make_tuple(8, 16, highbd_sad8x16_sse2_vp9, 8),
1028 make_tuple(16, 8, highbd_sad16x8_sse2_vp9, 8),
1029 make_tuple(16, 16, highbd_sad16x16_sse2_vp9, 8),
1030 make_tuple(16, 32, highbd_sad16x32_sse2_vp9, 8),
1031 make_tuple(32, 16, highbd_sad32x16_sse2_vp9, 8),
1032 make_tuple(32, 32, highbd_sad32x32_sse2_vp9, 8),
1033 make_tuple(32, 64, highbd_sad32x64_sse2_vp9, 8),
1034 make_tuple(64, 32, highbd_sad64x32_sse2_vp9, 8),
1035 make_tuple(64, 64, highbd_sad64x64_sse2_vp9, 8),
1036 make_tuple(8, 4, highbd_sad8x4_sse2_vp9, 10),
1037 make_tuple(8, 8, highbd_sad8x8_sse2_vp9, 10),
1038 make_tuple(8, 16, highbd_sad8x16_sse2_vp9, 10),
1039 make_tuple(16, 8, highbd_sad16x8_sse2_vp9, 10),
1040 make_tuple(16, 16, highbd_sad16x16_sse2_vp9, 10),
1041 make_tuple(16, 32, highbd_sad16x32_sse2_vp9, 10),
1042 make_tuple(32, 16, highbd_sad32x16_sse2_vp9, 10),
1043 make_tuple(32, 32, highbd_sad32x32_sse2_vp9, 10),
1044 make_tuple(32, 64, highbd_sad32x64_sse2_vp9, 10),
1045 make_tuple(64, 32, highbd_sad64x32_sse2_vp9, 10),
1046 make_tuple(64, 64, highbd_sad64x64_sse2_vp9, 10),
1047 make_tuple(8, 4, highbd_sad8x4_sse2_vp9, 12),
1048 make_tuple(8, 8, highbd_sad8x8_sse2_vp9, 12),
1049 make_tuple(8, 16, highbd_sad8x16_sse2_vp9, 12),
1050 make_tuple(16, 8, highbd_sad16x8_sse2_vp9, 12),
1051 make_tuple(16, 16, highbd_sad16x16_sse2_vp9, 12),
1052 make_tuple(16, 32, highbd_sad16x32_sse2_vp9, 12),
1053 make_tuple(32, 16, highbd_sad32x16_sse2_vp9, 12),
1054 make_tuple(32, 32, highbd_sad32x32_sse2_vp9, 12),
1055 make_tuple(32, 64, highbd_sad32x64_sse2_vp9, 12),
1056 make_tuple(64, 32, highbd_sad64x32_sse2_vp9, 12),
1057 make_tuple(64, 64, highbd_sad64x64_sse2_vp9, 12)));
1059 const SadMxNAvgVp9Func highbd_sad8x4_avg_sse2_vp9 = vp9_highbd_sad8x4_avg_sse2;
1060 const SadMxNAvgVp9Func highbd_sad8x8_avg_sse2_vp9 = vp9_highbd_sad8x8_avg_sse2;
1061 const SadMxNAvgVp9Func highbd_sad8x16_avg_sse2_vp9 =
1062 vp9_highbd_sad8x16_avg_sse2;
1063 const SadMxNAvgVp9Func highbd_sad16x8_avg_sse2_vp9 =
1064 vp9_highbd_sad16x8_avg_sse2;
1065 const SadMxNAvgVp9Func highbd_sad16x16_avg_sse2_vp9 =
1066 vp9_highbd_sad16x16_avg_sse2;
1067 const SadMxNAvgVp9Func highbd_sad16x32_avg_sse2_vp9 =
1068 vp9_highbd_sad16x32_avg_sse2;
1069 const SadMxNAvgVp9Func highbd_sad32x16_avg_sse2_vp9 =
1070 vp9_highbd_sad32x16_avg_sse2;
1071 const SadMxNAvgVp9Func highbd_sad32x32_avg_sse2_vp9 =
1072 vp9_highbd_sad32x32_avg_sse2;
1073 const SadMxNAvgVp9Func highbd_sad32x64_avg_sse2_vp9 =
1074 vp9_highbd_sad32x64_avg_sse2;
1075 const SadMxNAvgVp9Func highbd_sad64x32_avg_sse2_vp9 =
1076 vp9_highbd_sad64x32_avg_sse2;
1077 const SadMxNAvgVp9Func highbd_sad64x64_avg_sse2_vp9 =
1078 vp9_highbd_sad64x64_avg_sse2;
1080 INSTANTIATE_TEST_CASE_P(SSE2, SADavgVP9Test, ::testing::Values(
1081 make_tuple(8, 4, highbd_sad8x4_avg_sse2_vp9, 8),
1082 make_tuple(8, 8, highbd_sad8x8_avg_sse2_vp9, 8),
1083 make_tuple(8, 16, highbd_sad8x16_avg_sse2_vp9, 8),
1084 make_tuple(16, 8, highbd_sad16x8_avg_sse2_vp9, 8),
1085 make_tuple(16, 16, highbd_sad16x16_avg_sse2_vp9, 8),
1086 make_tuple(16, 32, highbd_sad16x32_avg_sse2_vp9, 8),
1087 make_tuple(32, 16, highbd_sad32x16_avg_sse2_vp9, 8),
1088 make_tuple(32, 32, highbd_sad32x32_avg_sse2_vp9, 8),
1089 make_tuple(32, 64, highbd_sad32x64_avg_sse2_vp9, 8),
1090 make_tuple(64, 32, highbd_sad64x32_avg_sse2_vp9, 8),
1091 make_tuple(64, 64, highbd_sad64x64_avg_sse2_vp9, 8),
1092 make_tuple(8, 4, highbd_sad8x4_avg_sse2_vp9, 10),
1093 make_tuple(8, 8, highbd_sad8x8_avg_sse2_vp9, 10),
1094 make_tuple(8, 16, highbd_sad8x16_avg_sse2_vp9, 10),
1095 make_tuple(16, 8, highbd_sad16x8_avg_sse2_vp9, 10),
1096 make_tuple(16, 16, highbd_sad16x16_avg_sse2_vp9, 10),
1097 make_tuple(16, 32, highbd_sad16x32_avg_sse2_vp9, 10),
1098 make_tuple(32, 16, highbd_sad32x16_avg_sse2_vp9, 10),
1099 make_tuple(32, 32, highbd_sad32x32_avg_sse2_vp9, 10),
1100 make_tuple(32, 64, highbd_sad32x64_avg_sse2_vp9, 10),
1101 make_tuple(64, 32, highbd_sad64x32_avg_sse2_vp9, 10),
1102 make_tuple(64, 64, highbd_sad64x64_avg_sse2_vp9, 10),
1103 make_tuple(8, 4, highbd_sad8x4_avg_sse2_vp9, 12),
1104 make_tuple(8, 8, highbd_sad8x8_avg_sse2_vp9, 12),
1105 make_tuple(8, 16, highbd_sad8x16_avg_sse2_vp9, 12),
1106 make_tuple(16, 8, highbd_sad16x8_avg_sse2_vp9, 12),
1107 make_tuple(16, 16, highbd_sad16x16_avg_sse2_vp9, 12),
1108 make_tuple(16, 32, highbd_sad16x32_avg_sse2_vp9, 12),
1109 make_tuple(32, 16, highbd_sad32x16_avg_sse2_vp9, 12),
1110 make_tuple(32, 32, highbd_sad32x32_avg_sse2_vp9, 12),
1111 make_tuple(32, 64, highbd_sad32x64_avg_sse2_vp9, 12),
1112 make_tuple(64, 32, highbd_sad64x32_avg_sse2_vp9, 12),
1113 make_tuple(64, 64, highbd_sad64x64_avg_sse2_vp9, 12)));
1115 const SadMxNx4Func highbd_sad_64x64x4d_sse2 = vp9_highbd_sad64x64x4d_sse2;
1116 const SadMxNx4Func highbd_sad_64x32x4d_sse2 = vp9_highbd_sad64x32x4d_sse2;
1117 const SadMxNx4Func highbd_sad_32x64x4d_sse2 = vp9_highbd_sad32x64x4d_sse2;
1118 const SadMxNx4Func highbd_sad_32x32x4d_sse2 = vp9_highbd_sad32x32x4d_sse2;
1119 const SadMxNx4Func highbd_sad_32x16x4d_sse2 = vp9_highbd_sad32x16x4d_sse2;
1120 const SadMxNx4Func highbd_sad_16x32x4d_sse2 = vp9_highbd_sad16x32x4d_sse2;
1121 const SadMxNx4Func highbd_sad_16x16x4d_sse2 = vp9_highbd_sad16x16x4d_sse2;
1122 const SadMxNx4Func highbd_sad_16x8x4d_sse2 = vp9_highbd_sad16x8x4d_sse2;
1123 const SadMxNx4Func highbd_sad_8x16x4d_sse2 = vp9_highbd_sad8x16x4d_sse2;
1124 const SadMxNx4Func highbd_sad_8x8x4d_sse2 = vp9_highbd_sad8x8x4d_sse2;
1125 const SadMxNx4Func highbd_sad_8x4x4d_sse2 = vp9_highbd_sad8x4x4d_sse2;
1126 const SadMxNx4Func highbd_sad_4x8x4d_sse2 = vp9_highbd_sad4x8x4d_sse2;
1127 const SadMxNx4Func highbd_sad_4x4x4d_sse2 = vp9_highbd_sad4x4x4d_sse2;
1129 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values(
1130 make_tuple(64, 64, sad_64x64x4d_sse2, -1),
1131 make_tuple(64, 32, sad_64x32x4d_sse2, -1),
1132 make_tuple(32, 64, sad_32x64x4d_sse2, -1),
1133 make_tuple(32, 32, sad_32x32x4d_sse2, -1),
1134 make_tuple(32, 16, sad_32x16x4d_sse2, -1),
1135 make_tuple(16, 32, sad_16x32x4d_sse2, -1),
1136 make_tuple(16, 16, sad_16x16x4d_sse2, -1),
1137 make_tuple(16, 8, sad_16x8x4d_sse2, -1),
1138 make_tuple(8, 16, sad_8x16x4d_sse2, -1),
1139 make_tuple(8, 8, sad_8x8x4d_sse2, -1),
1140 make_tuple(8, 4, sad_8x4x4d_sse2, -1),
1141 make_tuple(64, 64, highbd_sad_64x64x4d_sse2, 8),
1142 make_tuple(64, 32, highbd_sad_64x32x4d_sse2, 8),
1143 make_tuple(32, 64, highbd_sad_32x64x4d_sse2, 8),
1144 make_tuple(32, 32, highbd_sad_32x32x4d_sse2, 8),
1145 make_tuple(32, 16, highbd_sad_32x16x4d_sse2, 8),
1146 make_tuple(16, 32, highbd_sad_16x32x4d_sse2, 8),
1147 make_tuple(16, 16, highbd_sad_16x16x4d_sse2, 8),
1148 make_tuple(16, 8, highbd_sad_16x8x4d_sse2, 8),
1149 make_tuple(8, 16, highbd_sad_8x16x4d_sse2, 8),
1150 make_tuple(8, 8, highbd_sad_8x8x4d_sse2, 8),
1151 make_tuple(8, 4, highbd_sad_8x4x4d_sse2, 8),
1152 make_tuple(4, 8, highbd_sad_4x8x4d_sse2, 8),
1153 make_tuple(4, 4, highbd_sad_4x4x4d_sse2, 8),
1154 make_tuple(64, 64, highbd_sad_64x64x4d_sse2, 10),
1155 make_tuple(64, 32, highbd_sad_64x32x4d_sse2, 10),
1156 make_tuple(32, 64, highbd_sad_32x64x4d_sse2, 10),
1157 make_tuple(32, 32, highbd_sad_32x32x4d_sse2, 10),
1158 make_tuple(32, 16, highbd_sad_32x16x4d_sse2, 10),
1159 make_tuple(16, 32, highbd_sad_16x32x4d_sse2, 10),
1160 make_tuple(16, 16, highbd_sad_16x16x4d_sse2, 10),
1161 make_tuple(16, 8, highbd_sad_16x8x4d_sse2, 10),
1162 make_tuple(8, 16, highbd_sad_8x16x4d_sse2, 10),
1163 make_tuple(8, 8, highbd_sad_8x8x4d_sse2, 10),
1164 make_tuple(8, 4, highbd_sad_8x4x4d_sse2, 10),
1165 make_tuple(4, 8, highbd_sad_4x8x4d_sse2, 10),
1166 make_tuple(4, 4, highbd_sad_4x4x4d_sse2, 10),
1167 make_tuple(64, 64, highbd_sad_64x64x4d_sse2, 12),
1168 make_tuple(64, 32, highbd_sad_64x32x4d_sse2, 12),
1169 make_tuple(32, 64, highbd_sad_32x64x4d_sse2, 12),
1170 make_tuple(32, 32, highbd_sad_32x32x4d_sse2, 12),
1171 make_tuple(32, 16, highbd_sad_32x16x4d_sse2, 12),
1172 make_tuple(16, 32, highbd_sad_16x32x4d_sse2, 12),
1173 make_tuple(16, 16, highbd_sad_16x16x4d_sse2, 12),
1174 make_tuple(16, 8, highbd_sad_16x8x4d_sse2, 12),
1175 make_tuple(8, 16, highbd_sad_8x16x4d_sse2, 12),
1176 make_tuple(8, 8, highbd_sad_8x8x4d_sse2, 12),
1177 make_tuple(8, 4, highbd_sad_8x4x4d_sse2, 12),
1178 make_tuple(4, 8, highbd_sad_4x8x4d_sse2, 12),
1179 make_tuple(4, 4, highbd_sad_4x4x4d_sse2, 12)));
1181 INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::Values(
1182 make_tuple(64, 64, sad_64x64_sse2_vp9, -1),
1183 make_tuple(64, 32, sad_64x32_sse2_vp9, -1),
1184 make_tuple(32, 64, sad_32x64_sse2_vp9, -1),
1185 make_tuple(32, 32, sad_32x32_sse2_vp9, -1),
1186 make_tuple(32, 16, sad_32x16_sse2_vp9, -1),
1187 make_tuple(16, 32, sad_16x32_sse2_vp9, -1),
1188 make_tuple(16, 16, sad_16x16_sse2_vp9, -1),
1189 make_tuple(16, 8, sad_16x8_sse2_vp9, -1),
1190 make_tuple(8, 16, sad_8x16_sse2_vp9, -1),
1191 make_tuple(8, 8, sad_8x8_sse2_vp9, -1),
1192 make_tuple(8, 4, sad_8x4_sse2_vp9, -1)));
1194 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values(
1195 make_tuple(64, 64, sad_64x64x4d_sse2, -1),
1196 make_tuple(64, 32, sad_64x32x4d_sse2, -1),
1197 make_tuple(32, 64, sad_32x64x4d_sse2, -1),
1198 make_tuple(32, 32, sad_32x32x4d_sse2, -1),
1199 make_tuple(32, 16, sad_32x16x4d_sse2, -1),
1200 make_tuple(16, 32, sad_16x32x4d_sse2, -1),
1201 make_tuple(16, 16, sad_16x16x4d_sse2, -1),
1202 make_tuple(16, 8, sad_16x8x4d_sse2, -1),
1203 make_tuple(8, 16, sad_8x16x4d_sse2, -1),
1204 make_tuple(8, 8, sad_8x8x4d_sse2, -1),
1205 make_tuple(8, 4, sad_8x4x4d_sse2, -1)));
1206 #endif // CONFIG_VP9_HIGHBITDEPTH
1207 #endif // CONFIG_USE_X86INC
1208 #endif // CONFIG_VP9_ENCODER
1212 #if CONFIG_VP8_ENCODER
1213 const SadMxNx4Func sad_16x16x4d_sse3 = vp8_sad16x16x4d_sse3;
1214 const SadMxNx4Func sad_16x8x4d_sse3 = vp8_sad16x8x4d_sse3;
1215 const SadMxNx4Func sad_8x16x4d_sse3 = vp8_sad8x16x4d_sse3;
1216 const SadMxNx4Func sad_8x8x4d_sse3 = vp8_sad8x8x4d_sse3;
1217 const SadMxNx4Func sad_4x4x4d_sse3 = vp8_sad4x4x4d_sse3;
1218 INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values(
1219 make_tuple(16, 16, sad_16x16x4d_sse3, -1),
1220 make_tuple(16, 8, sad_16x8x4d_sse3, -1),
1221 make_tuple(8, 16, sad_8x16x4d_sse3, -1),
1222 make_tuple(8, 8, sad_8x8x4d_sse3, -1),
1223 make_tuple(4, 4, sad_4x4x4d_sse3, -1)));
1224 #endif // CONFIG_VP8_ENCODER
1228 #if CONFIG_USE_X86INC
1229 #if CONFIG_VP8_ENCODER
1230 const SadMxNFunc sad_16x16_sse3 = vp8_sad16x16_sse3;
1231 INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values(
1232 make_tuple(16, 16, sad_16x16_sse3, -1)));
1233 #endif // CONFIG_VP8_ENCODER
1234 #endif // CONFIG_USE_X86INC
1235 #endif // HAVE_SSSE3
1237 #if CONFIG_VP9_ENCODER
1239 const SadMxNx4Func sad_64x64x4d_avx2 = vp9_sad64x64x4d_avx2;
1240 const SadMxNx4Func sad_32x32x4d_avx2 = vp9_sad32x32x4d_avx2;
1241 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::Values(
1242 make_tuple(32, 32, sad_32x32x4d_avx2, -1),
1243 make_tuple(64, 64, sad_64x64x4d_avx2, -1)));
1247 const SadMxNx4Func sad_16x16x4d_neon = vp9_sad16x16x4d_neon;
1248 const SadMxNx4Func sad_32x32x4d_neon = vp9_sad32x32x4d_neon;
1249 const SadMxNx4Func sad_64x64x4d_neon = vp9_sad64x64x4d_neon;
1250 INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::Values(
1251 make_tuple(16, 16, sad_16x16x4d_neon, -1),
1252 make_tuple(32, 32, sad_32x32x4d_neon, -1),
1253 make_tuple(64, 64, sad_64x64x4d_neon, -1)));
1255 #endif // CONFIG_VP9_ENCODER