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"
32 #if CONFIG_VP8_ENCODER
33 typedef unsigned int (*SadMxNFunc)(const unsigned char *source_ptr,
35 const unsigned char *reference_ptr,
37 unsigned int max_sad);
38 typedef std::tr1::tuple<int, int, SadMxNFunc> SadMxNParam;
40 #if CONFIG_VP9_ENCODER
41 typedef unsigned int (*SadMxNVp9Func)(const unsigned char *source_ptr,
43 const unsigned char *reference_ptr,
44 int reference_stride);
45 typedef std::tr1::tuple<int, int, SadMxNVp9Func> SadMxNVp9Param;
48 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr,
50 const unsigned char *const ref_ptr[],
52 unsigned int *sad_array);
53 typedef std::tr1::tuple<int, int, SadMxNx4Func> SadMxNx4Param;
55 using libvpx_test::ACMRandom;
58 class SADTestBase : public ::testing::Test {
60 SADTestBase(int width, int height) : width_(width), height_(height) {}
62 static void SetUpTestCase() {
63 source_data_ = reinterpret_cast<uint8_t*>(
64 vpx_memalign(kDataAlignment, kDataBlockSize));
65 reference_data_ = reinterpret_cast<uint8_t*>(
66 vpx_memalign(kDataAlignment, kDataBufferSize));
69 static void TearDownTestCase() {
70 vpx_free(source_data_);
72 vpx_free(reference_data_);
73 reference_data_ = NULL;
76 virtual void TearDown() {
77 libvpx_test::ClearSystemState();
81 // Handle blocks up to 4 blocks 64x64 with stride up to 128
82 static const int kDataAlignment = 16;
83 static const int kDataBlockSize = 64 * 128;
84 static const int kDataBufferSize = 4 * kDataBlockSize;
86 virtual void SetUp() {
87 source_stride_ = (width_ + 31) & ~31;
88 reference_stride_ = width_ * 2;
89 rnd_.Reset(ACMRandom::DeterministicSeed());
92 virtual uint8_t* GetReference(int block_idx) {
93 return reference_data_ + block_idx * kDataBlockSize;
96 // Sum of Absolute Differences. Given two blocks, calculate the absolute
97 // difference between two pixels in the same relative location; accumulate.
98 unsigned int ReferenceSAD(unsigned int max_sad, int block_idx) {
100 const uint8_t* const reference = GetReference(block_idx);
102 for (int h = 0; h < height_; ++h) {
103 for (int w = 0; w < width_; ++w) {
104 sad += abs(source_data_[h * source_stride_ + w]
105 - reference[h * reference_stride_ + w]);
114 void FillConstant(uint8_t *data, int stride, uint8_t fill_constant) {
115 for (int h = 0; h < height_; ++h) {
116 for (int w = 0; w < width_; ++w) {
117 data[h * stride + w] = fill_constant;
122 void FillRandom(uint8_t *data, int stride) {
123 for (int h = 0; h < height_; ++h) {
124 for (int w = 0; w < width_; ++w) {
125 data[h * stride + w] = rnd_.Rand8();
131 static uint8_t* source_data_;
133 static uint8_t* reference_data_;
134 int reference_stride_;
140 : public SADTestBase,
141 public ::testing::WithParamInterface<SadMxNx4Param> {
143 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}
146 void SADs(unsigned int *results) {
147 const uint8_t* refs[] = {GetReference(0), GetReference(1),
148 GetReference(2), GetReference(3)};
150 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
151 refs, reference_stride_,
156 unsigned int reference_sad, exp_sad[4];
159 for (int block = 0; block < 4; ++block) {
160 reference_sad = ReferenceSAD(UINT_MAX, block);
162 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
167 #if CONFIG_VP8_ENCODER
169 : public SADTestBase,
170 public ::testing::WithParamInterface<SadMxNParam> {
172 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}
175 unsigned int SAD(unsigned int max_sad, int block_idx) {
177 const uint8_t* const reference = GetReference(block_idx);
179 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
180 reference, reference_stride_,
185 void CheckSAD(unsigned int max_sad) {
186 const unsigned int reference_sad = ReferenceSAD(max_sad, 0);
187 const unsigned int exp_sad = SAD(max_sad, 0);
189 if (reference_sad <= max_sad) {
190 ASSERT_EQ(exp_sad, reference_sad);
192 // Alternative implementations are not required to check max_sad
193 ASSERT_GE(exp_sad, reference_sad);
197 #endif // CONFIG_VP8_ENCODER
199 #if CONFIG_VP9_ENCODER
201 : public SADTestBase,
202 public ::testing::WithParamInterface<SadMxNVp9Param> {
204 SADVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}
207 unsigned int SAD(int block_idx) {
209 const uint8_t* const reference = GetReference(block_idx);
211 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
212 reference, reference_stride_));
217 const unsigned int reference_sad = ReferenceSAD(UINT_MAX, 0);
218 const unsigned int exp_sad = SAD(0);
220 ASSERT_EQ(reference_sad, exp_sad);
223 #endif // CONFIG_VP9_ENCODER
225 uint8_t* SADTestBase::source_data_ = NULL;
226 uint8_t* SADTestBase::reference_data_ = NULL;
228 #if CONFIG_VP8_ENCODER
229 TEST_P(SADTest, MaxRef) {
230 FillConstant(source_data_, source_stride_, 0);
231 FillConstant(reference_data_, reference_stride_, 255);
235 TEST_P(SADTest, MaxSrc) {
236 FillConstant(source_data_, source_stride_, 255);
237 FillConstant(reference_data_, reference_stride_, 0);
241 TEST_P(SADTest, ShortRef) {
242 int tmp_stride = reference_stride_;
243 reference_stride_ >>= 1;
244 FillRandom(source_data_, source_stride_);
245 FillRandom(reference_data_, reference_stride_);
247 reference_stride_ = tmp_stride;
250 TEST_P(SADTest, UnalignedRef) {
251 // The reference frame, but not the source frame, may be unaligned for
252 // certain types of searches.
253 const int tmp_stride = reference_stride_;
254 reference_stride_ -= 1;
255 FillRandom(source_data_, source_stride_);
256 FillRandom(reference_data_, reference_stride_);
258 reference_stride_ = tmp_stride;
261 TEST_P(SADTest, ShortSrc) {
262 const int tmp_stride = source_stride_;
263 source_stride_ >>= 1;
264 FillRandom(source_data_, source_stride_);
265 FillRandom(reference_data_, reference_stride_);
267 source_stride_ = tmp_stride;
270 TEST_P(SADTest, MaxSAD) {
271 // Verify that, when max_sad is set, the implementation does not return a
272 // value lower than the reference.
273 FillConstant(source_data_, source_stride_, 255);
274 FillConstant(reference_data_, reference_stride_, 0);
277 #endif // CONFIG_VP8_ENCODER
279 #if CONFIG_VP9_ENCODER
280 TEST_P(SADVP9Test, MaxRef) {
281 FillConstant(source_data_, source_stride_, 0);
282 FillConstant(reference_data_, reference_stride_, 255);
286 TEST_P(SADVP9Test, MaxSrc) {
287 FillConstant(source_data_, source_stride_, 255);
288 FillConstant(reference_data_, reference_stride_, 0);
292 TEST_P(SADVP9Test, ShortRef) {
293 const int tmp_stride = reference_stride_;
294 reference_stride_ >>= 1;
295 FillRandom(source_data_, source_stride_);
296 FillRandom(reference_data_, reference_stride_);
298 reference_stride_ = tmp_stride;
301 TEST_P(SADVP9Test, UnalignedRef) {
302 // The reference frame, but not the source frame, may be unaligned for
303 // certain types of searches.
304 const int tmp_stride = reference_stride_;
305 reference_stride_ -= 1;
306 FillRandom(source_data_, source_stride_);
307 FillRandom(reference_data_, reference_stride_);
309 reference_stride_ = tmp_stride;
312 TEST_P(SADVP9Test, ShortSrc) {
313 const int tmp_stride = source_stride_;
314 source_stride_ >>= 1;
315 FillRandom(source_data_, source_stride_);
316 FillRandom(reference_data_, reference_stride_);
318 source_stride_ = tmp_stride;
320 #endif // CONFIG_VP9_ENCODER
322 TEST_P(SADx4Test, MaxRef) {
323 FillConstant(source_data_, source_stride_, 0);
324 FillConstant(GetReference(0), reference_stride_, 255);
325 FillConstant(GetReference(1), reference_stride_, 255);
326 FillConstant(GetReference(2), reference_stride_, 255);
327 FillConstant(GetReference(3), reference_stride_, 255);
331 TEST_P(SADx4Test, MaxSrc) {
332 FillConstant(source_data_, source_stride_, 255);
333 FillConstant(GetReference(0), reference_stride_, 0);
334 FillConstant(GetReference(1), reference_stride_, 0);
335 FillConstant(GetReference(2), reference_stride_, 0);
336 FillConstant(GetReference(3), reference_stride_, 0);
340 TEST_P(SADx4Test, ShortRef) {
341 int tmp_stride = reference_stride_;
342 reference_stride_ >>= 1;
343 FillRandom(source_data_, source_stride_);
344 FillRandom(GetReference(0), reference_stride_);
345 FillRandom(GetReference(1), reference_stride_);
346 FillRandom(GetReference(2), reference_stride_);
347 FillRandom(GetReference(3), reference_stride_);
349 reference_stride_ = tmp_stride;
352 TEST_P(SADx4Test, UnalignedRef) {
353 // The reference frame, but not the source frame, may be unaligned for
354 // certain types of searches.
355 int tmp_stride = reference_stride_;
356 reference_stride_ -= 1;
357 FillRandom(source_data_, source_stride_);
358 FillRandom(GetReference(0), reference_stride_);
359 FillRandom(GetReference(1), reference_stride_);
360 FillRandom(GetReference(2), reference_stride_);
361 FillRandom(GetReference(3), reference_stride_);
363 reference_stride_ = tmp_stride;
366 TEST_P(SADx4Test, ShortSrc) {
367 int tmp_stride = source_stride_;
368 source_stride_ >>= 1;
369 FillRandom(source_data_, source_stride_);
370 FillRandom(GetReference(0), reference_stride_);
371 FillRandom(GetReference(1), reference_stride_);
372 FillRandom(GetReference(2), reference_stride_);
373 FillRandom(GetReference(3), reference_stride_);
375 source_stride_ = tmp_stride;
378 using std::tr1::make_tuple;
380 //------------------------------------------------------------------------------
382 #if CONFIG_VP8_ENCODER
383 const SadMxNFunc sad_16x16_c = vp8_sad16x16_c;
384 const SadMxNFunc sad_8x16_c = vp8_sad8x16_c;
385 const SadMxNFunc sad_16x8_c = vp8_sad16x8_c;
386 const SadMxNFunc sad_8x8_c = vp8_sad8x8_c;
387 const SadMxNFunc sad_4x4_c = vp8_sad4x4_c;
388 const SadMxNParam c_tests[] = {
389 make_tuple(16, 16, sad_16x16_c),
390 make_tuple(8, 16, sad_8x16_c),
391 make_tuple(16, 8, sad_16x8_c),
392 make_tuple(8, 8, sad_8x8_c),
393 make_tuple(4, 4, sad_4x4_c),
395 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
396 #endif // CONFIG_VP8_ENCODER
398 #if CONFIG_VP9_ENCODER
399 const SadMxNVp9Func sad_64x64_c_vp9 = vp9_sad64x64_c;
400 const SadMxNVp9Func sad_32x32_c_vp9 = vp9_sad32x32_c;
401 const SadMxNVp9Func sad_16x16_c_vp9 = vp9_sad16x16_c;
402 const SadMxNVp9Func sad_8x16_c_vp9 = vp9_sad8x16_c;
403 const SadMxNVp9Func sad_16x8_c_vp9 = vp9_sad16x8_c;
404 const SadMxNVp9Func sad_8x8_c_vp9 = vp9_sad8x8_c;
405 const SadMxNVp9Func sad_8x4_c_vp9 = vp9_sad8x4_c;
406 const SadMxNVp9Func sad_4x8_c_vp9 = vp9_sad4x8_c;
407 const SadMxNVp9Func sad_4x4_c_vp9 = vp9_sad4x4_c;
408 const SadMxNVp9Param c_vp9_tests[] = {
409 make_tuple(64, 64, sad_64x64_c_vp9),
410 make_tuple(32, 32, sad_32x32_c_vp9),
411 make_tuple(16, 16, sad_16x16_c_vp9),
412 make_tuple(8, 16, sad_8x16_c_vp9),
413 make_tuple(16, 8, sad_16x8_c_vp9),
414 make_tuple(8, 8, sad_8x8_c_vp9),
415 make_tuple(8, 4, sad_8x4_c_vp9),
416 make_tuple(4, 8, sad_4x8_c_vp9),
417 make_tuple(4, 4, sad_4x4_c_vp9),
419 INSTANTIATE_TEST_CASE_P(C, SADVP9Test, ::testing::ValuesIn(c_vp9_tests));
421 const SadMxNx4Func sad_64x64x4d_c = vp9_sad64x64x4d_c;
422 const SadMxNx4Func sad_64x32x4d_c = vp9_sad64x32x4d_c;
423 const SadMxNx4Func sad_32x64x4d_c = vp9_sad32x64x4d_c;
424 const SadMxNx4Func sad_32x32x4d_c = vp9_sad32x32x4d_c;
425 const SadMxNx4Func sad_32x16x4d_c = vp9_sad32x16x4d_c;
426 const SadMxNx4Func sad_16x32x4d_c = vp9_sad16x32x4d_c;
427 const SadMxNx4Func sad_16x16x4d_c = vp9_sad16x16x4d_c;
428 const SadMxNx4Func sad_16x8x4d_c = vp9_sad16x8x4d_c;
429 const SadMxNx4Func sad_8x16x4d_c = vp9_sad8x16x4d_c;
430 const SadMxNx4Func sad_8x8x4d_c = vp9_sad8x8x4d_c;
431 const SadMxNx4Func sad_8x4x4d_c = vp9_sad8x4x4d_c;
432 const SadMxNx4Func sad_4x8x4d_c = vp9_sad4x8x4d_c;
433 const SadMxNx4Func sad_4x4x4d_c = vp9_sad4x4x4d_c;
434 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values(
435 make_tuple(64, 64, sad_64x64x4d_c),
436 make_tuple(64, 32, sad_64x32x4d_c),
437 make_tuple(32, 64, sad_32x64x4d_c),
438 make_tuple(32, 32, sad_32x32x4d_c),
439 make_tuple(32, 16, sad_32x16x4d_c),
440 make_tuple(16, 32, sad_16x32x4d_c),
441 make_tuple(16, 16, sad_16x16x4d_c),
442 make_tuple(16, 8, sad_16x8x4d_c),
443 make_tuple(8, 16, sad_8x16x4d_c),
444 make_tuple(8, 8, sad_8x8x4d_c),
445 make_tuple(8, 4, sad_8x4x4d_c),
446 make_tuple(4, 8, sad_4x8x4d_c),
447 make_tuple(4, 4, sad_4x4x4d_c)));
448 #endif // CONFIG_VP9_ENCODER
450 //------------------------------------------------------------------------------
453 #if CONFIG_VP8_ENCODER
454 const SadMxNFunc sad_16x16_armv6 = vp8_sad16x16_armv6;
455 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values(
456 make_tuple(16, 16, sad_16x16_armv6)));
457 #endif // CONFIG_VP8_ENCODER
461 #if CONFIG_VP8_ENCODER
462 const SadMxNFunc sad_16x16_neon = vp8_sad16x16_neon;
463 const SadMxNFunc sad_8x16_neon = vp8_sad8x16_neon;
464 const SadMxNFunc sad_16x8_neon = vp8_sad16x8_neon;
465 const SadMxNFunc sad_8x8_neon = vp8_sad8x8_neon;
466 const SadMxNFunc sad_4x4_neon = vp8_sad4x4_neon;
467 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values(
468 make_tuple(16, 16, sad_16x16_neon),
469 make_tuple(8, 16, sad_8x16_neon),
470 make_tuple(16, 8, sad_16x8_neon),
471 make_tuple(8, 8, sad_8x8_neon),
472 make_tuple(4, 4, sad_4x4_neon)));
473 #endif // CONFIG_VP8_ENCODER
474 #if CONFIG_VP9_ENCODER
475 const SadMxNVp9Func sad_64x64_neon_vp9 = vp9_sad64x64_neon;
476 const SadMxNVp9Func sad_32x32_neon_vp9 = vp9_sad32x32_neon;
477 const SadMxNVp9Func sad_16x16_neon_vp9 = vp9_sad16x16_neon;
478 const SadMxNVp9Func sad_8x8_neon_vp9 = vp9_sad8x8_neon;
479 const SadMxNVp9Param neon_vp9_tests[] = {
480 make_tuple(64, 64, sad_64x64_neon_vp9),
481 make_tuple(32, 32, sad_32x32_neon_vp9),
482 make_tuple(16, 16, sad_16x16_neon_vp9),
483 make_tuple(8, 8, sad_8x8_neon_vp9),
485 INSTANTIATE_TEST_CASE_P(NEON, SADVP9Test, ::testing::ValuesIn(neon_vp9_tests));
486 #endif // CONFIG_VP9_ENCODER
489 //------------------------------------------------------------------------------
492 #if CONFIG_VP8_ENCODER
493 const SadMxNFunc sad_16x16_mmx = vp8_sad16x16_mmx;
494 const SadMxNFunc sad_8x16_mmx = vp8_sad8x16_mmx;
495 const SadMxNFunc sad_16x8_mmx = vp8_sad16x8_mmx;
496 const SadMxNFunc sad_8x8_mmx = vp8_sad8x8_mmx;
497 const SadMxNFunc sad_4x4_mmx = vp8_sad4x4_mmx;
498 const SadMxNParam mmx_tests[] = {
499 make_tuple(16, 16, sad_16x16_mmx),
500 make_tuple(8, 16, sad_8x16_mmx),
501 make_tuple(16, 8, sad_16x8_mmx),
502 make_tuple(8, 8, sad_8x8_mmx),
503 make_tuple(4, 4, sad_4x4_mmx),
505 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests));
506 #endif // CONFIG_VP8_ENCODER
511 #if CONFIG_VP9_ENCODER
512 #if CONFIG_USE_X86INC
513 const SadMxNVp9Func sad_4x4_sse_vp9 = vp9_sad4x4_sse;
514 const SadMxNVp9Func sad_4x8_sse_vp9 = vp9_sad4x8_sse;
515 INSTANTIATE_TEST_CASE_P(SSE, SADVP9Test, ::testing::Values(
516 make_tuple(4, 4, sad_4x4_sse_vp9),
517 make_tuple(4, 8, sad_4x8_sse_vp9)));
519 const SadMxNx4Func sad_4x8x4d_sse = vp9_sad4x8x4d_sse;
520 const SadMxNx4Func sad_4x4x4d_sse = vp9_sad4x4x4d_sse;
521 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::Values(
522 make_tuple(4, 8, sad_4x8x4d_sse),
523 make_tuple(4, 4, sad_4x4x4d_sse)));
524 #endif // CONFIG_USE_X86INC
525 #endif // CONFIG_VP9_ENCODER
529 #if CONFIG_VP8_ENCODER
530 const SadMxNFunc sad_16x16_wmt = vp8_sad16x16_wmt;
531 const SadMxNFunc sad_8x16_wmt = vp8_sad8x16_wmt;
532 const SadMxNFunc sad_16x8_wmt = vp8_sad16x8_wmt;
533 const SadMxNFunc sad_8x8_wmt = vp8_sad8x8_wmt;
534 const SadMxNFunc sad_4x4_wmt = vp8_sad4x4_wmt;
535 const SadMxNParam sse2_tests[] = {
536 make_tuple(16, 16, sad_16x16_wmt),
537 make_tuple(8, 16, sad_8x16_wmt),
538 make_tuple(16, 8, sad_16x8_wmt),
539 make_tuple(8, 8, sad_8x8_wmt),
540 make_tuple(4, 4, sad_4x4_wmt),
542 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
543 #endif // CONFIG_VP8_ENCODER
545 #if CONFIG_VP9_ENCODER
546 #if CONFIG_USE_X86INC
547 const SadMxNVp9Func sad_64x64_sse2_vp9 = vp9_sad64x64_sse2;
548 const SadMxNVp9Func sad_64x32_sse2_vp9 = vp9_sad64x32_sse2;
549 const SadMxNVp9Func sad_32x64_sse2_vp9 = vp9_sad32x64_sse2;
550 const SadMxNVp9Func sad_32x32_sse2_vp9 = vp9_sad32x32_sse2;
551 const SadMxNVp9Func sad_32x16_sse2_vp9 = vp9_sad32x16_sse2;
552 const SadMxNVp9Func sad_16x32_sse2_vp9 = vp9_sad16x32_sse2;
553 const SadMxNVp9Func sad_16x16_sse2_vp9 = vp9_sad16x16_sse2;
554 const SadMxNVp9Func sad_16x8_sse2_vp9 = vp9_sad16x8_sse2;
555 const SadMxNVp9Func sad_8x16_sse2_vp9 = vp9_sad8x16_sse2;
556 const SadMxNVp9Func sad_8x8_sse2_vp9 = vp9_sad8x8_sse2;
557 const SadMxNVp9Func sad_8x4_sse2_vp9 = vp9_sad8x4_sse2;
558 const SadMxNVp9Param sse2_vp9_tests[] = {
559 make_tuple(64, 64, sad_64x64_sse2_vp9),
560 make_tuple(64, 32, sad_64x32_sse2_vp9),
561 make_tuple(32, 64, sad_32x64_sse2_vp9),
562 make_tuple(32, 32, sad_32x32_sse2_vp9),
563 make_tuple(32, 16, sad_32x16_sse2_vp9),
564 make_tuple(16, 32, sad_16x32_sse2_vp9),
565 make_tuple(16, 16, sad_16x16_sse2_vp9),
566 make_tuple(16, 8, sad_16x8_sse2_vp9),
567 make_tuple(8, 16, sad_8x16_sse2_vp9),
568 make_tuple(8, 8, sad_8x8_sse2_vp9),
569 make_tuple(8, 4, sad_8x4_sse2_vp9),
571 INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::ValuesIn(sse2_vp9_tests));
573 const SadMxNx4Func sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2;
574 const SadMxNx4Func sad_64x32x4d_sse2 = vp9_sad64x32x4d_sse2;
575 const SadMxNx4Func sad_32x64x4d_sse2 = vp9_sad32x64x4d_sse2;
576 const SadMxNx4Func sad_32x32x4d_sse2 = vp9_sad32x32x4d_sse2;
577 const SadMxNx4Func sad_32x16x4d_sse2 = vp9_sad32x16x4d_sse2;
578 const SadMxNx4Func sad_16x32x4d_sse2 = vp9_sad16x32x4d_sse2;
579 const SadMxNx4Func sad_16x16x4d_sse2 = vp9_sad16x16x4d_sse2;
580 const SadMxNx4Func sad_16x8x4d_sse2 = vp9_sad16x8x4d_sse2;
581 const SadMxNx4Func sad_8x16x4d_sse2 = vp9_sad8x16x4d_sse2;
582 const SadMxNx4Func sad_8x8x4d_sse2 = vp9_sad8x8x4d_sse2;
583 const SadMxNx4Func sad_8x4x4d_sse2 = vp9_sad8x4x4d_sse2;
584 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values(
585 make_tuple(64, 64, sad_64x64x4d_sse2),
586 make_tuple(64, 32, sad_64x32x4d_sse2),
587 make_tuple(32, 64, sad_32x64x4d_sse2),
588 make_tuple(32, 32, sad_32x32x4d_sse2),
589 make_tuple(32, 16, sad_32x16x4d_sse2),
590 make_tuple(16, 32, sad_16x32x4d_sse2),
591 make_tuple(16, 16, sad_16x16x4d_sse2),
592 make_tuple(16, 8, sad_16x8x4d_sse2),
593 make_tuple(8, 16, sad_8x16x4d_sse2),
594 make_tuple(8, 8, sad_8x8x4d_sse2),
595 make_tuple(8, 4, sad_8x4x4d_sse2)));
596 #endif // CONFIG_USE_X86INC
597 #endif // CONFIG_VP9_ENCODER
601 #if CONFIG_VP8_ENCODER
602 const SadMxNx4Func sad_16x16x4d_sse3 = vp8_sad16x16x4d_sse3;
603 const SadMxNx4Func sad_16x8x4d_sse3 = vp8_sad16x8x4d_sse3;
604 const SadMxNx4Func sad_8x16x4d_sse3 = vp8_sad8x16x4d_sse3;
605 const SadMxNx4Func sad_8x8x4d_sse3 = vp8_sad8x8x4d_sse3;
606 const SadMxNx4Func sad_4x4x4d_sse3 = vp8_sad4x4x4d_sse3;
607 INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values(
608 make_tuple(16, 16, sad_16x16x4d_sse3),
609 make_tuple(16, 8, sad_16x8x4d_sse3),
610 make_tuple(8, 16, sad_8x16x4d_sse3),
611 make_tuple(8, 8, sad_8x8x4d_sse3),
612 make_tuple(4, 4, sad_4x4x4d_sse3)));
613 #endif // CONFIG_VP8_ENCODER
617 #if CONFIG_USE_X86INC
618 #if CONFIG_VP8_ENCODER
619 const SadMxNFunc sad_16x16_sse3 = vp8_sad16x16_sse3;
620 INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values(
621 make_tuple(16, 16, sad_16x16_sse3)));
622 #endif // CONFIG_VP8_ENCODER
623 #endif // CONFIG_USE_X86INC
627 #if CONFIG_VP9_ENCODER
628 const SadMxNx4Func sad_64x64x4d_avx2 = vp9_sad64x64x4d_avx2;
629 const SadMxNx4Func sad_32x32x4d_avx2 = vp9_sad32x32x4d_avx2;
630 INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::Values(
631 make_tuple(32, 32, sad_32x32x4d_avx2),
632 make_tuple(64, 64, sad_64x64x4d_avx2)));
633 #endif // CONFIG_VP9_ENCODER