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