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 #include <stdlib.h> | 10 #include <stdlib.h> |
(...skipping 17 matching lines...) Expand all Loading... |
28 #endif | 28 #endif |
29 #include "test/acm_random.h" | 29 #include "test/acm_random.h" |
30 | 30 |
31 namespace { | 31 namespace { |
32 | 32 |
33 using ::std::tr1::get; | 33 using ::std::tr1::get; |
34 using ::std::tr1::make_tuple; | 34 using ::std::tr1::make_tuple; |
35 using ::std::tr1::tuple; | 35 using ::std::tr1::tuple; |
36 using libvpx_test::ACMRandom; | 36 using libvpx_test::ACMRandom; |
37 | 37 |
| 38 static unsigned int mb_ss_ref(const int16_t *src) { |
| 39 unsigned int res = 0; |
| 40 for (int i = 0; i < 256; ++i) { |
| 41 res += src[i] * src[i]; |
| 42 } |
| 43 return res; |
| 44 } |
| 45 |
38 static unsigned int variance_ref(const uint8_t *ref, const uint8_t *src, | 46 static unsigned int variance_ref(const uint8_t *ref, const uint8_t *src, |
39 int l2w, int l2h, unsigned int *sse_ptr) { | 47 int l2w, int l2h, unsigned int *sse_ptr) { |
40 int se = 0; | 48 int se = 0; |
41 unsigned int sse = 0; | 49 unsigned int sse = 0; |
42 const int w = 1 << l2w, h = 1 << l2h; | 50 const int w = 1 << l2w, h = 1 << l2h; |
43 for (int y = 0; y < h; y++) { | 51 for (int y = 0; y < h; y++) { |
44 for (int x = 0; x < w; x++) { | 52 for (int x = 0; x < w; x++) { |
45 int diff = ref[w * y + x] - src[w * y + x]; | 53 int diff = ref[w * y + x] - src[w * y + x]; |
46 se += diff; | 54 se += diff; |
47 sse += diff * diff; | 55 sse += diff * diff; |
(...skipping 21 matching lines...) Expand all Loading... |
69 const int r = a + (((b - a) * yoff + 8) >> 4); | 77 const int r = a + (((b - a) * yoff + 8) >> 4); |
70 int diff = r - src[w * y + x]; | 78 int diff = r - src[w * y + x]; |
71 se += diff; | 79 se += diff; |
72 sse += diff * diff; | 80 sse += diff * diff; |
73 } | 81 } |
74 } | 82 } |
75 *sse_ptr = sse; | 83 *sse_ptr = sse; |
76 return sse - (((int64_t) se * se) >> (l2w + l2h)); | 84 return sse - (((int64_t) se * se) >> (l2w + l2h)); |
77 } | 85 } |
78 | 86 |
| 87 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src); |
| 88 |
| 89 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> { |
| 90 public: |
| 91 SumOfSquaresTest() : func_(GetParam()) {} |
| 92 |
| 93 virtual ~SumOfSquaresTest() { |
| 94 libvpx_test::ClearSystemState(); |
| 95 } |
| 96 |
| 97 protected: |
| 98 void ConstTest(); |
| 99 void RefTest(); |
| 100 |
| 101 SumOfSquaresFunction func_; |
| 102 ACMRandom rnd_; |
| 103 }; |
| 104 |
| 105 void SumOfSquaresTest::ConstTest() { |
| 106 int16_t mem[256]; |
| 107 unsigned int res; |
| 108 for (int v = 0; v < 256; ++v) { |
| 109 for (int i = 0; i < 256; ++i) { |
| 110 mem[i] = v; |
| 111 } |
| 112 ASM_REGISTER_STATE_CHECK(res = func_(mem)); |
| 113 EXPECT_EQ(256u * (v * v), res); |
| 114 } |
| 115 } |
| 116 |
| 117 void SumOfSquaresTest::RefTest() { |
| 118 int16_t mem[256]; |
| 119 for (int i = 0; i < 100; ++i) { |
| 120 for (int j = 0; j < 256; ++j) { |
| 121 mem[j] = rnd_.Rand8() - rnd_.Rand8(); |
| 122 } |
| 123 |
| 124 const unsigned int expected = mb_ss_ref(mem); |
| 125 unsigned int res; |
| 126 ASM_REGISTER_STATE_CHECK(res = func_(mem)); |
| 127 EXPECT_EQ(expected, res); |
| 128 } |
| 129 } |
| 130 |
79 template<typename VarianceFunctionType> | 131 template<typename VarianceFunctionType> |
80 class VarianceTest | 132 class VarianceTest |
81 : public ::testing::TestWithParam<tuple<int, int, VarianceFunctionType> > { | 133 : public ::testing::TestWithParam<tuple<int, int, VarianceFunctionType> > { |
82 public: | 134 public: |
83 virtual void SetUp() { | 135 virtual void SetUp() { |
84 const tuple<int, int, VarianceFunctionType>& params = this->GetParam(); | 136 const tuple<int, int, VarianceFunctionType>& params = this->GetParam(); |
85 log2width_ = get<0>(params); | 137 log2width_ = get<0>(params); |
86 width_ = 1 << log2width_; | 138 width_ = 1 << log2width_; |
87 log2height_ = get<1>(params); | 139 log2height_ = get<1>(params); |
88 height_ = 1 << log2height_; | 140 height_ = 1 << log2height_; |
89 variance_ = get<2>(params); | 141 variance_ = get<2>(params); |
90 | 142 |
91 rnd(ACMRandom::DeterministicSeed()); | 143 rnd_.Reset(ACMRandom::DeterministicSeed()); |
92 block_size_ = width_ * height_; | 144 block_size_ = width_ * height_; |
93 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); | 145 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); |
94 ref_ = new uint8_t[block_size_]; | 146 ref_ = new uint8_t[block_size_]; |
95 ASSERT_TRUE(src_ != NULL); | 147 ASSERT_TRUE(src_ != NULL); |
96 ASSERT_TRUE(ref_ != NULL); | 148 ASSERT_TRUE(ref_ != NULL); |
97 } | 149 } |
98 | 150 |
99 virtual void TearDown() { | 151 virtual void TearDown() { |
100 vpx_free(src_); | 152 vpx_free(src_); |
101 delete[] ref_; | 153 delete[] ref_; |
102 libvpx_test::ClearSystemState(); | 154 libvpx_test::ClearSystemState(); |
103 } | 155 } |
104 | 156 |
105 protected: | 157 protected: |
106 void ZeroTest(); | 158 void ZeroTest(); |
107 void RefTest(); | 159 void RefTest(); |
108 void OneQuarterTest(); | 160 void OneQuarterTest(); |
109 | 161 |
110 ACMRandom rnd; | 162 ACMRandom rnd_; |
111 uint8_t* src_; | 163 uint8_t* src_; |
112 uint8_t* ref_; | 164 uint8_t* ref_; |
113 int width_, log2width_; | 165 int width_, log2width_; |
114 int height_, log2height_; | 166 int height_, log2height_; |
115 int block_size_; | 167 int block_size_; |
116 VarianceFunctionType variance_; | 168 VarianceFunctionType variance_; |
117 }; | 169 }; |
118 | 170 |
119 template<typename VarianceFunctionType> | 171 template<typename VarianceFunctionType> |
120 void VarianceTest<VarianceFunctionType>::ZeroTest() { | 172 void VarianceTest<VarianceFunctionType>::ZeroTest() { |
121 for (int i = 0; i <= 255; ++i) { | 173 for (int i = 0; i <= 255; ++i) { |
122 memset(src_, i, block_size_); | 174 memset(src_, i, block_size_); |
123 for (int j = 0; j <= 255; ++j) { | 175 for (int j = 0; j <= 255; ++j) { |
124 memset(ref_, j, block_size_); | 176 memset(ref_, j, block_size_); |
125 unsigned int sse; | 177 unsigned int sse; |
126 unsigned int var; | 178 unsigned int var; |
127 ASM_REGISTER_STATE_CHECK( | 179 ASM_REGISTER_STATE_CHECK( |
128 var = variance_(src_, width_, ref_, width_, &sse)); | 180 var = variance_(src_, width_, ref_, width_, &sse)); |
129 EXPECT_EQ(0u, var) << "src values: " << i << "ref values: " << j; | 181 EXPECT_EQ(0u, var) << "src values: " << i << "ref values: " << j; |
130 } | 182 } |
131 } | 183 } |
132 } | 184 } |
133 | 185 |
134 template<typename VarianceFunctionType> | 186 template<typename VarianceFunctionType> |
135 void VarianceTest<VarianceFunctionType>::RefTest() { | 187 void VarianceTest<VarianceFunctionType>::RefTest() { |
136 for (int i = 0; i < 10; ++i) { | 188 for (int i = 0; i < 10; ++i) { |
137 for (int j = 0; j < block_size_; j++) { | 189 for (int j = 0; j < block_size_; j++) { |
138 src_[j] = rnd.Rand8(); | 190 src_[j] = rnd_.Rand8(); |
139 ref_[j] = rnd.Rand8(); | 191 ref_[j] = rnd_.Rand8(); |
140 } | 192 } |
141 unsigned int sse1, sse2; | 193 unsigned int sse1, sse2; |
142 unsigned int var1; | 194 unsigned int var1; |
143 ASM_REGISTER_STATE_CHECK( | 195 ASM_REGISTER_STATE_CHECK( |
144 var1 = variance_(src_, width_, ref_, width_, &sse1)); | 196 var1 = variance_(src_, width_, ref_, width_, &sse1)); |
145 const unsigned int var2 = variance_ref(src_, ref_, log2width_, | 197 const unsigned int var2 = variance_ref(src_, ref_, log2width_, |
146 log2height_, &sse2); | 198 log2height_, &sse2); |
147 EXPECT_EQ(sse1, sse2); | 199 EXPECT_EQ(sse1, sse2); |
148 EXPECT_EQ(var1, var2); | 200 EXPECT_EQ(var1, var2); |
149 } | 201 } |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
199 public: | 251 public: |
200 virtual void SetUp() { | 252 virtual void SetUp() { |
201 const tuple<int, int, SubpelVarianceFunctionType>& params = | 253 const tuple<int, int, SubpelVarianceFunctionType>& params = |
202 this->GetParam(); | 254 this->GetParam(); |
203 log2width_ = get<0>(params); | 255 log2width_ = get<0>(params); |
204 width_ = 1 << log2width_; | 256 width_ = 1 << log2width_; |
205 log2height_ = get<1>(params); | 257 log2height_ = get<1>(params); |
206 height_ = 1 << log2height_; | 258 height_ = 1 << log2height_; |
207 subpel_variance_ = get<2>(params); | 259 subpel_variance_ = get<2>(params); |
208 | 260 |
209 rnd(ACMRandom::DeterministicSeed()); | 261 rnd_.Reset(ACMRandom::DeterministicSeed()); |
210 block_size_ = width_ * height_; | 262 block_size_ = width_ * height_; |
211 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); | 263 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); |
212 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); | 264 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); |
213 ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; | 265 ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; |
214 ASSERT_TRUE(src_ != NULL); | 266 ASSERT_TRUE(src_ != NULL); |
215 ASSERT_TRUE(sec_ != NULL); | 267 ASSERT_TRUE(sec_ != NULL); |
216 ASSERT_TRUE(ref_ != NULL); | 268 ASSERT_TRUE(ref_ != NULL); |
217 } | 269 } |
218 | 270 |
219 virtual void TearDown() { | 271 virtual void TearDown() { |
220 vpx_free(src_); | 272 vpx_free(src_); |
221 delete[] ref_; | 273 delete[] ref_; |
222 vpx_free(sec_); | 274 vpx_free(sec_); |
223 libvpx_test::ClearSystemState(); | 275 libvpx_test::ClearSystemState(); |
224 } | 276 } |
225 | 277 |
226 protected: | 278 protected: |
227 void RefTest(); | 279 void RefTest(); |
228 | 280 |
229 ACMRandom rnd; | 281 ACMRandom rnd_; |
230 uint8_t *src_; | 282 uint8_t *src_; |
231 uint8_t *ref_; | 283 uint8_t *ref_; |
232 uint8_t *sec_; | 284 uint8_t *sec_; |
233 int width_, log2width_; | 285 int width_, log2width_; |
234 int height_, log2height_; | 286 int height_, log2height_; |
235 int block_size_; | 287 int block_size_; |
236 SubpelVarianceFunctionType subpel_variance_; | 288 SubpelVarianceFunctionType subpel_variance_; |
237 }; | 289 }; |
238 | 290 |
239 template<typename SubpelVarianceFunctionType> | 291 template<typename SubpelVarianceFunctionType> |
240 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { | 292 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { |
241 for (int x = 0; x < 16; ++x) { | 293 for (int x = 0; x < 16; ++x) { |
242 for (int y = 0; y < 16; ++y) { | 294 for (int y = 0; y < 16; ++y) { |
243 for (int j = 0; j < block_size_; j++) { | 295 for (int j = 0; j < block_size_; j++) { |
244 src_[j] = rnd.Rand8(); | 296 src_[j] = rnd_.Rand8(); |
245 } | 297 } |
246 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { | 298 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { |
247 ref_[j] = rnd.Rand8(); | 299 ref_[j] = rnd_.Rand8(); |
248 } | 300 } |
249 unsigned int sse1, sse2; | 301 unsigned int sse1, sse2; |
250 unsigned int var1; | 302 unsigned int var1; |
251 ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, | 303 ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, |
252 src_, width_, &sse1)); | 304 src_, width_, &sse1)); |
253 const unsigned int var2 = subpel_variance_ref(ref_, src_, log2width_, | 305 const unsigned int var2 = subpel_variance_ref(ref_, src_, log2width_, |
254 log2height_, x, y, &sse2); | 306 log2height_, x, y, &sse2); |
255 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; | 307 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; |
256 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; | 308 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; |
257 } | 309 } |
258 } | 310 } |
259 } | 311 } |
260 | 312 |
261 template<> | 313 template<> |
262 void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { | 314 void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { |
263 for (int x = 0; x < 16; ++x) { | 315 for (int x = 0; x < 16; ++x) { |
264 for (int y = 0; y < 16; ++y) { | 316 for (int y = 0; y < 16; ++y) { |
265 for (int j = 0; j < block_size_; j++) { | 317 for (int j = 0; j < block_size_; j++) { |
266 src_[j] = rnd.Rand8(); | 318 src_[j] = rnd_.Rand8(); |
267 sec_[j] = rnd.Rand8(); | 319 sec_[j] = rnd_.Rand8(); |
268 } | 320 } |
269 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { | 321 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { |
270 ref_[j] = rnd.Rand8(); | 322 ref_[j] = rnd_.Rand8(); |
271 } | 323 } |
272 unsigned int sse1, sse2; | 324 unsigned int sse1, sse2; |
273 unsigned int var1; | 325 unsigned int var1; |
274 ASM_REGISTER_STATE_CHECK( | 326 ASM_REGISTER_STATE_CHECK( |
275 var1 = subpel_variance_(ref_, width_ + 1, x, y, | 327 var1 = subpel_variance_(ref_, width_ + 1, x, y, |
276 src_, width_, &sse1, sec_)); | 328 src_, width_, &sse1, sec_)); |
277 const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_, | 329 const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_, |
278 log2width_, log2height_, | 330 log2width_, log2height_, |
279 x, y, &sse2); | 331 x, y, &sse2); |
280 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; | 332 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
355 #endif // CONFIG_VP8_ENCODER | 407 #endif // CONFIG_VP8_ENCODER |
356 | 408 |
357 } // namespace vp8 | 409 } // namespace vp8 |
358 | 410 |
359 // ----------------------------------------------------------------------------- | 411 // ----------------------------------------------------------------------------- |
360 // VP9 test cases. | 412 // VP9 test cases. |
361 | 413 |
362 namespace vp9 { | 414 namespace vp9 { |
363 | 415 |
364 #if CONFIG_VP9_ENCODER | 416 #if CONFIG_VP9_ENCODER |
| 417 |
| 418 TEST_P(SumOfSquaresTest, Const) { ConstTest(); } |
| 419 TEST_P(SumOfSquaresTest, Ref) { RefTest(); } |
| 420 |
| 421 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, |
| 422 ::testing::Values(vp9_get_mb_ss_c)); |
| 423 |
365 typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest; | 424 typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest; |
366 typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest; | 425 typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest; |
367 typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest; | 426 typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest; |
368 | 427 |
369 TEST_P(VP9VarianceTest, Zero) { ZeroTest(); } | 428 TEST_P(VP9VarianceTest, Zero) { ZeroTest(); } |
370 TEST_P(VP9VarianceTest, Ref) { RefTest(); } | 429 TEST_P(VP9VarianceTest, Ref) { RefTest(); } |
371 TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); } | 430 TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); } |
372 TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); } | 431 TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); } |
373 TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); } | 432 TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); } |
374 | 433 |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
478 make_tuple(3, 4, subpel_avg_variance8x16_c), | 537 make_tuple(3, 4, subpel_avg_variance8x16_c), |
479 make_tuple(4, 3, subpel_avg_variance16x8_c), | 538 make_tuple(4, 3, subpel_avg_variance16x8_c), |
480 make_tuple(4, 4, subpel_avg_variance16x16_c), | 539 make_tuple(4, 4, subpel_avg_variance16x16_c), |
481 make_tuple(4, 5, subpel_avg_variance16x32_c), | 540 make_tuple(4, 5, subpel_avg_variance16x32_c), |
482 make_tuple(5, 4, subpel_avg_variance32x16_c), | 541 make_tuple(5, 4, subpel_avg_variance32x16_c), |
483 make_tuple(5, 5, subpel_avg_variance32x32_c), | 542 make_tuple(5, 5, subpel_avg_variance32x32_c), |
484 make_tuple(5, 6, subpel_avg_variance32x64_c), | 543 make_tuple(5, 6, subpel_avg_variance32x64_c), |
485 make_tuple(6, 5, subpel_avg_variance64x32_c), | 544 make_tuple(6, 5, subpel_avg_variance64x32_c), |
486 make_tuple(6, 6, subpel_avg_variance64x64_c))); | 545 make_tuple(6, 6, subpel_avg_variance64x64_c))); |
487 | 546 |
488 #if HAVE_MMX | |
489 const vp9_variance_fn_t variance4x4_mmx = vp9_variance4x4_mmx; | |
490 const vp9_variance_fn_t variance8x8_mmx = vp9_variance8x8_mmx; | |
491 const vp9_variance_fn_t variance8x16_mmx = vp9_variance8x16_mmx; | |
492 const vp9_variance_fn_t variance16x8_mmx = vp9_variance16x8_mmx; | |
493 const vp9_variance_fn_t variance16x16_mmx = vp9_variance16x16_mmx; | |
494 INSTANTIATE_TEST_CASE_P( | |
495 MMX, VP9VarianceTest, | |
496 ::testing::Values(make_tuple(2, 2, variance4x4_mmx), | |
497 make_tuple(3, 3, variance8x8_mmx), | |
498 make_tuple(3, 4, variance8x16_mmx), | |
499 make_tuple(4, 3, variance16x8_mmx), | |
500 make_tuple(4, 4, variance16x16_mmx))); | |
501 #endif | |
502 | |
503 #if HAVE_SSE2 | 547 #if HAVE_SSE2 |
504 #if CONFIG_USE_X86INC | 548 #if CONFIG_USE_X86INC |
| 549 |
| 550 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, |
| 551 ::testing::Values(vp9_get_mb_ss_sse2)); |
| 552 |
505 const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2; | 553 const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2; |
506 const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2; | 554 const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2; |
507 const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2; | 555 const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2; |
508 const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2; | 556 const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2; |
509 const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2; | 557 const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2; |
510 const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2; | 558 const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2; |
511 const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2; | 559 const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2; |
512 const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2; | 560 const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2; |
513 const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2; | 561 const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2; |
514 const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2; | 562 const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2; |
(...skipping 244 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
759 NEON, VP9SubpelVarianceTest, | 807 NEON, VP9SubpelVarianceTest, |
760 ::testing::Values(make_tuple(3, 3, subpel_variance8x8_neon), | 808 ::testing::Values(make_tuple(3, 3, subpel_variance8x8_neon), |
761 make_tuple(4, 4, subpel_variance16x16_neon), | 809 make_tuple(4, 4, subpel_variance16x16_neon), |
762 make_tuple(5, 5, subpel_variance32x32_neon))); | 810 make_tuple(5, 5, subpel_variance32x32_neon))); |
763 #endif // HAVE_NEON | 811 #endif // HAVE_NEON |
764 #endif // CONFIG_VP9_ENCODER | 812 #endif // CONFIG_VP9_ENCODER |
765 | 813 |
766 } // namespace vp9 | 814 } // namespace vp9 |
767 | 815 |
768 } // namespace | 816 } // namespace |
OLD | NEW |