1 /*
2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved.
3 *
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.
9 */
10
11 #include <cstdlib>
12 #include <new>
13
14 #include "third_party/googletest/src/include/gtest/gtest.h"
15
16 #include "./vpx_config.h"
17 #include "./vpx_dsp_rtcd.h"
18 #include "test/acm_random.h"
19 #include "test/clear_system_state.h"
20 #include "test/register_state_check.h"
21 #include "vpx/vpx_codec.h"
22 #include "vpx/vpx_integer.h"
23 #include "vpx_dsp/variance.h"
24 #include "vpx_mem/vpx_mem.h"
25 #include "vpx_ports/mem.h"
26 #include "vpx_ports/vpx_timer.h"
27
28 namespace {
29
30 typedef unsigned int (*Get4x4SseFunc)(const uint8_t *a, int a_stride,
31 const uint8_t *b, int b_stride);
32 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src);
33
34 using libvpx_test::ACMRandom;
35
36 // Truncate high bit depth results by downshifting (with rounding) by:
37 // 2 * (bit_depth - 8) for sse
38 // (bit_depth - 8) for se
RoundHighBitDepth(int bit_depth,int64_t * se,uint64_t * sse)39 static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
40 switch (bit_depth) {
41 case VPX_BITS_12:
42 *sse = (*sse + 128) >> 8;
43 *se = (*se + 8) >> 4;
44 break;
45 case VPX_BITS_10:
46 *sse = (*sse + 8) >> 4;
47 *se = (*se + 2) >> 2;
48 break;
49 case VPX_BITS_8:
50 default: break;
51 }
52 }
53
mb_ss_ref(const int16_t * src)54 static unsigned int mb_ss_ref(const int16_t *src) {
55 unsigned int res = 0;
56 for (int i = 0; i < 256; ++i) {
57 res += src[i] * src[i];
58 }
59 return res;
60 }
61
62 /* Note:
63 * Our codebase calculates the "diff" value in the variance algorithm by
64 * (src - ref).
65 */
variance_ref(const uint8_t * src,const uint8_t * ref,int l2w,int l2h,int src_stride,int ref_stride,uint32_t * sse_ptr,bool use_high_bit_depth_,vpx_bit_depth_t bit_depth)66 static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w,
67 int l2h, int src_stride, int ref_stride,
68 uint32_t *sse_ptr, bool use_high_bit_depth_,
69 vpx_bit_depth_t bit_depth) {
70 int64_t se = 0;
71 uint64_t sse = 0;
72 const int w = 1 << l2w;
73 const int h = 1 << l2h;
74 for (int y = 0; y < h; y++) {
75 for (int x = 0; x < w; x++) {
76 int diff;
77 if (!use_high_bit_depth_) {
78 diff = src[y * src_stride + x] - ref[y * ref_stride + x];
79 se += diff;
80 sse += diff * diff;
81 #if CONFIG_VP9_HIGHBITDEPTH
82 } else {
83 diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] -
84 CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x];
85 se += diff;
86 sse += diff * diff;
87 #endif // CONFIG_VP9_HIGHBITDEPTH
88 }
89 }
90 }
91 RoundHighBitDepth(bit_depth, &se, &sse);
92 *sse_ptr = static_cast<uint32_t>(sse);
93 return static_cast<uint32_t>(
94 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
95 }
96
97 /* The subpel reference functions differ from the codec version in one aspect:
98 * they calculate the bilinear factors directly instead of using a lookup table
99 * and therefore upshift xoff and yoff by 1. Only every other calculated value
100 * is used so the codec version shrinks the table to save space and maintain
101 * compatibility with vp8.
102 */
subpel_variance_ref(const uint8_t * ref,const uint8_t * src,int l2w,int l2h,int xoff,int yoff,uint32_t * sse_ptr,bool use_high_bit_depth_,vpx_bit_depth_t bit_depth)103 static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
104 int l2w, int l2h, int xoff, int yoff,
105 uint32_t *sse_ptr, bool use_high_bit_depth_,
106 vpx_bit_depth_t bit_depth) {
107 int64_t se = 0;
108 uint64_t sse = 0;
109 const int w = 1 << l2w;
110 const int h = 1 << l2h;
111
112 xoff <<= 1;
113 yoff <<= 1;
114
115 for (int y = 0; y < h; y++) {
116 for (int x = 0; x < w; x++) {
117 // Bilinear interpolation at a 16th pel step.
118 if (!use_high_bit_depth_) {
119 const int a1 = ref[(w + 1) * (y + 0) + x + 0];
120 const int a2 = ref[(w + 1) * (y + 0) + x + 1];
121 const int b1 = ref[(w + 1) * (y + 1) + x + 0];
122 const int b2 = ref[(w + 1) * (y + 1) + x + 1];
123 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
124 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
125 const int r = a + (((b - a) * yoff + 8) >> 4);
126 const int diff = r - src[w * y + x];
127 se += diff;
128 sse += diff * diff;
129 #if CONFIG_VP9_HIGHBITDEPTH
130 } else {
131 uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
132 uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
133 const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
134 const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
135 const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
136 const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
137 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
138 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
139 const int r = a + (((b - a) * yoff + 8) >> 4);
140 const int diff = r - src16[w * y + x];
141 se += diff;
142 sse += diff * diff;
143 #endif // CONFIG_VP9_HIGHBITDEPTH
144 }
145 }
146 }
147 RoundHighBitDepth(bit_depth, &se, &sse);
148 *sse_ptr = static_cast<uint32_t>(sse);
149 return static_cast<uint32_t>(
150 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
151 }
152
subpel_avg_variance_ref(const uint8_t * ref,const uint8_t * src,const uint8_t * second_pred,int l2w,int l2h,int xoff,int yoff,uint32_t * sse_ptr,bool use_high_bit_depth,vpx_bit_depth_t bit_depth)153 static uint32_t subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src,
154 const uint8_t *second_pred, int l2w,
155 int l2h, int xoff, int yoff,
156 uint32_t *sse_ptr,
157 bool use_high_bit_depth,
158 vpx_bit_depth_t bit_depth) {
159 int64_t se = 0;
160 uint64_t sse = 0;
161 const int w = 1 << l2w;
162 const int h = 1 << l2h;
163
164 xoff <<= 1;
165 yoff <<= 1;
166
167 for (int y = 0; y < h; y++) {
168 for (int x = 0; x < w; x++) {
169 // bilinear interpolation at a 16th pel step
170 if (!use_high_bit_depth) {
171 const int a1 = ref[(w + 1) * (y + 0) + x + 0];
172 const int a2 = ref[(w + 1) * (y + 0) + x + 1];
173 const int b1 = ref[(w + 1) * (y + 1) + x + 0];
174 const int b2 = ref[(w + 1) * (y + 1) + x + 1];
175 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
176 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
177 const int r = a + (((b - a) * yoff + 8) >> 4);
178 const int diff =
179 ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x];
180 se += diff;
181 sse += diff * diff;
182 #if CONFIG_VP9_HIGHBITDEPTH
183 } else {
184 const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
185 const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
186 const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred);
187 const int a1 = ref16[(w + 1) * (y + 0) + x + 0];
188 const int a2 = ref16[(w + 1) * (y + 0) + x + 1];
189 const int b1 = ref16[(w + 1) * (y + 1) + x + 0];
190 const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
191 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
192 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
193 const int r = a + (((b - a) * yoff + 8) >> 4);
194 const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x];
195 se += diff;
196 sse += diff * diff;
197 #endif // CONFIG_VP9_HIGHBITDEPTH
198 }
199 }
200 }
201 RoundHighBitDepth(bit_depth, &se, &sse);
202 *sse_ptr = static_cast<uint32_t>(sse);
203 return static_cast<uint32_t>(
204 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
205 }
206
207 ////////////////////////////////////////////////////////////////////////////////
208
209 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> {
210 public:
SumOfSquaresTest()211 SumOfSquaresTest() : func_(GetParam()) {}
212
~SumOfSquaresTest()213 ~SumOfSquaresTest() override { libvpx_test::ClearSystemState(); }
214
215 protected:
216 void ConstTest();
217 void RefTest();
218
219 SumOfSquaresFunction func_;
220 ACMRandom rnd_;
221 };
222
ConstTest()223 void SumOfSquaresTest::ConstTest() {
224 int16_t mem[256];
225 unsigned int res;
226 for (int v = 0; v < 256; ++v) {
227 for (int i = 0; i < 256; ++i) {
228 mem[i] = v;
229 }
230 ASM_REGISTER_STATE_CHECK(res = func_(mem));
231 EXPECT_EQ(256u * (v * v), res);
232 }
233 }
234
RefTest()235 void SumOfSquaresTest::RefTest() {
236 int16_t mem[256];
237 for (int i = 0; i < 100; ++i) {
238 for (int j = 0; j < 256; ++j) {
239 mem[j] = rnd_.Rand8() - rnd_.Rand8();
240 }
241
242 const unsigned int expected = mb_ss_ref(mem);
243 unsigned int res;
244 ASM_REGISTER_STATE_CHECK(res = func_(mem));
245 EXPECT_EQ(expected, res);
246 }
247 }
248
249 ////////////////////////////////////////////////////////////////////////////////
250 // Encapsulating struct to store the function to test along with
251 // some testing context.
252 // Can be used for MSE, SSE, Variance, etc.
253
254 template <typename Func>
255 struct TestParams {
TestParams__anona3af5e140111::TestParams256 TestParams(int log2w = 0, int log2h = 0, Func function = nullptr,
257 int bit_depth_value = 0)
258 : log2width(log2w), log2height(log2h), func(function) {
259 use_high_bit_depth = (bit_depth_value > 0);
260 if (use_high_bit_depth) {
261 bit_depth = static_cast<vpx_bit_depth_t>(bit_depth_value);
262 } else {
263 bit_depth = VPX_BITS_8;
264 }
265 width = 1 << log2width;
266 height = 1 << log2height;
267 block_size = width * height;
268 mask = (1u << bit_depth) - 1;
269 }
270
271 int log2width, log2height;
272 int width, height;
273 int block_size;
274 Func func;
275 vpx_bit_depth_t bit_depth;
276 bool use_high_bit_depth;
277 uint32_t mask;
278 };
279
280 template <typename Func>
operator <<(std::ostream & os,const TestParams<Func> & p)281 std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) {
282 return os << "log2width/height:" << p.log2width << "/" << p.log2height
283 << " function:" << reinterpret_cast<const void *>(p.func)
284 << " bit-depth:" << p.bit_depth;
285 }
286
287 // Main class for testing a function type
288 template <typename FunctionType>
289 class MainTestClass
290 : public ::testing::TestWithParam<TestParams<FunctionType> > {
291 public:
SetUp()292 void SetUp() override {
293 params_ = this->GetParam();
294
295 rnd_.Reset(ACMRandom::DeterministicSeed());
296 const size_t unit =
297 use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
298 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit));
299 ref_ = new uint8_t[block_size() * unit];
300 ASSERT_NE(src_, nullptr);
301 ASSERT_NE(ref_, nullptr);
302 #if CONFIG_VP9_HIGHBITDEPTH
303 if (use_high_bit_depth()) {
304 // TODO(skal): remove!
305 src_ = CONVERT_TO_BYTEPTR(src_);
306 ref_ = CONVERT_TO_BYTEPTR(ref_);
307 }
308 #endif
309 }
310
TearDown()311 void TearDown() override {
312 #if CONFIG_VP9_HIGHBITDEPTH
313 if (use_high_bit_depth()) {
314 // TODO(skal): remove!
315 src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
316 ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_));
317 }
318 #endif
319
320 vpx_free(src_);
321 delete[] ref_;
322 src_ = nullptr;
323 ref_ = nullptr;
324 libvpx_test::ClearSystemState();
325 }
326
327 protected:
328 // We could sub-class MainTestClass into dedicated class for Variance
329 // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing
330 // to access top class fields xxx. That's cumbersome, so for now we'll just
331 // implement the testing methods here:
332
333 // Variance tests
334 void ZeroTest();
335 void RefTest();
336 void RefStrideTest();
337 void OneQuarterTest();
338 void SpeedTest();
339
340 // MSE/SSE tests
341 void RefTestMse();
342 void RefTestSse();
343 void MaxTestMse();
344 void MaxTestSse();
345
346 protected:
347 ACMRandom rnd_;
348 uint8_t *src_;
349 uint8_t *ref_;
350 TestParams<FunctionType> params_;
351
352 // some relay helpers
use_high_bit_depth() const353 bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
byte_shift() const354 int byte_shift() const { return params_.bit_depth - 8; }
block_size() const355 int block_size() const { return params_.block_size; }
width() const356 int width() const { return params_.width; }
height() const357 int height() const { return params_.height; }
mask() const358 uint32_t mask() const { return params_.mask; }
359 };
360
361 ////////////////////////////////////////////////////////////////////////////////
362 // Tests related to variance.
363
364 template <typename VarianceFunctionType>
ZeroTest()365 void MainTestClass<VarianceFunctionType>::ZeroTest() {
366 for (int i = 0; i <= 255; ++i) {
367 if (!use_high_bit_depth()) {
368 memset(src_, i, block_size());
369 } else {
370 uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_);
371 for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift();
372 }
373 for (int j = 0; j <= 255; ++j) {
374 if (!use_high_bit_depth()) {
375 memset(ref_, j, block_size());
376 } else {
377 uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_);
378 for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift();
379 }
380 unsigned int sse, var;
381 ASM_REGISTER_STATE_CHECK(
382 var = params_.func(src_, width(), ref_, width(), &sse));
383 EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j;
384 }
385 }
386 }
387
388 template <typename VarianceFunctionType>
RefTest()389 void MainTestClass<VarianceFunctionType>::RefTest() {
390 for (int i = 0; i < 10; ++i) {
391 for (int j = 0; j < block_size(); j++) {
392 if (!use_high_bit_depth()) {
393 src_[j] = rnd_.Rand8();
394 ref_[j] = rnd_.Rand8();
395 #if CONFIG_VP9_HIGHBITDEPTH
396 } else {
397 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
398 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
399 #endif // CONFIG_VP9_HIGHBITDEPTH
400 }
401 }
402 unsigned int sse1, sse2, var1, var2;
403 const int stride = width();
404 ASM_REGISTER_STATE_CHECK(
405 var1 = params_.func(src_, stride, ref_, stride, &sse1));
406 var2 =
407 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
408 stride, &sse2, use_high_bit_depth(), params_.bit_depth);
409 EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
410 EXPECT_EQ(var1, var2) << "Error at test index: " << i;
411 }
412 }
413
414 template <typename VarianceFunctionType>
RefStrideTest()415 void MainTestClass<VarianceFunctionType>::RefStrideTest() {
416 for (int i = 0; i < 10; ++i) {
417 const int ref_stride = (i & 1) * width();
418 const int src_stride = ((i >> 1) & 1) * width();
419 for (int j = 0; j < block_size(); j++) {
420 const int ref_ind = (j / width()) * ref_stride + j % width();
421 const int src_ind = (j / width()) * src_stride + j % width();
422 if (!use_high_bit_depth()) {
423 src_[src_ind] = rnd_.Rand8();
424 ref_[ref_ind] = rnd_.Rand8();
425 #if CONFIG_VP9_HIGHBITDEPTH
426 } else {
427 CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() & mask();
428 CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() & mask();
429 #endif // CONFIG_VP9_HIGHBITDEPTH
430 }
431 }
432 unsigned int sse1, sse2;
433 unsigned int var1, var2;
434
435 ASM_REGISTER_STATE_CHECK(
436 var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1));
437 var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height,
438 src_stride, ref_stride, &sse2, use_high_bit_depth(),
439 params_.bit_depth);
440 EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
441 EXPECT_EQ(var1, var2) << "Error at test index: " << i;
442 }
443 }
444
445 template <typename VarianceFunctionType>
OneQuarterTest()446 void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
447 const int half = block_size() / 2;
448 if (!use_high_bit_depth()) {
449 memset(src_, 255, block_size());
450 memset(ref_, 255, half);
451 memset(ref_ + half, 0, half);
452 #if CONFIG_VP9_HIGHBITDEPTH
453 } else {
454 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
455 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
456 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
457 #endif // CONFIG_VP9_HIGHBITDEPTH
458 }
459 unsigned int sse, var, expected;
460 ASM_REGISTER_STATE_CHECK(
461 var = params_.func(src_, width(), ref_, width(), &sse));
462 expected = block_size() * 255 * 255 / 4;
463 EXPECT_EQ(expected, var);
464 }
465
466 template <typename VarianceFunctionType>
SpeedTest()467 void MainTestClass<VarianceFunctionType>::SpeedTest() {
468 const int half = block_size() / 2;
469 if (!use_high_bit_depth()) {
470 memset(src_, 255, block_size());
471 memset(ref_, 255, half);
472 memset(ref_ + half, 0, half);
473 #if CONFIG_VP9_HIGHBITDEPTH
474 } else {
475 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
476 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
477 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
478 #endif // CONFIG_VP9_HIGHBITDEPTH
479 }
480 unsigned int sse;
481
482 vpx_usec_timer timer;
483 vpx_usec_timer_start(&timer);
484 for (int i = 0; i < (1 << 30) / block_size(); ++i) {
485 const uint32_t variance = params_.func(src_, width(), ref_, width(), &sse);
486 // Ignore return value.
487 (void)variance;
488 }
489 vpx_usec_timer_mark(&timer);
490 const int elapsed_time = static_cast<int>(vpx_usec_timer_elapsed(&timer));
491 printf("Variance %dx%d %dbpp time: %5d ms\n", width(), height(),
492 params_.bit_depth, elapsed_time / 1000);
493 }
494
495 ////////////////////////////////////////////////////////////////////////////////
496 // Tests related to MSE / SSE.
497
498 template <typename FunctionType>
RefTestMse()499 void MainTestClass<FunctionType>::RefTestMse() {
500 for (int i = 0; i < 10; ++i) {
501 for (int j = 0; j < block_size(); ++j) {
502 if (!use_high_bit_depth()) {
503 src_[j] = rnd_.Rand8();
504 ref_[j] = rnd_.Rand8();
505 #if CONFIG_VP9_HIGHBITDEPTH
506 } else {
507 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
508 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
509 #endif // CONFIG_VP9_HIGHBITDEPTH
510 }
511 }
512 unsigned int sse1, sse2;
513 const int stride = width();
514 ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
515 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
516 stride, &sse2, use_high_bit_depth(), params_.bit_depth);
517 EXPECT_EQ(sse1, sse2);
518 }
519 }
520
521 template <typename FunctionType>
RefTestSse()522 void MainTestClass<FunctionType>::RefTestSse() {
523 for (int i = 0; i < 10; ++i) {
524 for (int j = 0; j < block_size(); ++j) {
525 src_[j] = rnd_.Rand8();
526 ref_[j] = rnd_.Rand8();
527 }
528 unsigned int sse2;
529 unsigned int var1;
530 const int stride = width();
531 ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride));
532 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
533 stride, &sse2, false, VPX_BITS_8);
534 EXPECT_EQ(var1, sse2);
535 }
536 }
537
538 template <typename FunctionType>
MaxTestMse()539 void MainTestClass<FunctionType>::MaxTestMse() {
540 if (!use_high_bit_depth()) {
541 memset(src_, 255, block_size());
542 memset(ref_, 0, block_size());
543 #if CONFIG_VP9_HIGHBITDEPTH
544 } else {
545 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
546 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, block_size());
547 #endif // CONFIG_VP9_HIGHBITDEPTH
548 }
549 unsigned int sse;
550 ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse));
551 const unsigned int expected = block_size() * 255 * 255;
552 EXPECT_EQ(expected, sse);
553 }
554
555 template <typename FunctionType>
MaxTestSse()556 void MainTestClass<FunctionType>::MaxTestSse() {
557 memset(src_, 255, block_size());
558 memset(ref_, 0, block_size());
559 unsigned int var;
560 ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_, width()));
561 const unsigned int expected = block_size() * 255 * 255;
562 EXPECT_EQ(expected, var);
563 }
564
565 ////////////////////////////////////////////////////////////////////////////////
566
567 template <typename FunctionType>
568 class SubpelVarianceTest
569 : public ::testing::TestWithParam<TestParams<FunctionType> > {
570 public:
SetUp()571 void SetUp() override {
572 params_ = this->GetParam();
573
574 rnd_.Reset(ACMRandom::DeterministicSeed());
575 if (!use_high_bit_depth()) {
576 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size()));
577 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size()));
578 ref_ = reinterpret_cast<uint8_t *>(
579 vpx_malloc(block_size() + width() + height() + 1));
580 #if CONFIG_VP9_HIGHBITDEPTH
581 } else {
582 src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
583 vpx_memalign(16, block_size() * sizeof(uint16_t))));
584 sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
585 vpx_memalign(16, block_size() * sizeof(uint16_t))));
586 ref_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(vpx_malloc(
587 (block_size() + width() + height() + 1) * sizeof(uint16_t))));
588 #endif // CONFIG_VP9_HIGHBITDEPTH
589 }
590 ASSERT_NE(src_, nullptr);
591 ASSERT_NE(sec_, nullptr);
592 ASSERT_NE(ref_, nullptr);
593 }
594
TearDown()595 void TearDown() override {
596 if (!use_high_bit_depth()) {
597 vpx_free(src_);
598 vpx_free(sec_);
599 vpx_free(ref_);
600 #if CONFIG_VP9_HIGHBITDEPTH
601 } else {
602 vpx_free(CONVERT_TO_SHORTPTR(src_));
603 vpx_free(CONVERT_TO_SHORTPTR(ref_));
604 vpx_free(CONVERT_TO_SHORTPTR(sec_));
605 #endif // CONFIG_VP9_HIGHBITDEPTH
606 }
607 libvpx_test::ClearSystemState();
608 }
609
610 protected:
611 void RefTest();
612 void ExtremeRefTest();
613 void SpeedTest();
614
615 ACMRandom rnd_;
616 uint8_t *src_;
617 uint8_t *ref_;
618 uint8_t *sec_;
619 TestParams<FunctionType> params_;
620
621 // some relay helpers
use_high_bit_depth() const622 bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
byte_shift() const623 int byte_shift() const { return params_.bit_depth - 8; }
block_size() const624 int block_size() const { return params_.block_size; }
width() const625 int width() const { return params_.width; }
height() const626 int height() const { return params_.height; }
mask() const627 uint32_t mask() const { return params_.mask; }
628 };
629
630 template <typename SubpelVarianceFunctionType>
RefTest()631 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
632 for (int x = 0; x < 8; ++x) {
633 for (int y = 0; y < 8; ++y) {
634 if (!use_high_bit_depth()) {
635 for (int j = 0; j < block_size(); j++) {
636 src_[j] = rnd_.Rand8();
637 }
638 for (int j = 0; j < block_size() + width() + height() + 1; j++) {
639 ref_[j] = rnd_.Rand8();
640 }
641 #if CONFIG_VP9_HIGHBITDEPTH
642 } else {
643 for (int j = 0; j < block_size(); j++) {
644 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
645 }
646 for (int j = 0; j < block_size() + width() + height() + 1; j++) {
647 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
648 }
649 #endif // CONFIG_VP9_HIGHBITDEPTH
650 }
651 unsigned int sse1, sse2;
652 unsigned int var1;
653 ASM_REGISTER_STATE_CHECK(
654 var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
655 const unsigned int var2 = subpel_variance_ref(
656 ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
657 use_high_bit_depth(), params_.bit_depth);
658 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
659 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
660 }
661 }
662 }
663
664 template <typename SubpelVarianceFunctionType>
ExtremeRefTest()665 void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() {
666 // Compare against reference.
667 // Src: Set the first half of values to 0, the second half to the maximum.
668 // Ref: Set the first half of values to the maximum, the second half to 0.
669 for (int x = 0; x < 8; ++x) {
670 for (int y = 0; y < 8; ++y) {
671 const int half = block_size() / 2;
672 if (!use_high_bit_depth()) {
673 memset(src_, 0, half);
674 memset(src_ + half, 255, half);
675 memset(ref_, 255, half);
676 memset(ref_ + half, 0, half + width() + height() + 1);
677 #if CONFIG_VP9_HIGHBITDEPTH
678 } else {
679 vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask(), half);
680 vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half);
681 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half);
682 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask(),
683 half + width() + height() + 1);
684 #endif // CONFIG_VP9_HIGHBITDEPTH
685 }
686 unsigned int sse1, sse2;
687 unsigned int var1;
688 ASM_REGISTER_STATE_CHECK(
689 var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
690 const unsigned int var2 = subpel_variance_ref(
691 ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
692 use_high_bit_depth(), params_.bit_depth);
693 EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
694 EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
695 }
696 }
697 }
698
699 template <typename SubpelVarianceFunctionType>
SpeedTest()700 void SubpelVarianceTest<SubpelVarianceFunctionType>::SpeedTest() {
701 // The only interesting points are 0, 4, and anything else. To make the loops
702 // simple we will use 0, 2 and 4.
703 for (int x = 0; x <= 4; x += 2) {
704 for (int y = 0; y <= 4; y += 2) {
705 if (!use_high_bit_depth()) {
706 memset(src_, 25, block_size());
707 memset(ref_, 50, block_size());
708 #if CONFIG_VP9_HIGHBITDEPTH
709 } else {
710 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 25, block_size());
711 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 50, block_size());
712 #endif // CONFIG_VP9_HIGHBITDEPTH
713 }
714 unsigned int sse;
715 vpx_usec_timer timer;
716 vpx_usec_timer_start(&timer);
717 for (int i = 0; i < 1000000000 / block_size(); ++i) {
718 const uint32_t variance =
719 params_.func(ref_, width() + 1, x, y, src_, width(), &sse);
720 (void)variance;
721 }
722 vpx_usec_timer_mark(&timer);
723 const int elapsed_time = static_cast<int>(vpx_usec_timer_elapsed(&timer));
724 printf("SubpelVariance %dx%d xoffset: %d yoffset: %d time: %5d ms\n",
725 width(), height(), x, y, elapsed_time / 1000);
726 }
727 }
728 }
729
730 template <>
RefTest()731 void SubpelVarianceTest<vpx_subp_avg_variance_fn_t>::RefTest() {
732 for (int x = 0; x < 8; ++x) {
733 for (int y = 0; y < 8; ++y) {
734 if (!use_high_bit_depth()) {
735 for (int j = 0; j < block_size(); j++) {
736 src_[j] = rnd_.Rand8();
737 sec_[j] = rnd_.Rand8();
738 }
739 for (int j = 0; j < block_size() + width() + height() + 1; j++) {
740 ref_[j] = rnd_.Rand8();
741 }
742 #if CONFIG_VP9_HIGHBITDEPTH
743 } else {
744 for (int j = 0; j < block_size(); j++) {
745 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
746 CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask();
747 }
748 for (int j = 0; j < block_size() + width() + height() + 1; j++) {
749 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
750 }
751 #endif // CONFIG_VP9_HIGHBITDEPTH
752 }
753 uint32_t sse1, sse2;
754 uint32_t var1, var2;
755 ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 1, x, y,
756 src_, width(), &sse1, sec_));
757 var2 = subpel_avg_variance_ref(ref_, src_, sec_, params_.log2width,
758 params_.log2height, x, y, &sse2,
759 use_high_bit_depth(), params_.bit_depth);
760 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
761 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
762 }
763 }
764 }
765
766 typedef MainTestClass<Get4x4SseFunc> VpxSseTest;
767 typedef MainTestClass<vpx_variance_fn_t> VpxMseTest;
768 typedef MainTestClass<vpx_variance_fn_t> VpxVarianceTest;
769 typedef SubpelVarianceTest<vpx_subpixvariance_fn_t> VpxSubpelVarianceTest;
770 typedef SubpelVarianceTest<vpx_subp_avg_variance_fn_t> VpxSubpelAvgVarianceTest;
771
TEST_P(VpxSseTest,RefSse)772 TEST_P(VpxSseTest, RefSse) { RefTestSse(); }
TEST_P(VpxSseTest,MaxSse)773 TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); }
TEST_P(VpxMseTest,RefMse)774 TEST_P(VpxMseTest, RefMse) { RefTestMse(); }
TEST_P(VpxMseTest,MaxMse)775 TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); }
TEST_P(VpxMseTest,DISABLED_Speed)776 TEST_P(VpxMseTest, DISABLED_Speed) { SpeedTest(); }
TEST_P(VpxVarianceTest,Zero)777 TEST_P(VpxVarianceTest, Zero) { ZeroTest(); }
TEST_P(VpxVarianceTest,Ref)778 TEST_P(VpxVarianceTest, Ref) { RefTest(); }
TEST_P(VpxVarianceTest,RefStride)779 TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); }
TEST_P(VpxVarianceTest,OneQuarter)780 TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); }
TEST_P(VpxVarianceTest,DISABLED_Speed)781 TEST_P(VpxVarianceTest, DISABLED_Speed) { SpeedTest(); }
TEST_P(SumOfSquaresTest,Const)782 TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
TEST_P(SumOfSquaresTest,Ref)783 TEST_P(SumOfSquaresTest, Ref) { RefTest(); }
TEST_P(VpxSubpelVarianceTest,Ref)784 TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); }
TEST_P(VpxSubpelVarianceTest,ExtremeRef)785 TEST_P(VpxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
TEST_P(VpxSubpelVarianceTest,DISABLED_Speed)786 TEST_P(VpxSubpelVarianceTest, DISABLED_Speed) { SpeedTest(); }
TEST_P(VpxSubpelAvgVarianceTest,Ref)787 TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); }
788
789 INSTANTIATE_TEST_SUITE_P(C, SumOfSquaresTest,
790 ::testing::Values(vpx_get_mb_ss_c));
791
792 typedef TestParams<Get4x4SseFunc> SseParams;
793 INSTANTIATE_TEST_SUITE_P(C, VpxSseTest,
794 ::testing::Values(SseParams(2, 2,
795 &vpx_get4x4sse_cs_c)));
796
797 typedef TestParams<vpx_variance_fn_t> MseParams;
798 INSTANTIATE_TEST_SUITE_P(C, VpxMseTest,
799 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c),
800 MseParams(4, 3, &vpx_mse16x8_c),
801 MseParams(3, 4, &vpx_mse8x16_c),
802 MseParams(3, 3, &vpx_mse8x8_c)));
803
804 typedef TestParams<vpx_variance_fn_t> VarianceParams;
805 INSTANTIATE_TEST_SUITE_P(
806 C, VpxVarianceTest,
807 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c),
808 VarianceParams(6, 5, &vpx_variance64x32_c),
809 VarianceParams(5, 6, &vpx_variance32x64_c),
810 VarianceParams(5, 5, &vpx_variance32x32_c),
811 VarianceParams(5, 4, &vpx_variance32x16_c),
812 VarianceParams(4, 5, &vpx_variance16x32_c),
813 VarianceParams(4, 4, &vpx_variance16x16_c),
814 VarianceParams(4, 3, &vpx_variance16x8_c),
815 VarianceParams(3, 4, &vpx_variance8x16_c),
816 VarianceParams(3, 3, &vpx_variance8x8_c),
817 VarianceParams(3, 2, &vpx_variance8x4_c),
818 VarianceParams(2, 3, &vpx_variance4x8_c),
819 VarianceParams(2, 2, &vpx_variance4x4_c)));
820
821 typedef TestParams<vpx_subpixvariance_fn_t> SubpelVarianceParams;
822 INSTANTIATE_TEST_SUITE_P(
823 C, VpxSubpelVarianceTest,
824 ::testing::Values(
825 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_c, 0),
826 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_c, 0),
827 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_c, 0),
828 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_c, 0),
829 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_c, 0),
830 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_c, 0),
831 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_c, 0),
832 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_c, 0),
833 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_c, 0),
834 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_c, 0),
835 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_c, 0),
836 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_c, 0),
837 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_c, 0)));
838
839 typedef TestParams<vpx_subp_avg_variance_fn_t> SubpelAvgVarianceParams;
840 INSTANTIATE_TEST_SUITE_P(
841 C, VpxSubpelAvgVarianceTest,
842 ::testing::Values(
843 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_c, 0),
844 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0),
845 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_c, 0),
846 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0),
847 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0),
848 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_c, 0),
849 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0),
850 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_c, 0),
851 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0),
852 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0),
853 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0),
854 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0),
855 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0)));
856
857 #if CONFIG_VP9_HIGHBITDEPTH
858 typedef MainTestClass<vpx_variance_fn_t> VpxHBDVarianceTest;
859 typedef SubpelVarianceTest<vpx_subpixvariance_fn_t> VpxHBDSubpelVarianceTest;
860 typedef SubpelVarianceTest<vpx_subp_avg_variance_fn_t>
861 VpxHBDSubpelAvgVarianceTest;
862
TEST_P(VpxHBDVarianceTest,Zero)863 TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); }
TEST_P(VpxHBDVarianceTest,Ref)864 TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); }
TEST_P(VpxHBDVarianceTest,RefStride)865 TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); }
TEST_P(VpxHBDVarianceTest,OneQuarter)866 TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
TEST_P(VpxHBDVarianceTest,DISABLED_Speed)867 TEST_P(VpxHBDVarianceTest, DISABLED_Speed) { SpeedTest(); }
TEST_P(VpxHBDSubpelVarianceTest,Ref)868 TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest(); }
TEST_P(VpxHBDSubpelVarianceTest,ExtremeRef)869 TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
TEST_P(VpxHBDSubpelAvgVarianceTest,Ref)870 TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
871
872 typedef MainTestClass<vpx_variance_fn_t> VpxHBDMseTest;
TEST_P(VpxHBDMseTest,RefMse)873 TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); }
TEST_P(VpxHBDMseTest,MaxMse)874 TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); }
TEST_P(VpxHBDMseTest,DISABLED_Speed)875 TEST_P(VpxHBDMseTest, DISABLED_Speed) { SpeedTest(); }
876 INSTANTIATE_TEST_SUITE_P(
877 C, VpxHBDMseTest,
878 ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_c, VPX_BITS_12),
879 MseParams(4, 3, &vpx_highbd_12_mse16x8_c, VPX_BITS_12),
880 MseParams(3, 4, &vpx_highbd_12_mse8x16_c, VPX_BITS_12),
881 MseParams(3, 3, &vpx_highbd_12_mse8x8_c, VPX_BITS_12),
882 MseParams(4, 4, &vpx_highbd_10_mse16x16_c, VPX_BITS_10),
883 MseParams(4, 3, &vpx_highbd_10_mse16x8_c, VPX_BITS_10),
884 MseParams(3, 4, &vpx_highbd_10_mse8x16_c, VPX_BITS_10),
885 MseParams(3, 3, &vpx_highbd_10_mse8x8_c, VPX_BITS_10),
886 MseParams(4, 4, &vpx_highbd_8_mse16x16_c, VPX_BITS_8),
887 MseParams(4, 3, &vpx_highbd_8_mse16x8_c, VPX_BITS_8),
888 MseParams(3, 4, &vpx_highbd_8_mse8x16_c, VPX_BITS_8),
889 MseParams(3, 3, &vpx_highbd_8_mse8x8_c, VPX_BITS_8)));
890
891 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VpxHBDMseTest);
892
893 INSTANTIATE_TEST_SUITE_P(
894 C, VpxHBDVarianceTest,
895 ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
896 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12),
897 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12),
898 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
899 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12),
900 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12),
901 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
902 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
903 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
904 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
905 VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
906 VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12),
907 VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12),
908 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
909 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
910 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10),
911 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10),
912 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
913 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10),
914 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
915 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
916 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10),
917 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
918 VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
919 VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
920 VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
921 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
922 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
923 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8),
924 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
925 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
926 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
927 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
928 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
929 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
930 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
931 VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
932 VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
933 VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)));
934
935 INSTANTIATE_TEST_SUITE_P(
936 C, VpxHBDSubpelVarianceTest,
937 ::testing::Values(
938 SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8),
939 SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8),
940 SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8),
941 SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8),
942 SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8),
943 SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8),
944 SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_c, 8),
945 SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8),
946 SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8),
947 SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8),
948 SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_c, 8),
949 SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8),
950 SubpelVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_c, 8),
951 SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_c,
952 10),
953 SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c,
954 10),
955 SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c,
956 10),
957 SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c,
958 10),
959 SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_c,
960 10),
961 SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_c,
962 10),
963 SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c,
964 10),
965 SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_c, 10),
966 SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10),
967 SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10),
968 SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10),
969 SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10),
970 SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10),
971 SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c,
972 12),
973 SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c,
974 12),
975 SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_c,
976 12),
977 SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c,
978 12),
979 SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c,
980 12),
981 SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c,
982 12),
983 SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c,
984 12),
985 SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12),
986 SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12),
987 SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12),
988 SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12),
989 SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12),
990 SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c,
991 12)));
992
993 INSTANTIATE_TEST_SUITE_P(
994 C, VpxHBDSubpelAvgVarianceTest,
995 ::testing::Values(
996 SubpelAvgVarianceParams(6, 6,
997 &vpx_highbd_8_sub_pixel_avg_variance64x64_c, 8),
998 SubpelAvgVarianceParams(6, 5,
999 &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8),
1000 SubpelAvgVarianceParams(5, 6,
1001 &vpx_highbd_8_sub_pixel_avg_variance32x64_c, 8),
1002 SubpelAvgVarianceParams(5, 5,
1003 &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8),
1004 SubpelAvgVarianceParams(5, 4,
1005 &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8),
1006 SubpelAvgVarianceParams(4, 5,
1007 &vpx_highbd_8_sub_pixel_avg_variance16x32_c, 8),
1008 SubpelAvgVarianceParams(4, 4,
1009 &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8),
1010 SubpelAvgVarianceParams(4, 3,
1011 &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8),
1012 SubpelAvgVarianceParams(3, 4,
1013 &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8),
1014 SubpelAvgVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c,
1015 8),
1016 SubpelAvgVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c,
1017 8),
1018 SubpelAvgVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c,
1019 8),
1020 SubpelAvgVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c,
1021 8),
1022 SubpelAvgVarianceParams(6, 6,
1023 &vpx_highbd_10_sub_pixel_avg_variance64x64_c,
1024 10),
1025 SubpelAvgVarianceParams(6, 5,
1026 &vpx_highbd_10_sub_pixel_avg_variance64x32_c,
1027 10),
1028 SubpelAvgVarianceParams(5, 6,
1029 &vpx_highbd_10_sub_pixel_avg_variance32x64_c,
1030 10),
1031 SubpelAvgVarianceParams(5, 5,
1032 &vpx_highbd_10_sub_pixel_avg_variance32x32_c,
1033 10),
1034 SubpelAvgVarianceParams(5, 4,
1035 &vpx_highbd_10_sub_pixel_avg_variance32x16_c,
1036 10),
1037 SubpelAvgVarianceParams(4, 5,
1038 &vpx_highbd_10_sub_pixel_avg_variance16x32_c,
1039 10),
1040 SubpelAvgVarianceParams(4, 4,
1041 &vpx_highbd_10_sub_pixel_avg_variance16x16_c,
1042 10),
1043 SubpelAvgVarianceParams(4, 3,
1044 &vpx_highbd_10_sub_pixel_avg_variance16x8_c,
1045 10),
1046 SubpelAvgVarianceParams(3, 4,
1047 &vpx_highbd_10_sub_pixel_avg_variance8x16_c,
1048 10),
1049 SubpelAvgVarianceParams(3, 3,
1050 &vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10),
1051 SubpelAvgVarianceParams(3, 2,
1052 &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10),
1053 SubpelAvgVarianceParams(2, 3,
1054 &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10),
1055 SubpelAvgVarianceParams(2, 2,
1056 &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10),
1057 SubpelAvgVarianceParams(6, 6,
1058 &vpx_highbd_12_sub_pixel_avg_variance64x64_c,
1059 12),
1060 SubpelAvgVarianceParams(6, 5,
1061 &vpx_highbd_12_sub_pixel_avg_variance64x32_c,
1062 12),
1063 SubpelAvgVarianceParams(5, 6,
1064 &vpx_highbd_12_sub_pixel_avg_variance32x64_c,
1065 12),
1066 SubpelAvgVarianceParams(5, 5,
1067 &vpx_highbd_12_sub_pixel_avg_variance32x32_c,
1068 12),
1069 SubpelAvgVarianceParams(5, 4,
1070 &vpx_highbd_12_sub_pixel_avg_variance32x16_c,
1071 12),
1072 SubpelAvgVarianceParams(4, 5,
1073 &vpx_highbd_12_sub_pixel_avg_variance16x32_c,
1074 12),
1075 SubpelAvgVarianceParams(4, 4,
1076 &vpx_highbd_12_sub_pixel_avg_variance16x16_c,
1077 12),
1078 SubpelAvgVarianceParams(4, 3,
1079 &vpx_highbd_12_sub_pixel_avg_variance16x8_c,
1080 12),
1081 SubpelAvgVarianceParams(3, 4,
1082 &vpx_highbd_12_sub_pixel_avg_variance8x16_c,
1083 12),
1084 SubpelAvgVarianceParams(3, 3,
1085 &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12),
1086 SubpelAvgVarianceParams(3, 2,
1087 &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12),
1088 SubpelAvgVarianceParams(2, 3,
1089 &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12),
1090 SubpelAvgVarianceParams(2, 2,
1091 &vpx_highbd_12_sub_pixel_avg_variance4x4_c,
1092 12)));
1093 #endif // CONFIG_VP9_HIGHBITDEPTH
1094
1095 #if HAVE_SSE2
1096 INSTANTIATE_TEST_SUITE_P(SSE2, SumOfSquaresTest,
1097 ::testing::Values(vpx_get_mb_ss_sse2));
1098
1099 INSTANTIATE_TEST_SUITE_P(SSE2, VpxMseTest,
1100 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2),
1101 MseParams(4, 3, &vpx_mse16x8_sse2),
1102 MseParams(3, 4, &vpx_mse8x16_sse2),
1103 MseParams(3, 3, &vpx_mse8x8_sse2)));
1104
1105 INSTANTIATE_TEST_SUITE_P(
1106 SSE2, VpxVarianceTest,
1107 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2),
1108 VarianceParams(6, 5, &vpx_variance64x32_sse2),
1109 VarianceParams(5, 6, &vpx_variance32x64_sse2),
1110 VarianceParams(5, 5, &vpx_variance32x32_sse2),
1111 VarianceParams(5, 4, &vpx_variance32x16_sse2),
1112 VarianceParams(4, 5, &vpx_variance16x32_sse2),
1113 VarianceParams(4, 4, &vpx_variance16x16_sse2),
1114 VarianceParams(4, 3, &vpx_variance16x8_sse2),
1115 VarianceParams(3, 4, &vpx_variance8x16_sse2),
1116 VarianceParams(3, 3, &vpx_variance8x8_sse2),
1117 VarianceParams(3, 2, &vpx_variance8x4_sse2),
1118 VarianceParams(2, 3, &vpx_variance4x8_sse2),
1119 VarianceParams(2, 2, &vpx_variance4x4_sse2)));
1120
1121 INSTANTIATE_TEST_SUITE_P(
1122 SSE2, VpxSubpelVarianceTest,
1123 ::testing::Values(
1124 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0),
1125 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0),
1126 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_sse2, 0),
1127 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0),
1128 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0),
1129 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0),
1130 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0),
1131 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0),
1132 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0),
1133 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0),
1134 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0),
1135 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0),
1136 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0)));
1137
1138 INSTANTIATE_TEST_SUITE_P(
1139 SSE2, VpxSubpelAvgVarianceTest,
1140 ::testing::Values(
1141 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0),
1142 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_sse2, 0),
1143 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0),
1144 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0),
1145 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0),
1146 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0),
1147 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0),
1148 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_sse2, 0),
1149 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0),
1150 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0),
1151 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_sse2, 0),
1152 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0),
1153 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0)));
1154
1155 #if CONFIG_VP9_HIGHBITDEPTH
1156 INSTANTIATE_TEST_SUITE_P(
1157 SSE2, VpxHBDMseTest,
1158 ::testing::Values(
1159 MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2, VPX_BITS_12),
1160 MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2, VPX_BITS_12),
1161 MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2, VPX_BITS_10),
1162 MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2, VPX_BITS_10),
1163 MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2, VPX_BITS_8),
1164 MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2, VPX_BITS_8)));
1165
1166 INSTANTIATE_TEST_SUITE_P(
1167 SSE2, VpxHBDVarianceTest,
1168 ::testing::Values(
1169 VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
1170 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
1171 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
1172 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
1173 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
1174 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
1175 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
1176 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
1177 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
1178 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
1179 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
1180 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
1181 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
1182 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
1183 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
1184 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
1185 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10),
1186 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
1187 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
1188 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10),
1189 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8),
1190 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8),
1191 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
1192 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
1193 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
1194 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
1195 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
1196 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
1197 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
1198 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));
1199
1200 INSTANTIATE_TEST_SUITE_P(
1201 SSE2, VpxHBDSubpelVarianceTest,
1202 ::testing::Values(
1203 SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2,
1204 12),
1205 SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2,
1206 12),
1207 SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2,
1208 12),
1209 SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2,
1210 12),
1211 SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2,
1212 12),
1213 SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2,
1214 12),
1215 SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2,
1216 12),
1217 SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2,
1218 12),
1219 SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2,
1220 12),
1221 SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2,
1222 12),
1223 SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2,
1224 12),
1225 SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2,
1226 10),
1227 SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2,
1228 10),
1229 SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2,
1230 10),
1231 SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2,
1232 10),
1233 SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_sse2,
1234 10),
1235 SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2,
1236 10),
1237 SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2,
1238 10),
1239 SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2,
1240 10),
1241 SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2,
1242 10),
1243 SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2,
1244 10),
1245 SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2,
1246 10),
1247 SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2,
1248 8),
1249 SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2,
1250 8),
1251 SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_sse2,
1252 8),
1253 SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2,
1254 8),
1255 SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse2,
1256 8),
1257 SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2,
1258 8),
1259 SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2,
1260 8),
1261 SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2,
1262 8),
1263 SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2,
1264 8),
1265 SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8),
1266 SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2,
1267 8)));
1268
1269 INSTANTIATE_TEST_SUITE_P(
1270 SSE2, VpxHBDSubpelAvgVarianceTest,
1271 ::testing::Values(
1272 SubpelAvgVarianceParams(6, 6,
1273 &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2,
1274 12),
1275 SubpelAvgVarianceParams(6, 5,
1276 &vpx_highbd_12_sub_pixel_avg_variance64x32_sse2,
1277 12),
1278 SubpelAvgVarianceParams(5, 6,
1279 &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2,
1280 12),
1281 SubpelAvgVarianceParams(5, 5,
1282 &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2,
1283 12),
1284 SubpelAvgVarianceParams(5, 4,
1285 &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2,
1286 12),
1287 SubpelAvgVarianceParams(4, 5,
1288 &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2,
1289 12),
1290 SubpelAvgVarianceParams(4, 4,
1291 &vpx_highbd_12_sub_pixel_avg_variance16x16_sse2,
1292 12),
1293 SubpelAvgVarianceParams(4, 3,
1294 &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2,
1295 12),
1296 SubpelAvgVarianceParams(3, 4,
1297 &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2,
1298 12),
1299 SubpelAvgVarianceParams(3, 3,
1300 &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2,
1301 12),
1302 SubpelAvgVarianceParams(3, 2,
1303 &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2,
1304 12),
1305 SubpelAvgVarianceParams(6, 6,
1306 &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2,
1307 10),
1308 SubpelAvgVarianceParams(6, 5,
1309 &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2,
1310 10),
1311 SubpelAvgVarianceParams(5, 6,
1312 &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2,
1313 10),
1314 SubpelAvgVarianceParams(5, 5,
1315 &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2,
1316 10),
1317 SubpelAvgVarianceParams(5, 4,
1318 &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2,
1319 10),
1320 SubpelAvgVarianceParams(4, 5,
1321 &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2,
1322 10),
1323 SubpelAvgVarianceParams(4, 4,
1324 &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2,
1325 10),
1326 SubpelAvgVarianceParams(4, 3,
1327 &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2,
1328 10),
1329 SubpelAvgVarianceParams(3, 4,
1330 &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2,
1331 10),
1332 SubpelAvgVarianceParams(3, 3,
1333 &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2,
1334 10),
1335 SubpelAvgVarianceParams(3, 2,
1336 &vpx_highbd_10_sub_pixel_avg_variance8x4_sse2,
1337 10),
1338 SubpelAvgVarianceParams(6, 6,
1339 &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2,
1340 8),
1341 SubpelAvgVarianceParams(6, 5,
1342 &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2,
1343 8),
1344 SubpelAvgVarianceParams(5, 6,
1345 &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2,
1346 8),
1347 SubpelAvgVarianceParams(5, 5,
1348 &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2,
1349 8),
1350 SubpelAvgVarianceParams(5, 4,
1351 &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2,
1352 8),
1353 SubpelAvgVarianceParams(4, 5,
1354 &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2,
1355 8),
1356 SubpelAvgVarianceParams(4, 4,
1357 &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2,
1358 8),
1359 SubpelAvgVarianceParams(4, 3,
1360 &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2,
1361 8),
1362 SubpelAvgVarianceParams(3, 4,
1363 &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2,
1364 8),
1365 SubpelAvgVarianceParams(3, 3,
1366 &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2,
1367 8),
1368 SubpelAvgVarianceParams(3, 2,
1369 &vpx_highbd_8_sub_pixel_avg_variance8x4_sse2,
1370 8)));
1371 #endif // CONFIG_VP9_HIGHBITDEPTH
1372 #endif // HAVE_SSE2
1373
1374 #if HAVE_SSSE3
1375 INSTANTIATE_TEST_SUITE_P(
1376 SSSE3, VpxSubpelVarianceTest,
1377 ::testing::Values(
1378 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0),
1379 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0),
1380 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0),
1381 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0),
1382 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0),
1383 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_ssse3, 0),
1384 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0),
1385 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0),
1386 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0),
1387 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_ssse3, 0),
1388 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0),
1389 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_ssse3, 0),
1390 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_ssse3, 0)));
1391
1392 INSTANTIATE_TEST_SUITE_P(
1393 SSSE3, VpxSubpelAvgVarianceTest,
1394 ::testing::Values(
1395 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3,
1396 0),
1397 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_ssse3,
1398 0),
1399 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3,
1400 0),
1401 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3,
1402 0),
1403 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3,
1404 0),
1405 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3,
1406 0),
1407 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3,
1408 0),
1409 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0),
1410 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0),
1411 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3, 0),
1412 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_ssse3, 0),
1413 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0),
1414 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3,
1415 0)));
1416 #endif // HAVE_SSSE3
1417
1418 #if HAVE_AVX2
1419 INSTANTIATE_TEST_SUITE_P(AVX2, VpxMseTest,
1420 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2),
1421 MseParams(4, 3, &vpx_mse16x8_avx2)));
1422
1423 INSTANTIATE_TEST_SUITE_P(
1424 AVX2, VpxVarianceTest,
1425 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2),
1426 VarianceParams(6, 5, &vpx_variance64x32_avx2),
1427 VarianceParams(5, 6, &vpx_variance32x64_avx2),
1428 VarianceParams(5, 5, &vpx_variance32x32_avx2),
1429 VarianceParams(5, 4, &vpx_variance32x16_avx2),
1430 VarianceParams(4, 5, &vpx_variance16x32_avx2),
1431 VarianceParams(4, 4, &vpx_variance16x16_avx2),
1432 VarianceParams(4, 3, &vpx_variance16x8_avx2),
1433 VarianceParams(3, 4, &vpx_variance8x16_avx2),
1434 VarianceParams(3, 3, &vpx_variance8x8_avx2),
1435 VarianceParams(3, 2, &vpx_variance8x4_avx2)));
1436
1437 INSTANTIATE_TEST_SUITE_P(
1438 AVX2, VpxSubpelVarianceTest,
1439 ::testing::Values(
1440 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0),
1441 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0)));
1442
1443 INSTANTIATE_TEST_SUITE_P(
1444 AVX2, VpxSubpelAvgVarianceTest,
1445 ::testing::Values(
1446 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0),
1447 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2,
1448 0)));
1449 #endif // HAVE_AVX2
1450
1451 #if HAVE_NEON
1452 INSTANTIATE_TEST_SUITE_P(NEON, VpxSseTest,
1453 ::testing::Values(SseParams(2, 2,
1454 &vpx_get4x4sse_cs_neon)));
1455
1456 INSTANTIATE_TEST_SUITE_P(NEON, VpxMseTest,
1457 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon),
1458 MseParams(4, 3, &vpx_mse16x8_neon),
1459 MseParams(3, 4, &vpx_mse8x16_neon),
1460 MseParams(3, 3, &vpx_mse8x8_neon)));
1461
1462 INSTANTIATE_TEST_SUITE_P(
1463 NEON, VpxVarianceTest,
1464 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon),
1465 VarianceParams(6, 5, &vpx_variance64x32_neon),
1466 VarianceParams(5, 6, &vpx_variance32x64_neon),
1467 VarianceParams(5, 5, &vpx_variance32x32_neon),
1468 VarianceParams(5, 4, &vpx_variance32x16_neon),
1469 VarianceParams(4, 5, &vpx_variance16x32_neon),
1470 VarianceParams(4, 4, &vpx_variance16x16_neon),
1471 VarianceParams(4, 3, &vpx_variance16x8_neon),
1472 VarianceParams(3, 4, &vpx_variance8x16_neon),
1473 VarianceParams(3, 3, &vpx_variance8x8_neon),
1474 VarianceParams(3, 2, &vpx_variance8x4_neon),
1475 VarianceParams(2, 3, &vpx_variance4x8_neon),
1476 VarianceParams(2, 2, &vpx_variance4x4_neon)));
1477
1478 #if HAVE_NEON_DOTPROD
1479 INSTANTIATE_TEST_SUITE_P(
1480 NEON_DOTPROD, VpxSseTest,
1481 ::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_neon_dotprod)));
1482
1483 INSTANTIATE_TEST_SUITE_P(
1484 NEON_DOTPROD, VpxMseTest,
1485 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon_dotprod),
1486 MseParams(4, 3, &vpx_mse16x8_neon_dotprod),
1487 MseParams(3, 4, &vpx_mse8x16_neon_dotprod),
1488 MseParams(3, 3, &vpx_mse8x8_neon_dotprod)));
1489
1490 INSTANTIATE_TEST_SUITE_P(
1491 NEON_DOTPROD, VpxVarianceTest,
1492 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon_dotprod),
1493 VarianceParams(6, 5, &vpx_variance64x32_neon_dotprod),
1494 VarianceParams(5, 6, &vpx_variance32x64_neon_dotprod),
1495 VarianceParams(5, 5, &vpx_variance32x32_neon_dotprod),
1496 VarianceParams(5, 4, &vpx_variance32x16_neon_dotprod),
1497 VarianceParams(4, 5, &vpx_variance16x32_neon_dotprod),
1498 VarianceParams(4, 4, &vpx_variance16x16_neon_dotprod),
1499 VarianceParams(4, 3, &vpx_variance16x8_neon_dotprod),
1500 VarianceParams(3, 4, &vpx_variance8x16_neon_dotprod),
1501 VarianceParams(3, 3, &vpx_variance8x8_neon_dotprod),
1502 VarianceParams(3, 2, &vpx_variance8x4_neon_dotprod),
1503 VarianceParams(2, 3, &vpx_variance4x8_neon_dotprod),
1504 VarianceParams(2, 2, &vpx_variance4x4_neon_dotprod)));
1505 #endif // HAVE_NEON_DOTPROD
1506
1507 INSTANTIATE_TEST_SUITE_P(
1508 NEON, VpxSubpelVarianceTest,
1509 ::testing::Values(
1510 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_neon, 0),
1511 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_neon, 0),
1512 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_neon, 0),
1513 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_neon, 0),
1514 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_neon, 0),
1515 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_neon, 0),
1516 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_neon, 0),
1517 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_neon, 0),
1518 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_neon, 0),
1519 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_neon, 0),
1520 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_neon, 0),
1521 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_neon, 0),
1522 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_neon, 0)));
1523
1524 INSTANTIATE_TEST_SUITE_P(
1525 NEON, VpxSubpelAvgVarianceTest,
1526 ::testing::Values(
1527 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_neon, 0),
1528 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_neon, 0),
1529 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_neon, 0),
1530 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_neon, 0),
1531 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_neon, 0),
1532 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_neon, 0),
1533 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_neon, 0),
1534 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_neon, 0),
1535 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_neon, 0),
1536 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_neon, 0),
1537 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_neon, 0),
1538 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_neon, 0),
1539 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_neon, 0)));
1540
1541 #if CONFIG_VP9_HIGHBITDEPTH
1542 INSTANTIATE_TEST_SUITE_P(
1543 NEON, VpxHBDMseTest,
1544 ::testing::Values(
1545 MseParams(4, 4, &vpx_highbd_12_mse16x16_neon, VPX_BITS_12),
1546 MseParams(4, 3, &vpx_highbd_12_mse16x8_neon, VPX_BITS_12),
1547 MseParams(3, 4, &vpx_highbd_12_mse8x16_neon, VPX_BITS_12),
1548 MseParams(3, 3, &vpx_highbd_12_mse8x8_neon, VPX_BITS_12),
1549 MseParams(4, 4, &vpx_highbd_10_mse16x16_neon, VPX_BITS_10),
1550 MseParams(4, 3, &vpx_highbd_10_mse16x8_neon, VPX_BITS_10),
1551 MseParams(3, 4, &vpx_highbd_10_mse8x16_neon, VPX_BITS_10),
1552 MseParams(3, 3, &vpx_highbd_10_mse8x8_neon, VPX_BITS_10),
1553 MseParams(4, 4, &vpx_highbd_8_mse16x16_neon, VPX_BITS_8),
1554 MseParams(4, 3, &vpx_highbd_8_mse16x8_neon, VPX_BITS_8),
1555 MseParams(3, 4, &vpx_highbd_8_mse8x16_neon, VPX_BITS_8),
1556 MseParams(3, 3, &vpx_highbd_8_mse8x8_neon, VPX_BITS_8)));
1557
1558 // TODO(webm:1819): Re-enable when vpx_highbd_8_mse16x16_neon_dotprod, etc. can
1559 // be used again.
1560 #if 0
1561 #if HAVE_NEON_DOTPROD
1562 INSTANTIATE_TEST_SUITE_P(
1563 NEON_DOTPROD, VpxHBDMseTest,
1564 ::testing::Values(
1565 MseParams(4, 4, &vpx_highbd_8_mse16x16_neon_dotprod, VPX_BITS_8),
1566 MseParams(4, 3, &vpx_highbd_8_mse16x8_neon_dotprod, VPX_BITS_8),
1567 MseParams(3, 4, &vpx_highbd_8_mse8x16_neon_dotprod, VPX_BITS_8),
1568 MseParams(3, 3, &vpx_highbd_8_mse8x8_neon_dotprod, VPX_BITS_8)));
1569 #endif // HAVE_NEON_DOTPROD
1570 #endif // 0
1571
1572 INSTANTIATE_TEST_SUITE_P(
1573 NEON, VpxHBDVarianceTest,
1574 ::testing::Values(
1575 VarianceParams(6, 6, &vpx_highbd_12_variance64x64_neon, 12),
1576 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_neon, 12),
1577 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_neon, 12),
1578 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_neon, 12),
1579 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_neon, 12),
1580 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_neon, 12),
1581 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_neon, 12),
1582 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_neon, 12),
1583 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_neon, 12),
1584 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_neon, 12),
1585 VarianceParams(3, 2, &vpx_highbd_12_variance8x4_neon, 12),
1586 VarianceParams(2, 3, &vpx_highbd_12_variance4x8_neon, 12),
1587 VarianceParams(2, 2, &vpx_highbd_12_variance4x4_neon, 12),
1588 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_neon, 10),
1589 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_neon, 10),
1590 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_neon, 10),
1591 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_neon, 10),
1592 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_neon, 10),
1593 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_neon, 10),
1594 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_neon, 10),
1595 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_neon, 10),
1596 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_neon, 10),
1597 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_neon, 10),
1598 VarianceParams(3, 2, &vpx_highbd_10_variance8x4_neon, 10),
1599 VarianceParams(2, 3, &vpx_highbd_10_variance4x8_neon, 10),
1600 VarianceParams(2, 2, &vpx_highbd_10_variance4x4_neon, 10),
1601 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_neon, 8),
1602 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_neon, 8),
1603 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_neon, 8),
1604 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_neon, 8),
1605 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_neon, 8),
1606 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_neon, 8),
1607 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_neon, 8),
1608 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_neon, 8),
1609 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_neon, 8),
1610 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_neon, 8),
1611 VarianceParams(3, 2, &vpx_highbd_8_variance8x4_neon, 8),
1612 VarianceParams(2, 3, &vpx_highbd_8_variance4x8_neon, 8),
1613 VarianceParams(2, 2, &vpx_highbd_8_variance4x4_neon, 8)));
1614
1615 INSTANTIATE_TEST_SUITE_P(
1616 NEON, VpxHBDSubpelVarianceTest,
1617 ::testing::Values(
1618 SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_neon,
1619 12),
1620 SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_neon,
1621 12),
1622 SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_neon,
1623 12),
1624 SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_neon,
1625 12),
1626 SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_neon,
1627 12),
1628 SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_neon,
1629 12),
1630 SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_neon,
1631 12),
1632 SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_neon,
1633 12),
1634 SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_neon,
1635 12),
1636 SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_neon,
1637 12),
1638 SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_neon,
1639 12),
1640 SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_neon,
1641 12),
1642 SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_neon,
1643 12),
1644 SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_neon,
1645 10),
1646 SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_neon,
1647 10),
1648 SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_neon,
1649 10),
1650 SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_neon,
1651 10),
1652 SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_neon,
1653 10),
1654 SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_neon,
1655 10),
1656 SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_neon,
1657 10),
1658 SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_neon,
1659 10),
1660 SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_neon,
1661 10),
1662 SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_neon,
1663 10),
1664 SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_neon,
1665 10),
1666 SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_neon,
1667 10),
1668 SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_neon,
1669 10),
1670 SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_neon,
1671 8),
1672 SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_neon,
1673 8),
1674 SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_neon,
1675 8),
1676 SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_neon,
1677 8),
1678 SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_neon,
1679 8),
1680 SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_neon,
1681 8),
1682 SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_neon,
1683 8),
1684 SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_neon,
1685 8),
1686 SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_neon,
1687 8),
1688 SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_neon, 8),
1689 SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_neon, 8),
1690 SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_neon, 8),
1691 SubpelVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_neon,
1692 8)));
1693
1694 INSTANTIATE_TEST_SUITE_P(
1695 NEON, VpxHBDSubpelAvgVarianceTest,
1696 ::testing::Values(
1697 SubpelAvgVarianceParams(6, 6,
1698 &vpx_highbd_12_sub_pixel_avg_variance64x64_neon,
1699 12),
1700 SubpelAvgVarianceParams(6, 5,
1701 &vpx_highbd_12_sub_pixel_avg_variance64x32_neon,
1702 12),
1703 SubpelAvgVarianceParams(5, 6,
1704 &vpx_highbd_12_sub_pixel_avg_variance32x64_neon,
1705 12),
1706 SubpelAvgVarianceParams(5, 5,
1707 &vpx_highbd_12_sub_pixel_avg_variance32x32_neon,
1708 12),
1709 SubpelAvgVarianceParams(5, 4,
1710 &vpx_highbd_12_sub_pixel_avg_variance32x16_neon,
1711 12),
1712 SubpelAvgVarianceParams(4, 5,
1713 &vpx_highbd_12_sub_pixel_avg_variance16x32_neon,
1714 12),
1715 SubpelAvgVarianceParams(4, 4,
1716 &vpx_highbd_12_sub_pixel_avg_variance16x16_neon,
1717 12),
1718 SubpelAvgVarianceParams(4, 3,
1719 &vpx_highbd_12_sub_pixel_avg_variance16x8_neon,
1720 12),
1721 SubpelAvgVarianceParams(3, 4,
1722 &vpx_highbd_12_sub_pixel_avg_variance8x16_neon,
1723 12),
1724 SubpelAvgVarianceParams(3, 3,
1725 &vpx_highbd_12_sub_pixel_avg_variance8x8_neon,
1726 12),
1727 SubpelAvgVarianceParams(3, 2,
1728 &vpx_highbd_12_sub_pixel_avg_variance8x4_neon,
1729 12),
1730 SubpelAvgVarianceParams(2, 3,
1731 &vpx_highbd_12_sub_pixel_avg_variance4x8_neon,
1732 12),
1733 SubpelAvgVarianceParams(2, 2,
1734 &vpx_highbd_12_sub_pixel_avg_variance4x4_neon,
1735 12),
1736 SubpelAvgVarianceParams(6, 6,
1737 &vpx_highbd_10_sub_pixel_avg_variance64x64_neon,
1738 10),
1739 SubpelAvgVarianceParams(6, 5,
1740 &vpx_highbd_10_sub_pixel_avg_variance64x32_neon,
1741 10),
1742 SubpelAvgVarianceParams(5, 6,
1743 &vpx_highbd_10_sub_pixel_avg_variance32x64_neon,
1744 10),
1745 SubpelAvgVarianceParams(5, 5,
1746 &vpx_highbd_10_sub_pixel_avg_variance32x32_neon,
1747 10),
1748 SubpelAvgVarianceParams(5, 4,
1749 &vpx_highbd_10_sub_pixel_avg_variance32x16_neon,
1750 10),
1751 SubpelAvgVarianceParams(4, 5,
1752 &vpx_highbd_10_sub_pixel_avg_variance16x32_neon,
1753 10),
1754 SubpelAvgVarianceParams(4, 4,
1755 &vpx_highbd_10_sub_pixel_avg_variance16x16_neon,
1756 10),
1757 SubpelAvgVarianceParams(4, 3,
1758 &vpx_highbd_10_sub_pixel_avg_variance16x8_neon,
1759 10),
1760 SubpelAvgVarianceParams(3, 4,
1761 &vpx_highbd_10_sub_pixel_avg_variance8x16_neon,
1762 10),
1763 SubpelAvgVarianceParams(3, 3,
1764 &vpx_highbd_10_sub_pixel_avg_variance8x8_neon,
1765 10),
1766 SubpelAvgVarianceParams(3, 2,
1767 &vpx_highbd_10_sub_pixel_avg_variance8x4_neon,
1768 10),
1769 SubpelAvgVarianceParams(2, 3,
1770 &vpx_highbd_10_sub_pixel_avg_variance4x8_neon,
1771 10),
1772 SubpelAvgVarianceParams(2, 2,
1773 &vpx_highbd_10_sub_pixel_avg_variance4x4_neon,
1774 10),
1775 SubpelAvgVarianceParams(6, 6,
1776 &vpx_highbd_8_sub_pixel_avg_variance64x64_neon,
1777 8),
1778 SubpelAvgVarianceParams(6, 5,
1779 &vpx_highbd_8_sub_pixel_avg_variance64x32_neon,
1780 8),
1781 SubpelAvgVarianceParams(5, 6,
1782 &vpx_highbd_8_sub_pixel_avg_variance32x64_neon,
1783 8),
1784 SubpelAvgVarianceParams(5, 5,
1785 &vpx_highbd_8_sub_pixel_avg_variance32x32_neon,
1786 8),
1787 SubpelAvgVarianceParams(5, 4,
1788 &vpx_highbd_8_sub_pixel_avg_variance32x16_neon,
1789 8),
1790 SubpelAvgVarianceParams(4, 5,
1791 &vpx_highbd_8_sub_pixel_avg_variance16x32_neon,
1792 8),
1793 SubpelAvgVarianceParams(4, 4,
1794 &vpx_highbd_8_sub_pixel_avg_variance16x16_neon,
1795 8),
1796 SubpelAvgVarianceParams(4, 3,
1797 &vpx_highbd_8_sub_pixel_avg_variance16x8_neon,
1798 8),
1799 SubpelAvgVarianceParams(3, 4,
1800 &vpx_highbd_8_sub_pixel_avg_variance8x16_neon,
1801 8),
1802 SubpelAvgVarianceParams(3, 3,
1803 &vpx_highbd_8_sub_pixel_avg_variance8x8_neon,
1804 8),
1805 SubpelAvgVarianceParams(3, 2,
1806 &vpx_highbd_8_sub_pixel_avg_variance8x4_neon,
1807 8),
1808 SubpelAvgVarianceParams(2, 3,
1809 &vpx_highbd_8_sub_pixel_avg_variance4x8_neon,
1810 8),
1811 SubpelAvgVarianceParams(2, 2,
1812 &vpx_highbd_8_sub_pixel_avg_variance4x4_neon,
1813 8)));
1814
1815 #endif // CONFIG_VP9_HIGHBITDEPTH
1816 #endif // HAVE_NEON
1817
1818 #if HAVE_MSA
1819 INSTANTIATE_TEST_SUITE_P(MSA, SumOfSquaresTest,
1820 ::testing::Values(vpx_get_mb_ss_msa));
1821
1822 INSTANTIATE_TEST_SUITE_P(MSA, VpxSseTest,
1823 ::testing::Values(SseParams(2, 2,
1824 &vpx_get4x4sse_cs_msa)));
1825
1826 INSTANTIATE_TEST_SUITE_P(MSA, VpxMseTest,
1827 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa),
1828 MseParams(4, 3, &vpx_mse16x8_msa),
1829 MseParams(3, 4, &vpx_mse8x16_msa),
1830 MseParams(3, 3, &vpx_mse8x8_msa)));
1831
1832 INSTANTIATE_TEST_SUITE_P(
1833 MSA, VpxVarianceTest,
1834 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa),
1835 VarianceParams(6, 5, &vpx_variance64x32_msa),
1836 VarianceParams(5, 6, &vpx_variance32x64_msa),
1837 VarianceParams(5, 5, &vpx_variance32x32_msa),
1838 VarianceParams(5, 4, &vpx_variance32x16_msa),
1839 VarianceParams(4, 5, &vpx_variance16x32_msa),
1840 VarianceParams(4, 4, &vpx_variance16x16_msa),
1841 VarianceParams(4, 3, &vpx_variance16x8_msa),
1842 VarianceParams(3, 4, &vpx_variance8x16_msa),
1843 VarianceParams(3, 3, &vpx_variance8x8_msa),
1844 VarianceParams(3, 2, &vpx_variance8x4_msa),
1845 VarianceParams(2, 3, &vpx_variance4x8_msa),
1846 VarianceParams(2, 2, &vpx_variance4x4_msa)));
1847
1848 INSTANTIATE_TEST_SUITE_P(
1849 MSA, VpxSubpelVarianceTest,
1850 ::testing::Values(
1851 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_msa, 0),
1852 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_msa, 0),
1853 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_msa, 0),
1854 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_msa, 0),
1855 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_msa, 0),
1856 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_msa, 0),
1857 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_msa, 0),
1858 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_msa, 0),
1859 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_msa, 0),
1860 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_msa, 0),
1861 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_msa, 0),
1862 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_msa, 0),
1863 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_msa, 0)));
1864
1865 INSTANTIATE_TEST_SUITE_P(
1866 MSA, VpxSubpelAvgVarianceTest,
1867 ::testing::Values(
1868 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0),
1869 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0),
1870 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0),
1871 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0),
1872 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0),
1873 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0),
1874 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0),
1875 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0),
1876 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0),
1877 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0),
1878 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0),
1879 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0),
1880 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0)));
1881 #endif // HAVE_MSA
1882
1883 #if HAVE_VSX
1884 INSTANTIATE_TEST_SUITE_P(VSX, SumOfSquaresTest,
1885 ::testing::Values(vpx_get_mb_ss_vsx));
1886
1887 INSTANTIATE_TEST_SUITE_P(VSX, VpxSseTest,
1888 ::testing::Values(SseParams(2, 2,
1889 &vpx_get4x4sse_cs_vsx)));
1890 INSTANTIATE_TEST_SUITE_P(VSX, VpxMseTest,
1891 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_vsx),
1892 MseParams(4, 3, &vpx_mse16x8_vsx),
1893 MseParams(3, 4, &vpx_mse8x16_vsx),
1894 MseParams(3, 3, &vpx_mse8x8_vsx)));
1895
1896 INSTANTIATE_TEST_SUITE_P(
1897 VSX, VpxVarianceTest,
1898 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_vsx),
1899 VarianceParams(6, 5, &vpx_variance64x32_vsx),
1900 VarianceParams(5, 6, &vpx_variance32x64_vsx),
1901 VarianceParams(5, 5, &vpx_variance32x32_vsx),
1902 VarianceParams(5, 4, &vpx_variance32x16_vsx),
1903 VarianceParams(4, 5, &vpx_variance16x32_vsx),
1904 VarianceParams(4, 4, &vpx_variance16x16_vsx),
1905 VarianceParams(4, 3, &vpx_variance16x8_vsx),
1906 VarianceParams(3, 4, &vpx_variance8x16_vsx),
1907 VarianceParams(3, 3, &vpx_variance8x8_vsx),
1908 VarianceParams(3, 2, &vpx_variance8x4_vsx),
1909 VarianceParams(2, 3, &vpx_variance4x8_vsx),
1910 VarianceParams(2, 2, &vpx_variance4x4_vsx)));
1911 #endif // HAVE_VSX
1912
1913 #if HAVE_MMI
1914 INSTANTIATE_TEST_SUITE_P(MMI, VpxMseTest,
1915 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_mmi),
1916 MseParams(4, 3, &vpx_mse16x8_mmi),
1917 MseParams(3, 4, &vpx_mse8x16_mmi),
1918 MseParams(3, 3, &vpx_mse8x8_mmi)));
1919
1920 INSTANTIATE_TEST_SUITE_P(
1921 MMI, VpxVarianceTest,
1922 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_mmi),
1923 VarianceParams(6, 5, &vpx_variance64x32_mmi),
1924 VarianceParams(5, 6, &vpx_variance32x64_mmi),
1925 VarianceParams(5, 5, &vpx_variance32x32_mmi),
1926 VarianceParams(5, 4, &vpx_variance32x16_mmi),
1927 VarianceParams(4, 5, &vpx_variance16x32_mmi),
1928 VarianceParams(4, 4, &vpx_variance16x16_mmi),
1929 VarianceParams(4, 3, &vpx_variance16x8_mmi),
1930 VarianceParams(3, 4, &vpx_variance8x16_mmi),
1931 VarianceParams(3, 3, &vpx_variance8x8_mmi),
1932 VarianceParams(3, 2, &vpx_variance8x4_mmi),
1933 VarianceParams(2, 3, &vpx_variance4x8_mmi),
1934 VarianceParams(2, 2, &vpx_variance4x4_mmi)));
1935
1936 INSTANTIATE_TEST_SUITE_P(
1937 MMI, VpxSubpelVarianceTest,
1938 ::testing::Values(
1939 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_mmi, 0),
1940 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_mmi, 0),
1941 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_mmi, 0),
1942 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_mmi, 0),
1943 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_mmi, 0),
1944 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_mmi, 0),
1945 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_mmi, 0),
1946 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_mmi, 0),
1947 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_mmi, 0),
1948 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_mmi, 0),
1949 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_mmi, 0),
1950 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_mmi, 0),
1951 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_mmi, 0)));
1952
1953 INSTANTIATE_TEST_SUITE_P(
1954 MMI, VpxSubpelAvgVarianceTest,
1955 ::testing::Values(
1956 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_mmi, 0),
1957 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_mmi, 0),
1958 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_mmi, 0),
1959 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_mmi, 0),
1960 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_mmi, 0),
1961 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_mmi, 0),
1962 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_mmi, 0),
1963 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_mmi, 0),
1964 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_mmi, 0),
1965 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_mmi, 0),
1966 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_mmi, 0),
1967 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_mmi, 0),
1968 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_mmi, 0)));
1969 #endif // HAVE_MMI
1970
1971 #if HAVE_LSX
1972 INSTANTIATE_TEST_SUITE_P(LSX, VpxMseTest,
1973 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_lsx)));
1974
1975 INSTANTIATE_TEST_SUITE_P(
1976 LSX, VpxVarianceTest,
1977 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_lsx),
1978 VarianceParams(5, 5, &vpx_variance32x32_lsx),
1979 VarianceParams(4, 4, &vpx_variance16x16_lsx),
1980 VarianceParams(3, 3, &vpx_variance8x8_lsx)));
1981
1982 INSTANTIATE_TEST_SUITE_P(
1983 LSX, VpxSubpelVarianceTest,
1984 ::testing::Values(
1985 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_lsx, 0),
1986 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_lsx, 0),
1987 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_lsx, 0)));
1988
1989 INSTANTIATE_TEST_SUITE_P(LSX, VpxSubpelAvgVarianceTest,
1990 ::testing::Values(SubpelAvgVarianceParams(
1991 6, 6, &vpx_sub_pixel_avg_variance64x64_lsx, 0)));
1992 #endif
1993 } // namespace
1994