OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 12 matching lines...) Expand all Loading... |
23 #include "vpx_mem/vpx_mem.h" | 23 #include "vpx_mem/vpx_mem.h" |
24 | 24 |
25 #include "test/acm_random.h" | 25 #include "test/acm_random.h" |
26 #include "test/clear_system_state.h" | 26 #include "test/clear_system_state.h" |
27 #include "test/register_state_check.h" | 27 #include "test/register_state_check.h" |
28 #include "test/util.h" | 28 #include "test/util.h" |
29 #include "third_party/googletest/src/include/gtest/gtest.h" | 29 #include "third_party/googletest/src/include/gtest/gtest.h" |
30 | 30 |
31 | 31 |
32 #if CONFIG_VP8_ENCODER | 32 #if CONFIG_VP8_ENCODER |
33 typedef unsigned int (*sad_m_by_n_fn_t)(const unsigned char *source_ptr, | 33 typedef unsigned int (*SadMxNFunc)(const unsigned char *source_ptr, |
34 int source_stride, | 34 int source_stride, |
35 const unsigned char *reference_ptr, | 35 const unsigned char *reference_ptr, |
36 int reference_stride, | 36 int reference_stride, |
37 unsigned int max_sad); | 37 unsigned int max_sad); |
38 typedef std::tr1::tuple<int, int, sad_m_by_n_fn_t> sad_m_by_n_test_param_t; | 38 typedef std::tr1::tuple<int, int, SadMxNFunc> SadMxNParam; |
39 #endif | 39 #endif |
40 #if CONFIG_VP9_ENCODER | 40 #if CONFIG_VP9_ENCODER |
41 typedef unsigned int (*sad_m_by_n_fn_vp9_t)(const unsigned char *source_ptr, | 41 typedef unsigned int (*SadMxNVp9Func)(const unsigned char *source_ptr, |
42 int source_stride, | 42 int source_stride, |
43 const unsigned char *reference_ptr, | 43 const unsigned char *reference_ptr, |
44 int reference_stride); | 44 int reference_stride); |
45 typedef std::tr1::tuple<int, int, sad_m_by_n_fn_vp9_t> | 45 typedef std::tr1::tuple<int, int, SadMxNVp9Func> SadMxNVp9Param; |
46 sad_m_by_n_test_param_vp9_t; | |
47 #endif | 46 #endif |
48 | 47 |
49 typedef void (*sad_n_by_n_by_4_fn_t)(const uint8_t *src_ptr, | 48 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, |
50 int src_stride, | 49 int src_stride, |
51 const unsigned char * const ref_ptr[], | 50 const unsigned char *const ref_ptr[], |
52 int ref_stride, | 51 int ref_stride, |
53 unsigned int *sad_array); | 52 unsigned int *sad_array); |
54 typedef std::tr1::tuple<int, int, sad_n_by_n_by_4_fn_t> | 53 typedef std::tr1::tuple<int, int, SadMxNx4Func> SadMxNx4Param; |
55 sad_n_by_n_by_4_test_param_t; | |
56 | 54 |
57 using libvpx_test::ACMRandom; | 55 using libvpx_test::ACMRandom; |
58 | 56 |
59 namespace { | 57 namespace { |
60 class SADTestBase : public ::testing::Test { | 58 class SADTestBase : public ::testing::Test { |
61 public: | 59 public: |
62 SADTestBase(int width, int height) : width_(width), height_(height) {} | 60 SADTestBase(int width, int height) : width_(width), height_(height) {} |
63 | 61 |
64 static void SetUpTestCase() { | 62 static void SetUpTestCase() { |
65 source_data_ = reinterpret_cast<uint8_t*>( | 63 source_data_ = reinterpret_cast<uint8_t*>( |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
133 static uint8_t* source_data_; | 131 static uint8_t* source_data_; |
134 int source_stride_; | 132 int source_stride_; |
135 static uint8_t* reference_data_; | 133 static uint8_t* reference_data_; |
136 int reference_stride_; | 134 int reference_stride_; |
137 | 135 |
138 ACMRandom rnd_; | 136 ACMRandom rnd_; |
139 }; | 137 }; |
140 | 138 |
141 class SADx4Test | 139 class SADx4Test |
142 : public SADTestBase, | 140 : public SADTestBase, |
143 public ::testing::WithParamInterface<sad_n_by_n_by_4_test_param_t> { | 141 public ::testing::WithParamInterface<SadMxNx4Param> { |
144 public: | 142 public: |
145 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} | 143 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} |
146 | 144 |
147 protected: | 145 protected: |
148 void SADs(unsigned int *results) { | 146 void SADs(unsigned int *results) { |
149 const uint8_t* refs[] = {GetReference(0), GetReference(1), | 147 const uint8_t* refs[] = {GetReference(0), GetReference(1), |
150 GetReference(2), GetReference(3)}; | 148 GetReference(2), GetReference(3)}; |
151 | 149 |
152 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_, | 150 ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_, |
153 refs, reference_stride_, | 151 refs, reference_stride_, |
154 results)); | 152 results)); |
155 } | 153 } |
156 | 154 |
157 void CheckSADs() { | 155 void CheckSADs() { |
158 unsigned int reference_sad, exp_sad[4]; | 156 unsigned int reference_sad, exp_sad[4]; |
159 | 157 |
160 SADs(exp_sad); | 158 SADs(exp_sad); |
161 for (int block = 0; block < 4; ++block) { | 159 for (int block = 0; block < 4; ++block) { |
162 reference_sad = ReferenceSAD(UINT_MAX, block); | 160 reference_sad = ReferenceSAD(UINT_MAX, block); |
163 | 161 |
164 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; | 162 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; |
165 } | 163 } |
166 } | 164 } |
167 }; | 165 }; |
168 | 166 |
169 #if CONFIG_VP8_ENCODER | 167 #if CONFIG_VP8_ENCODER |
170 class SADTest | 168 class SADTest |
171 : public SADTestBase, | 169 : public SADTestBase, |
172 public ::testing::WithParamInterface<sad_m_by_n_test_param_t> { | 170 public ::testing::WithParamInterface<SadMxNParam> { |
173 public: | 171 public: |
174 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} | 172 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} |
175 | 173 |
176 protected: | 174 protected: |
177 unsigned int SAD(unsigned int max_sad, int block_idx) { | 175 unsigned int SAD(unsigned int max_sad, int block_idx) { |
178 unsigned int ret; | 176 unsigned int ret; |
179 const uint8_t* const reference = GetReference(block_idx); | 177 const uint8_t* const reference = GetReference(block_idx); |
180 | 178 |
181 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, | 179 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, |
182 reference, reference_stride_, | 180 reference, reference_stride_, |
(...skipping 11 matching lines...) Expand all Loading... |
194 // Alternative implementations are not required to check max_sad | 192 // Alternative implementations are not required to check max_sad |
195 ASSERT_GE(exp_sad, reference_sad); | 193 ASSERT_GE(exp_sad, reference_sad); |
196 } | 194 } |
197 } | 195 } |
198 }; | 196 }; |
199 #endif // CONFIG_VP8_ENCODER | 197 #endif // CONFIG_VP8_ENCODER |
200 | 198 |
201 #if CONFIG_VP9_ENCODER | 199 #if CONFIG_VP9_ENCODER |
202 class SADVP9Test | 200 class SADVP9Test |
203 : public SADTestBase, | 201 : public SADTestBase, |
204 public ::testing::WithParamInterface<sad_m_by_n_test_param_vp9_t> { | 202 public ::testing::WithParamInterface<SadMxNVp9Param> { |
205 public: | 203 public: |
206 SADVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} | 204 SADVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} |
207 | 205 |
208 protected: | 206 protected: |
209 unsigned int SAD(int block_idx) { | 207 unsigned int SAD(int block_idx) { |
210 unsigned int ret; | 208 unsigned int ret; |
211 const uint8_t* const reference = GetReference(block_idx); | 209 const uint8_t* const reference = GetReference(block_idx); |
212 | 210 |
213 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, | 211 ASM_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, |
214 reference, reference_stride_)); | 212 reference, reference_stride_)); |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
375 FillRandom(GetReference(3), reference_stride_); | 373 FillRandom(GetReference(3), reference_stride_); |
376 CheckSADs(); | 374 CheckSADs(); |
377 source_stride_ = tmp_stride; | 375 source_stride_ = tmp_stride; |
378 } | 376 } |
379 | 377 |
380 using std::tr1::make_tuple; | 378 using std::tr1::make_tuple; |
381 | 379 |
382 //------------------------------------------------------------------------------ | 380 //------------------------------------------------------------------------------ |
383 // C functions | 381 // C functions |
384 #if CONFIG_VP8_ENCODER | 382 #if CONFIG_VP8_ENCODER |
385 const sad_m_by_n_fn_t sad_16x16_c = vp8_sad16x16_c; | 383 const SadMxNFunc sad_16x16_c = vp8_sad16x16_c; |
386 const sad_m_by_n_fn_t sad_8x16_c = vp8_sad8x16_c; | 384 const SadMxNFunc sad_8x16_c = vp8_sad8x16_c; |
387 const sad_m_by_n_fn_t sad_16x8_c = vp8_sad16x8_c; | 385 const SadMxNFunc sad_16x8_c = vp8_sad16x8_c; |
388 const sad_m_by_n_fn_t sad_8x8_c = vp8_sad8x8_c; | 386 const SadMxNFunc sad_8x8_c = vp8_sad8x8_c; |
389 const sad_m_by_n_fn_t sad_4x4_c = vp8_sad4x4_c; | 387 const SadMxNFunc sad_4x4_c = vp8_sad4x4_c; |
390 const sad_m_by_n_test_param_t c_tests[] = { | 388 const SadMxNParam c_tests[] = { |
391 make_tuple(16, 16, sad_16x16_c), | 389 make_tuple(16, 16, sad_16x16_c), |
392 make_tuple(8, 16, sad_8x16_c), | 390 make_tuple(8, 16, sad_8x16_c), |
393 make_tuple(16, 8, sad_16x8_c), | 391 make_tuple(16, 8, sad_16x8_c), |
394 make_tuple(8, 8, sad_8x8_c), | 392 make_tuple(8, 8, sad_8x8_c), |
395 make_tuple(4, 4, sad_4x4_c), | 393 make_tuple(4, 4, sad_4x4_c), |
396 }; | 394 }; |
397 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); | 395 INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); |
398 #endif // CONFIG_VP8_ENCODER | 396 #endif // CONFIG_VP8_ENCODER |
399 | 397 |
400 #if CONFIG_VP9_ENCODER | 398 #if CONFIG_VP9_ENCODER |
401 const sad_m_by_n_fn_vp9_t sad_64x64_c_vp9 = vp9_sad64x64_c; | 399 const SadMxNVp9Func sad_64x64_c_vp9 = vp9_sad64x64_c; |
402 const sad_m_by_n_fn_vp9_t sad_32x32_c_vp9 = vp9_sad32x32_c; | 400 const SadMxNVp9Func sad_32x32_c_vp9 = vp9_sad32x32_c; |
403 const sad_m_by_n_fn_vp9_t sad_16x16_c_vp9 = vp9_sad16x16_c; | 401 const SadMxNVp9Func sad_16x16_c_vp9 = vp9_sad16x16_c; |
404 const sad_m_by_n_fn_vp9_t sad_8x16_c_vp9 = vp9_sad8x16_c; | 402 const SadMxNVp9Func sad_8x16_c_vp9 = vp9_sad8x16_c; |
405 const sad_m_by_n_fn_vp9_t sad_16x8_c_vp9 = vp9_sad16x8_c; | 403 const SadMxNVp9Func sad_16x8_c_vp9 = vp9_sad16x8_c; |
406 const sad_m_by_n_fn_vp9_t sad_8x8_c_vp9 = vp9_sad8x8_c; | 404 const SadMxNVp9Func sad_8x8_c_vp9 = vp9_sad8x8_c; |
407 const sad_m_by_n_fn_vp9_t sad_8x4_c_vp9 = vp9_sad8x4_c; | 405 const SadMxNVp9Func sad_8x4_c_vp9 = vp9_sad8x4_c; |
408 const sad_m_by_n_fn_vp9_t sad_4x8_c_vp9 = vp9_sad4x8_c; | 406 const SadMxNVp9Func sad_4x8_c_vp9 = vp9_sad4x8_c; |
409 const sad_m_by_n_fn_vp9_t sad_4x4_c_vp9 = vp9_sad4x4_c; | 407 const SadMxNVp9Func sad_4x4_c_vp9 = vp9_sad4x4_c; |
410 const sad_m_by_n_test_param_vp9_t c_vp9_tests[] = { | 408 const SadMxNVp9Param c_vp9_tests[] = { |
411 make_tuple(64, 64, sad_64x64_c_vp9), | 409 make_tuple(64, 64, sad_64x64_c_vp9), |
412 make_tuple(32, 32, sad_32x32_c_vp9), | 410 make_tuple(32, 32, sad_32x32_c_vp9), |
413 make_tuple(16, 16, sad_16x16_c_vp9), | 411 make_tuple(16, 16, sad_16x16_c_vp9), |
414 make_tuple(8, 16, sad_8x16_c_vp9), | 412 make_tuple(8, 16, sad_8x16_c_vp9), |
415 make_tuple(16, 8, sad_16x8_c_vp9), | 413 make_tuple(16, 8, sad_16x8_c_vp9), |
416 make_tuple(8, 8, sad_8x8_c_vp9), | 414 make_tuple(8, 8, sad_8x8_c_vp9), |
417 make_tuple(8, 4, sad_8x4_c_vp9), | 415 make_tuple(8, 4, sad_8x4_c_vp9), |
418 make_tuple(4, 8, sad_4x8_c_vp9), | 416 make_tuple(4, 8, sad_4x8_c_vp9), |
419 make_tuple(4, 4, sad_4x4_c_vp9), | 417 make_tuple(4, 4, sad_4x4_c_vp9), |
420 }; | 418 }; |
421 INSTANTIATE_TEST_CASE_P(C, SADVP9Test, ::testing::ValuesIn(c_vp9_tests)); | 419 INSTANTIATE_TEST_CASE_P(C, SADVP9Test, ::testing::ValuesIn(c_vp9_tests)); |
422 | 420 |
423 const sad_n_by_n_by_4_fn_t sad_64x64x4d_c = vp9_sad64x64x4d_c; | 421 const SadMxNx4Func sad_64x64x4d_c = vp9_sad64x64x4d_c; |
424 const sad_n_by_n_by_4_fn_t sad_64x32x4d_c = vp9_sad64x32x4d_c; | 422 const SadMxNx4Func sad_64x32x4d_c = vp9_sad64x32x4d_c; |
425 const sad_n_by_n_by_4_fn_t sad_32x64x4d_c = vp9_sad32x64x4d_c; | 423 const SadMxNx4Func sad_32x64x4d_c = vp9_sad32x64x4d_c; |
426 const sad_n_by_n_by_4_fn_t sad_32x32x4d_c = vp9_sad32x32x4d_c; | 424 const SadMxNx4Func sad_32x32x4d_c = vp9_sad32x32x4d_c; |
427 const sad_n_by_n_by_4_fn_t sad_32x16x4d_c = vp9_sad32x16x4d_c; | 425 const SadMxNx4Func sad_32x16x4d_c = vp9_sad32x16x4d_c; |
428 const sad_n_by_n_by_4_fn_t sad_16x32x4d_c = vp9_sad16x32x4d_c; | 426 const SadMxNx4Func sad_16x32x4d_c = vp9_sad16x32x4d_c; |
429 const sad_n_by_n_by_4_fn_t sad_16x16x4d_c = vp9_sad16x16x4d_c; | 427 const SadMxNx4Func sad_16x16x4d_c = vp9_sad16x16x4d_c; |
430 const sad_n_by_n_by_4_fn_t sad_16x8x4d_c = vp9_sad16x8x4d_c; | 428 const SadMxNx4Func sad_16x8x4d_c = vp9_sad16x8x4d_c; |
431 const sad_n_by_n_by_4_fn_t sad_8x16x4d_c = vp9_sad8x16x4d_c; | 429 const SadMxNx4Func sad_8x16x4d_c = vp9_sad8x16x4d_c; |
432 const sad_n_by_n_by_4_fn_t sad_8x8x4d_c = vp9_sad8x8x4d_c; | 430 const SadMxNx4Func sad_8x8x4d_c = vp9_sad8x8x4d_c; |
433 const sad_n_by_n_by_4_fn_t sad_8x4x4d_c = vp9_sad8x4x4d_c; | 431 const SadMxNx4Func sad_8x4x4d_c = vp9_sad8x4x4d_c; |
434 const sad_n_by_n_by_4_fn_t sad_4x8x4d_c = vp9_sad4x8x4d_c; | 432 const SadMxNx4Func sad_4x8x4d_c = vp9_sad4x8x4d_c; |
435 const sad_n_by_n_by_4_fn_t sad_4x4x4d_c = vp9_sad4x4x4d_c; | 433 const SadMxNx4Func sad_4x4x4d_c = vp9_sad4x4x4d_c; |
436 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values( | 434 INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values( |
437 make_tuple(64, 64, sad_64x64x4d_c), | 435 make_tuple(64, 64, sad_64x64x4d_c), |
438 make_tuple(64, 32, sad_64x32x4d_c), | 436 make_tuple(64, 32, sad_64x32x4d_c), |
439 make_tuple(32, 64, sad_32x64x4d_c), | 437 make_tuple(32, 64, sad_32x64x4d_c), |
440 make_tuple(32, 32, sad_32x32x4d_c), | 438 make_tuple(32, 32, sad_32x32x4d_c), |
441 make_tuple(32, 16, sad_32x16x4d_c), | 439 make_tuple(32, 16, sad_32x16x4d_c), |
442 make_tuple(16, 32, sad_16x32x4d_c), | 440 make_tuple(16, 32, sad_16x32x4d_c), |
443 make_tuple(16, 16, sad_16x16x4d_c), | 441 make_tuple(16, 16, sad_16x16x4d_c), |
444 make_tuple(16, 8, sad_16x8x4d_c), | 442 make_tuple(16, 8, sad_16x8x4d_c), |
445 make_tuple(8, 16, sad_8x16x4d_c), | 443 make_tuple(8, 16, sad_8x16x4d_c), |
446 make_tuple(8, 8, sad_8x8x4d_c), | 444 make_tuple(8, 8, sad_8x8x4d_c), |
447 make_tuple(8, 4, sad_8x4x4d_c), | 445 make_tuple(8, 4, sad_8x4x4d_c), |
448 make_tuple(4, 8, sad_4x8x4d_c), | 446 make_tuple(4, 8, sad_4x8x4d_c), |
449 make_tuple(4, 4, sad_4x4x4d_c))); | 447 make_tuple(4, 4, sad_4x4x4d_c))); |
450 #endif // CONFIG_VP9_ENCODER | 448 #endif // CONFIG_VP9_ENCODER |
451 | 449 |
452 //------------------------------------------------------------------------------ | 450 //------------------------------------------------------------------------------ |
453 // ARM functions | 451 // ARM functions |
454 #if HAVE_MEDIA | 452 #if HAVE_MEDIA |
455 #if CONFIG_VP8_ENCODER | 453 #if CONFIG_VP8_ENCODER |
456 const sad_m_by_n_fn_t sad_16x16_armv6 = vp8_sad16x16_armv6; | 454 const SadMxNFunc sad_16x16_armv6 = vp8_sad16x16_armv6; |
457 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values( | 455 INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values( |
458 make_tuple(16, 16, sad_16x16_armv6))); | 456 make_tuple(16, 16, sad_16x16_armv6))); |
459 #endif // CONFIG_VP8_ENCODER | 457 #endif // CONFIG_VP8_ENCODER |
460 #endif // HAVE_MEDIA | 458 #endif // HAVE_MEDIA |
461 | 459 |
462 #if HAVE_NEON | 460 #if HAVE_NEON |
463 #if CONFIG_VP8_ENCODER | 461 #if CONFIG_VP8_ENCODER |
464 const sad_m_by_n_fn_t sad_16x16_neon = vp8_sad16x16_neon; | 462 const SadMxNFunc sad_16x16_neon = vp8_sad16x16_neon; |
465 const sad_m_by_n_fn_t sad_8x16_neon = vp8_sad8x16_neon; | 463 const SadMxNFunc sad_8x16_neon = vp8_sad8x16_neon; |
466 const sad_m_by_n_fn_t sad_16x8_neon = vp8_sad16x8_neon; | 464 const SadMxNFunc sad_16x8_neon = vp8_sad16x8_neon; |
467 const sad_m_by_n_fn_t sad_8x8_neon = vp8_sad8x8_neon; | 465 const SadMxNFunc sad_8x8_neon = vp8_sad8x8_neon; |
468 const sad_m_by_n_fn_t sad_4x4_neon = vp8_sad4x4_neon; | 466 const SadMxNFunc sad_4x4_neon = vp8_sad4x4_neon; |
469 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values( | 467 INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values( |
470 make_tuple(16, 16, sad_16x16_neon), | 468 make_tuple(16, 16, sad_16x16_neon), |
471 make_tuple(8, 16, sad_8x16_neon), | 469 make_tuple(8, 16, sad_8x16_neon), |
472 make_tuple(16, 8, sad_16x8_neon), | 470 make_tuple(16, 8, sad_16x8_neon), |
473 make_tuple(8, 8, sad_8x8_neon), | 471 make_tuple(8, 8, sad_8x8_neon), |
474 make_tuple(4, 4, sad_4x4_neon))); | 472 make_tuple(4, 4, sad_4x4_neon))); |
475 #endif // CONFIG_VP8_ENCODER | 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 SadMxNVp9Param neon_vp9_tests[] = { |
| 479 make_tuple(64, 64, sad_64x64_neon_vp9), |
| 480 make_tuple(32, 32, sad_32x32_neon_vp9), |
| 481 make_tuple(16, 16, sad_16x16_neon_vp9), |
| 482 }; |
| 483 INSTANTIATE_TEST_CASE_P(NEON, SADVP9Test, ::testing::ValuesIn(neon_vp9_tests)); |
| 484 #endif // CONFIG_VP9_ENCODER |
476 #endif // HAVE_NEON | 485 #endif // HAVE_NEON |
477 | 486 |
478 //------------------------------------------------------------------------------ | 487 //------------------------------------------------------------------------------ |
479 // x86 functions | 488 // x86 functions |
480 #if HAVE_MMX | 489 #if HAVE_MMX |
481 #if CONFIG_VP8_ENCODER | 490 #if CONFIG_VP8_ENCODER |
482 const sad_m_by_n_fn_t sad_16x16_mmx = vp8_sad16x16_mmx; | 491 const SadMxNFunc sad_16x16_mmx = vp8_sad16x16_mmx; |
483 const sad_m_by_n_fn_t sad_8x16_mmx = vp8_sad8x16_mmx; | 492 const SadMxNFunc sad_8x16_mmx = vp8_sad8x16_mmx; |
484 const sad_m_by_n_fn_t sad_16x8_mmx = vp8_sad16x8_mmx; | 493 const SadMxNFunc sad_16x8_mmx = vp8_sad16x8_mmx; |
485 const sad_m_by_n_fn_t sad_8x8_mmx = vp8_sad8x8_mmx; | 494 const SadMxNFunc sad_8x8_mmx = vp8_sad8x8_mmx; |
486 const sad_m_by_n_fn_t sad_4x4_mmx = vp8_sad4x4_mmx; | 495 const SadMxNFunc sad_4x4_mmx = vp8_sad4x4_mmx; |
487 const sad_m_by_n_test_param_t mmx_tests[] = { | 496 const SadMxNParam mmx_tests[] = { |
488 make_tuple(16, 16, sad_16x16_mmx), | 497 make_tuple(16, 16, sad_16x16_mmx), |
489 make_tuple(8, 16, sad_8x16_mmx), | 498 make_tuple(8, 16, sad_8x16_mmx), |
490 make_tuple(16, 8, sad_16x8_mmx), | 499 make_tuple(16, 8, sad_16x8_mmx), |
491 make_tuple(8, 8, sad_8x8_mmx), | 500 make_tuple(8, 8, sad_8x8_mmx), |
492 make_tuple(4, 4, sad_4x4_mmx), | 501 make_tuple(4, 4, sad_4x4_mmx), |
493 }; | 502 }; |
494 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); | 503 INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); |
495 #endif // CONFIG_VP8_ENCODER | 504 #endif // CONFIG_VP8_ENCODER |
496 | 505 |
497 #if CONFIG_VP9_ENCODER | 506 #if CONFIG_VP9_ENCODER |
498 const sad_m_by_n_fn_vp9_t sad_16x16_mmx_vp9 = vp9_sad16x16_mmx; | 507 const SadMxNVp9Func sad_16x16_mmx_vp9 = vp9_sad16x16_mmx; |
499 const sad_m_by_n_fn_vp9_t sad_8x16_mmx_vp9 = vp9_sad8x16_mmx; | 508 const SadMxNVp9Func sad_8x16_mmx_vp9 = vp9_sad8x16_mmx; |
500 const sad_m_by_n_fn_vp9_t sad_16x8_mmx_vp9 = vp9_sad16x8_mmx; | 509 const SadMxNVp9Func sad_16x8_mmx_vp9 = vp9_sad16x8_mmx; |
501 const sad_m_by_n_fn_vp9_t sad_8x8_mmx_vp9 = vp9_sad8x8_mmx; | 510 const SadMxNVp9Func sad_8x8_mmx_vp9 = vp9_sad8x8_mmx; |
502 const sad_m_by_n_fn_vp9_t sad_4x4_mmx_vp9 = vp9_sad4x4_mmx; | 511 const SadMxNVp9Func sad_4x4_mmx_vp9 = vp9_sad4x4_mmx; |
503 const sad_m_by_n_test_param_vp9_t mmx_vp9_tests[] = { | 512 const SadMxNVp9Param mmx_vp9_tests[] = { |
504 make_tuple(16, 16, sad_16x16_mmx_vp9), | 513 make_tuple(16, 16, sad_16x16_mmx_vp9), |
505 make_tuple(8, 16, sad_8x16_mmx_vp9), | 514 make_tuple(8, 16, sad_8x16_mmx_vp9), |
506 make_tuple(16, 8, sad_16x8_mmx_vp9), | 515 make_tuple(16, 8, sad_16x8_mmx_vp9), |
507 make_tuple(8, 8, sad_8x8_mmx_vp9), | 516 make_tuple(8, 8, sad_8x8_mmx_vp9), |
508 make_tuple(4, 4, sad_4x4_mmx_vp9), | 517 make_tuple(4, 4, sad_4x4_mmx_vp9), |
509 }; | 518 }; |
510 INSTANTIATE_TEST_CASE_P(MMX, SADVP9Test, ::testing::ValuesIn(mmx_vp9_tests)); | 519 INSTANTIATE_TEST_CASE_P(MMX, SADVP9Test, ::testing::ValuesIn(mmx_vp9_tests)); |
511 #endif // CONFIG_VP9_ENCODER | 520 #endif // CONFIG_VP9_ENCODER |
512 #endif // HAVE_MMX | 521 #endif // HAVE_MMX |
513 | 522 |
514 #if HAVE_SSE | 523 #if HAVE_SSE |
515 #if CONFIG_VP9_ENCODER | 524 #if CONFIG_VP9_ENCODER |
516 #if CONFIG_USE_X86INC | 525 #if CONFIG_USE_X86INC |
517 const sad_m_by_n_fn_vp9_t sad_4x4_sse_vp9 = vp9_sad4x4_sse; | 526 const SadMxNVp9Func sad_4x4_sse_vp9 = vp9_sad4x4_sse; |
518 const sad_m_by_n_fn_vp9_t sad_4x8_sse_vp9 = vp9_sad4x8_sse; | 527 const SadMxNVp9Func sad_4x8_sse_vp9 = vp9_sad4x8_sse; |
519 INSTANTIATE_TEST_CASE_P(SSE, SADVP9Test, ::testing::Values( | 528 INSTANTIATE_TEST_CASE_P(SSE, SADVP9Test, ::testing::Values( |
520 make_tuple(4, 4, sad_4x4_sse_vp9), | 529 make_tuple(4, 4, sad_4x4_sse_vp9), |
521 make_tuple(4, 8, sad_4x8_sse_vp9))); | 530 make_tuple(4, 8, sad_4x8_sse_vp9))); |
522 | 531 |
523 const sad_n_by_n_by_4_fn_t sad_4x8x4d_sse = vp9_sad4x8x4d_sse; | 532 const SadMxNx4Func sad_4x8x4d_sse = vp9_sad4x8x4d_sse; |
524 const sad_n_by_n_by_4_fn_t sad_4x4x4d_sse = vp9_sad4x4x4d_sse; | 533 const SadMxNx4Func sad_4x4x4d_sse = vp9_sad4x4x4d_sse; |
525 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::Values( | 534 INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::Values( |
526 make_tuple(4, 8, sad_4x8x4d_sse), | 535 make_tuple(4, 8, sad_4x8x4d_sse), |
527 make_tuple(4, 4, sad_4x4x4d_sse))); | 536 make_tuple(4, 4, sad_4x4x4d_sse))); |
528 #endif // CONFIG_USE_X86INC | 537 #endif // CONFIG_USE_X86INC |
529 #endif // CONFIG_VP9_ENCODER | 538 #endif // CONFIG_VP9_ENCODER |
530 #endif // HAVE_SSE | 539 #endif // HAVE_SSE |
531 | 540 |
532 #if HAVE_SSE2 | 541 #if HAVE_SSE2 |
533 #if CONFIG_VP8_ENCODER | 542 #if CONFIG_VP8_ENCODER |
534 const sad_m_by_n_fn_t sad_16x16_wmt = vp8_sad16x16_wmt; | 543 const SadMxNFunc sad_16x16_wmt = vp8_sad16x16_wmt; |
535 const sad_m_by_n_fn_t sad_8x16_wmt = vp8_sad8x16_wmt; | 544 const SadMxNFunc sad_8x16_wmt = vp8_sad8x16_wmt; |
536 const sad_m_by_n_fn_t sad_16x8_wmt = vp8_sad16x8_wmt; | 545 const SadMxNFunc sad_16x8_wmt = vp8_sad16x8_wmt; |
537 const sad_m_by_n_fn_t sad_8x8_wmt = vp8_sad8x8_wmt; | 546 const SadMxNFunc sad_8x8_wmt = vp8_sad8x8_wmt; |
538 const sad_m_by_n_fn_t sad_4x4_wmt = vp8_sad4x4_wmt; | 547 const SadMxNFunc sad_4x4_wmt = vp8_sad4x4_wmt; |
539 const sad_m_by_n_test_param_t sse2_tests[] = { | 548 const SadMxNParam sse2_tests[] = { |
540 make_tuple(16, 16, sad_16x16_wmt), | 549 make_tuple(16, 16, sad_16x16_wmt), |
541 make_tuple(8, 16, sad_8x16_wmt), | 550 make_tuple(8, 16, sad_8x16_wmt), |
542 make_tuple(16, 8, sad_16x8_wmt), | 551 make_tuple(16, 8, sad_16x8_wmt), |
543 make_tuple(8, 8, sad_8x8_wmt), | 552 make_tuple(8, 8, sad_8x8_wmt), |
544 make_tuple(4, 4, sad_4x4_wmt), | 553 make_tuple(4, 4, sad_4x4_wmt), |
545 }; | 554 }; |
546 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); | 555 INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); |
547 #endif // CONFIG_VP8_ENCODER | 556 #endif // CONFIG_VP8_ENCODER |
548 | 557 |
549 #if CONFIG_VP9_ENCODER | 558 #if CONFIG_VP9_ENCODER |
550 #if CONFIG_USE_X86INC | 559 #if CONFIG_USE_X86INC |
551 const sad_m_by_n_fn_vp9_t sad_64x64_sse2_vp9 = vp9_sad64x64_sse2; | 560 const SadMxNVp9Func sad_64x64_sse2_vp9 = vp9_sad64x64_sse2; |
552 const sad_m_by_n_fn_vp9_t sad_64x32_sse2_vp9 = vp9_sad64x32_sse2; | 561 const SadMxNVp9Func sad_64x32_sse2_vp9 = vp9_sad64x32_sse2; |
553 const sad_m_by_n_fn_vp9_t sad_32x64_sse2_vp9 = vp9_sad32x64_sse2; | 562 const SadMxNVp9Func sad_32x64_sse2_vp9 = vp9_sad32x64_sse2; |
554 const sad_m_by_n_fn_vp9_t sad_32x32_sse2_vp9 = vp9_sad32x32_sse2; | 563 const SadMxNVp9Func sad_32x32_sse2_vp9 = vp9_sad32x32_sse2; |
555 const sad_m_by_n_fn_vp9_t sad_32x16_sse2_vp9 = vp9_sad32x16_sse2; | 564 const SadMxNVp9Func sad_32x16_sse2_vp9 = vp9_sad32x16_sse2; |
556 const sad_m_by_n_fn_vp9_t sad_16x32_sse2_vp9 = vp9_sad16x32_sse2; | 565 const SadMxNVp9Func sad_16x32_sse2_vp9 = vp9_sad16x32_sse2; |
557 const sad_m_by_n_fn_vp9_t sad_16x16_sse2_vp9 = vp9_sad16x16_sse2; | 566 const SadMxNVp9Func sad_16x16_sse2_vp9 = vp9_sad16x16_sse2; |
558 const sad_m_by_n_fn_vp9_t sad_16x8_sse2_vp9 = vp9_sad16x8_sse2; | 567 const SadMxNVp9Func sad_16x8_sse2_vp9 = vp9_sad16x8_sse2; |
559 const sad_m_by_n_fn_vp9_t sad_8x16_sse2_vp9 = vp9_sad8x16_sse2; | 568 const SadMxNVp9Func sad_8x16_sse2_vp9 = vp9_sad8x16_sse2; |
560 const sad_m_by_n_fn_vp9_t sad_8x8_sse2_vp9 = vp9_sad8x8_sse2; | 569 const SadMxNVp9Func sad_8x8_sse2_vp9 = vp9_sad8x8_sse2; |
561 const sad_m_by_n_fn_vp9_t sad_8x4_sse2_vp9 = vp9_sad8x4_sse2; | 570 const SadMxNVp9Func sad_8x4_sse2_vp9 = vp9_sad8x4_sse2; |
562 const sad_m_by_n_test_param_vp9_t sse2_vp9_tests[] = { | 571 const SadMxNVp9Param sse2_vp9_tests[] = { |
563 make_tuple(64, 64, sad_64x64_sse2_vp9), | 572 make_tuple(64, 64, sad_64x64_sse2_vp9), |
564 make_tuple(64, 32, sad_64x32_sse2_vp9), | 573 make_tuple(64, 32, sad_64x32_sse2_vp9), |
565 make_tuple(32, 64, sad_32x64_sse2_vp9), | 574 make_tuple(32, 64, sad_32x64_sse2_vp9), |
566 make_tuple(32, 32, sad_32x32_sse2_vp9), | 575 make_tuple(32, 32, sad_32x32_sse2_vp9), |
567 make_tuple(32, 16, sad_32x16_sse2_vp9), | 576 make_tuple(32, 16, sad_32x16_sse2_vp9), |
568 make_tuple(16, 32, sad_16x32_sse2_vp9), | 577 make_tuple(16, 32, sad_16x32_sse2_vp9), |
569 make_tuple(16, 16, sad_16x16_sse2_vp9), | 578 make_tuple(16, 16, sad_16x16_sse2_vp9), |
570 make_tuple(16, 8, sad_16x8_sse2_vp9), | 579 make_tuple(16, 8, sad_16x8_sse2_vp9), |
571 make_tuple(8, 16, sad_8x16_sse2_vp9), | 580 make_tuple(8, 16, sad_8x16_sse2_vp9), |
572 make_tuple(8, 8, sad_8x8_sse2_vp9), | 581 make_tuple(8, 8, sad_8x8_sse2_vp9), |
573 make_tuple(8, 4, sad_8x4_sse2_vp9), | 582 make_tuple(8, 4, sad_8x4_sse2_vp9), |
574 }; | 583 }; |
575 INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::ValuesIn(sse2_vp9_tests)); | 584 INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::ValuesIn(sse2_vp9_tests)); |
576 | 585 |
577 const sad_n_by_n_by_4_fn_t sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2; | 586 const SadMxNx4Func sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2; |
578 const sad_n_by_n_by_4_fn_t sad_64x32x4d_sse2 = vp9_sad64x32x4d_sse2; | 587 const SadMxNx4Func sad_64x32x4d_sse2 = vp9_sad64x32x4d_sse2; |
579 const sad_n_by_n_by_4_fn_t sad_32x64x4d_sse2 = vp9_sad32x64x4d_sse2; | 588 const SadMxNx4Func sad_32x64x4d_sse2 = vp9_sad32x64x4d_sse2; |
580 const sad_n_by_n_by_4_fn_t sad_32x32x4d_sse2 = vp9_sad32x32x4d_sse2; | 589 const SadMxNx4Func sad_32x32x4d_sse2 = vp9_sad32x32x4d_sse2; |
581 const sad_n_by_n_by_4_fn_t sad_32x16x4d_sse2 = vp9_sad32x16x4d_sse2; | 590 const SadMxNx4Func sad_32x16x4d_sse2 = vp9_sad32x16x4d_sse2; |
582 const sad_n_by_n_by_4_fn_t sad_16x32x4d_sse2 = vp9_sad16x32x4d_sse2; | 591 const SadMxNx4Func sad_16x32x4d_sse2 = vp9_sad16x32x4d_sse2; |
583 const sad_n_by_n_by_4_fn_t sad_16x16x4d_sse2 = vp9_sad16x16x4d_sse2; | 592 const SadMxNx4Func sad_16x16x4d_sse2 = vp9_sad16x16x4d_sse2; |
584 const sad_n_by_n_by_4_fn_t sad_16x8x4d_sse2 = vp9_sad16x8x4d_sse2; | 593 const SadMxNx4Func sad_16x8x4d_sse2 = vp9_sad16x8x4d_sse2; |
585 const sad_n_by_n_by_4_fn_t sad_8x16x4d_sse2 = vp9_sad8x16x4d_sse2; | 594 const SadMxNx4Func sad_8x16x4d_sse2 = vp9_sad8x16x4d_sse2; |
586 const sad_n_by_n_by_4_fn_t sad_8x8x4d_sse2 = vp9_sad8x8x4d_sse2; | 595 const SadMxNx4Func sad_8x8x4d_sse2 = vp9_sad8x8x4d_sse2; |
587 const sad_n_by_n_by_4_fn_t sad_8x4x4d_sse2 = vp9_sad8x4x4d_sse2; | 596 const SadMxNx4Func sad_8x4x4d_sse2 = vp9_sad8x4x4d_sse2; |
588 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values( | 597 INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values( |
589 make_tuple(64, 64, sad_64x64x4d_sse2), | 598 make_tuple(64, 64, sad_64x64x4d_sse2), |
590 make_tuple(64, 32, sad_64x32x4d_sse2), | 599 make_tuple(64, 32, sad_64x32x4d_sse2), |
591 make_tuple(32, 64, sad_32x64x4d_sse2), | 600 make_tuple(32, 64, sad_32x64x4d_sse2), |
592 make_tuple(32, 32, sad_32x32x4d_sse2), | 601 make_tuple(32, 32, sad_32x32x4d_sse2), |
593 make_tuple(32, 16, sad_32x16x4d_sse2), | 602 make_tuple(32, 16, sad_32x16x4d_sse2), |
594 make_tuple(16, 32, sad_16x32x4d_sse2), | 603 make_tuple(16, 32, sad_16x32x4d_sse2), |
595 make_tuple(16, 16, sad_16x16x4d_sse2), | 604 make_tuple(16, 16, sad_16x16x4d_sse2), |
596 make_tuple(16, 8, sad_16x8x4d_sse2), | 605 make_tuple(16, 8, sad_16x8x4d_sse2), |
597 make_tuple(8, 16, sad_8x16x4d_sse2), | 606 make_tuple(8, 16, sad_8x16x4d_sse2), |
598 make_tuple(8, 8, sad_8x8x4d_sse2), | 607 make_tuple(8, 8, sad_8x8x4d_sse2), |
599 make_tuple(8, 4, sad_8x4x4d_sse2))); | 608 make_tuple(8, 4, sad_8x4x4d_sse2))); |
600 #endif // CONFIG_USE_X86INC | 609 #endif // CONFIG_USE_X86INC |
601 #endif // CONFIG_VP9_ENCODER | 610 #endif // CONFIG_VP9_ENCODER |
602 #endif // HAVE_SSE2 | 611 #endif // HAVE_SSE2 |
603 | 612 |
604 #if HAVE_SSE3 | 613 #if HAVE_SSE3 |
605 #if CONFIG_VP8_ENCODER | 614 #if CONFIG_VP8_ENCODER |
606 const sad_n_by_n_by_4_fn_t sad_16x16x4d_sse3 = vp8_sad16x16x4d_sse3; | 615 const SadMxNx4Func sad_16x16x4d_sse3 = vp8_sad16x16x4d_sse3; |
607 const sad_n_by_n_by_4_fn_t sad_16x8x4d_sse3 = vp8_sad16x8x4d_sse3; | 616 const SadMxNx4Func sad_16x8x4d_sse3 = vp8_sad16x8x4d_sse3; |
608 const sad_n_by_n_by_4_fn_t sad_8x16x4d_sse3 = vp8_sad8x16x4d_sse3; | 617 const SadMxNx4Func sad_8x16x4d_sse3 = vp8_sad8x16x4d_sse3; |
609 const sad_n_by_n_by_4_fn_t sad_8x8x4d_sse3 = vp8_sad8x8x4d_sse3; | 618 const SadMxNx4Func sad_8x8x4d_sse3 = vp8_sad8x8x4d_sse3; |
610 const sad_n_by_n_by_4_fn_t sad_4x4x4d_sse3 = vp8_sad4x4x4d_sse3; | 619 const SadMxNx4Func sad_4x4x4d_sse3 = vp8_sad4x4x4d_sse3; |
611 INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values( | 620 INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values( |
612 make_tuple(16, 16, sad_16x16x4d_sse3), | 621 make_tuple(16, 16, sad_16x16x4d_sse3), |
613 make_tuple(16, 8, sad_16x8x4d_sse3), | 622 make_tuple(16, 8, sad_16x8x4d_sse3), |
614 make_tuple(8, 16, sad_8x16x4d_sse3), | 623 make_tuple(8, 16, sad_8x16x4d_sse3), |
615 make_tuple(8, 8, sad_8x8x4d_sse3), | 624 make_tuple(8, 8, sad_8x8x4d_sse3), |
616 make_tuple(4, 4, sad_4x4x4d_sse3))); | 625 make_tuple(4, 4, sad_4x4x4d_sse3))); |
617 #endif // CONFIG_VP8_ENCODER | 626 #endif // CONFIG_VP8_ENCODER |
618 #endif // HAVE_SSE3 | 627 #endif // HAVE_SSE3 |
619 | 628 |
620 #if HAVE_SSSE3 | 629 #if HAVE_SSSE3 |
621 #if CONFIG_USE_X86INC | 630 #if CONFIG_USE_X86INC |
622 #if CONFIG_VP8_ENCODER | 631 #if CONFIG_VP8_ENCODER |
623 const sad_m_by_n_fn_t sad_16x16_sse3 = vp8_sad16x16_sse3; | 632 const SadMxNFunc sad_16x16_sse3 = vp8_sad16x16_sse3; |
624 INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values( | 633 INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values( |
625 make_tuple(16, 16, sad_16x16_sse3))); | 634 make_tuple(16, 16, sad_16x16_sse3))); |
626 #endif // CONFIG_VP8_ENCODER | 635 #endif // CONFIG_VP8_ENCODER |
627 #endif // CONFIG_USE_X86INC | 636 #endif // CONFIG_USE_X86INC |
628 #endif // HAVE_SSSE3 | 637 #endif // HAVE_SSSE3 |
629 | 638 |
630 #if HAVE_AVX2 | 639 #if HAVE_AVX2 |
631 #if CONFIG_VP9_ENCODER | 640 #if CONFIG_VP9_ENCODER |
632 // TODO(jzern): these prototypes can be removed after the avx2 versions are | 641 // TODO(jzern): these prototypes can be removed after the avx2 versions are |
633 // reenabled in vp9_rtcd_defs.pl. | 642 // reenabled in vp9_rtcd_defs.pl. |
634 extern "C" { | 643 extern "C" { |
635 void vp9_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, | 644 void vp9_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, |
636 const uint8_t *const ref_ptr[], int ref_stride, | 645 const uint8_t *const ref_ptr[], int ref_stride, |
637 unsigned int *sad_array); | 646 unsigned int *sad_array); |
638 void vp9_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, | 647 void vp9_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, |
639 const uint8_t *const ref_ptr[], int ref_stride, | 648 const uint8_t *const ref_ptr[], int ref_stride, |
640 unsigned int *sad_array); | 649 unsigned int *sad_array); |
641 } | 650 } |
642 const sad_n_by_n_by_4_fn_t sad_64x64x4d_avx2 = vp9_sad64x64x4d_avx2; | 651 const SadMxNx4Func sad_64x64x4d_avx2 = vp9_sad64x64x4d_avx2; |
643 const sad_n_by_n_by_4_fn_t sad_32x32x4d_avx2 = vp9_sad32x32x4d_avx2; | 652 const SadMxNx4Func sad_32x32x4d_avx2 = vp9_sad32x32x4d_avx2; |
644 INSTANTIATE_TEST_CASE_P(DISABLED_AVX2, SADx4Test, ::testing::Values( | 653 INSTANTIATE_TEST_CASE_P(DISABLED_AVX2, SADx4Test, ::testing::Values( |
645 make_tuple(32, 32, sad_32x32x4d_avx2), | 654 make_tuple(32, 32, sad_32x32x4d_avx2), |
646 make_tuple(64, 64, sad_64x64x4d_avx2))); | 655 make_tuple(64, 64, sad_64x64x4d_avx2))); |
647 #endif // CONFIG_VP9_ENCODER | 656 #endif // CONFIG_VP9_ENCODER |
648 #endif // HAVE_AVX2 | 657 #endif // HAVE_AVX2 |
649 | 658 |
650 } // namespace | 659 } // namespace |
OLD | NEW |