1 /*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #include <math.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include "gtest/gtest.h"
17 #include "test/register_state_check.h"
18 #include "test/function_equivalence_test.h"
19
20 #include "config/aom_config.h"
21 #include "config/aom_dsp_rtcd.h"
22 #include "config/av1_rtcd.h"
23
24 #include "aom/aom_integer.h"
25
26 #include "av1/common/enums.h"
27
28 #include "aom_dsp/blend.h"
29
30 using libaom_test::FunctionEquivalenceTest;
31
32 namespace {
33
34 template <typename F, typename T>
35 class BlendA64Mask1DTest : public FunctionEquivalenceTest<F> {
36 public:
37 static const int kIterations = 10000;
38 static const int kMaxWidth = MAX_SB_SIZE * 5; // * 5 to cover longer strides
39 static const int kMaxHeight = MAX_SB_SIZE;
40 static const int kBufSize = kMaxWidth * kMaxHeight;
41 static const int kMaxMaskWidth = 2 * MAX_SB_SIZE;
42 static const int kMaxMaskSize = kMaxMaskWidth;
43
44 ~BlendA64Mask1DTest() override = default;
45
46 virtual void Execute(const T *p_src0, const T *p_src1) = 0;
47
Common(int block_size)48 void Common(int block_size) {
49 w_ = block_size_wide[block_size];
50 h_ = block_size_high[block_size];
51
52 dst_offset_ = this->rng_(33);
53 dst_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
54
55 src0_offset_ = this->rng_(33);
56 src0_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
57
58 src1_offset_ = this->rng_(33);
59 src1_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
60
61 T *p_src0;
62 T *p_src1;
63
64 switch (this->rng_(3)) {
65 case 0: // Separate sources
66 p_src0 = src0_;
67 p_src1 = src1_;
68 break;
69 case 1: // src0 == dst
70 p_src0 = dst_tst_;
71 src0_stride_ = dst_stride_;
72 src0_offset_ = dst_offset_;
73 p_src1 = src1_;
74 break;
75 case 2: // src1 == dst
76 p_src0 = src0_;
77 p_src1 = dst_tst_;
78 src1_stride_ = dst_stride_;
79 src1_offset_ = dst_offset_;
80 break;
81 default: FAIL();
82 }
83
84 Execute(p_src0, p_src1);
85
86 for (int r = 0; r < h_; ++r) {
87 for (int c = 0; c < w_; ++c) {
88 ASSERT_EQ(dst_ref_[dst_offset_ + r * dst_stride_ + c],
89 dst_tst_[dst_offset_ + r * dst_stride_ + c]);
90 }
91 }
92 }
93
94 T dst_ref_[kBufSize];
95 T dst_tst_[kBufSize];
96 uint32_t dst_stride_;
97 uint32_t dst_offset_;
98
99 T src0_[kBufSize];
100 uint32_t src0_stride_;
101 uint32_t src0_offset_;
102
103 T src1_[kBufSize];
104 uint32_t src1_stride_;
105 uint32_t src1_offset_;
106
107 uint8_t mask_[kMaxMaskSize];
108
109 int w_;
110 int h_;
111 };
112
113 //////////////////////////////////////////////////////////////////////////////
114 // 8 bit version
115 //////////////////////////////////////////////////////////////////////////////
116
117 typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
118 uint32_t src0_stride, const uint8_t *src1,
119 uint32_t src1_stride, const uint8_t *mask, int w, int h);
120 typedef libaom_test::FuncParam<F8B> TestFuncs;
121
122 class BlendA64Mask1DTest8B : public BlendA64Mask1DTest<F8B, uint8_t> {
123 protected:
Execute(const uint8_t * p_src0,const uint8_t * p_src1)124 void Execute(const uint8_t *p_src0, const uint8_t *p_src1) override {
125 params_.ref_func(dst_ref_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
126 src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_,
127 w_, h_);
128 API_REGISTER_STATE_CHECK(params_.tst_func(
129 dst_tst_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
130 src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_, w_, h_));
131 }
132 };
133
TEST_P(BlendA64Mask1DTest8B,RandomValues)134 TEST_P(BlendA64Mask1DTest8B, RandomValues) {
135 for (int bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) {
136 for (int i = 0; i < kBufSize; ++i) {
137 dst_ref_[i] = rng_.Rand8();
138 dst_tst_[i] = rng_.Rand8();
139
140 src0_[i] = rng_.Rand8();
141 src1_[i] = rng_.Rand8();
142 }
143
144 for (int i = 0; i < kMaxMaskSize; ++i)
145 mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
146
147 Common(bsize);
148 }
149 }
150
TEST_P(BlendA64Mask1DTest8B,ExtremeValues)151 TEST_P(BlendA64Mask1DTest8B, ExtremeValues) {
152 for (int i = 0; i < kBufSize; ++i) {
153 dst_ref_[i] = rng_(2) + 254;
154 dst_tst_[i] = rng_(2) + 254;
155 src0_[i] = rng_(2) + 254;
156 src1_[i] = rng_(2) + 254;
157 }
158
159 for (int i = 0; i < kMaxMaskSize; ++i)
160 mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
161
162 for (int bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) {
163 Common(bsize);
164 }
165 }
166
blend_a64_hmask_ref(uint8_t * dst,uint32_t dst_stride,const uint8_t * src0,uint32_t src0_stride,const uint8_t * src1,uint32_t src1_stride,const uint8_t * mask,int w,int h)167 static void blend_a64_hmask_ref(uint8_t *dst, uint32_t dst_stride,
168 const uint8_t *src0, uint32_t src0_stride,
169 const uint8_t *src1, uint32_t src1_stride,
170 const uint8_t *mask, int w, int h) {
171 uint8_t mask2d[BlendA64Mask1DTest8B::kMaxMaskSize]
172 [BlendA64Mask1DTest8B::kMaxMaskSize];
173
174 for (int row = 0; row < h; ++row)
175 for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
176
177 aom_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
178 &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, w, h,
179 0, 0);
180 }
181
blend_a64_vmask_ref(uint8_t * dst,uint32_t dst_stride,const uint8_t * src0,uint32_t src0_stride,const uint8_t * src1,uint32_t src1_stride,const uint8_t * mask,int w,int h)182 static void blend_a64_vmask_ref(uint8_t *dst, uint32_t dst_stride,
183 const uint8_t *src0, uint32_t src0_stride,
184 const uint8_t *src1, uint32_t src1_stride,
185 const uint8_t *mask, int w, int h) {
186 uint8_t mask2d[BlendA64Mask1DTest8B::kMaxMaskSize]
187 [BlendA64Mask1DTest8B::kMaxMaskSize];
188
189 for (int row = 0; row < h; ++row)
190 for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
191
192 aom_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
193 &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, w, h,
194 0, 0);
195 }
196
197 INSTANTIATE_TEST_SUITE_P(
198 C, BlendA64Mask1DTest8B,
199 ::testing::Values(TestFuncs(blend_a64_hmask_ref, aom_blend_a64_hmask_c),
200 TestFuncs(blend_a64_vmask_ref, aom_blend_a64_vmask_c)));
201
202 #if HAVE_SSE4_1
203 INSTANTIATE_TEST_SUITE_P(
204 SSE4_1, BlendA64Mask1DTest8B,
205 ::testing::Values(
206 TestFuncs(blend_a64_hmask_ref, aom_blend_a64_hmask_sse4_1),
207 TestFuncs(blend_a64_vmask_ref, aom_blend_a64_vmask_sse4_1)));
208 #endif // HAVE_SSE4_1
209
210 #if HAVE_NEON
211 INSTANTIATE_TEST_SUITE_P(
212 NEON, BlendA64Mask1DTest8B,
213 ::testing::Values(TestFuncs(blend_a64_hmask_ref, aom_blend_a64_hmask_neon),
214 TestFuncs(blend_a64_vmask_ref,
215 aom_blend_a64_vmask_neon)));
216 #endif // HAVE_NEON
217
218 //////////////////////////////////////////////////////////////////////////////
219 // High bit-depth version
220 //////////////////////////////////////////////////////////////////////////////
221 #if CONFIG_AV1_HIGHBITDEPTH
222 typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
223 uint32_t src0_stride, const uint8_t *src1,
224 uint32_t src1_stride, const uint8_t *mask, int w, int h,
225 int bd);
226 typedef libaom_test::FuncParam<FHBD> TestFuncsHBD;
227
228 class BlendA64Mask1DTestHBD : public BlendA64Mask1DTest<FHBD, uint16_t> {
229 protected:
Execute(const uint16_t * p_src0,const uint16_t * p_src1)230 void Execute(const uint16_t *p_src0, const uint16_t *p_src1) override {
231 params_.ref_func(CONVERT_TO_BYTEPTR(dst_ref_ + dst_offset_), dst_stride_,
232 CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
233 CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
234 mask_, w_, h_, bit_depth_);
235 API_REGISTER_STATE_CHECK(params_.tst_func(
236 CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
237 CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
238 CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_, mask_, w_, h_,
239 bit_depth_));
240 }
241
242 int bit_depth_;
243 };
244
TEST_P(BlendA64Mask1DTestHBD,RandomValues)245 TEST_P(BlendA64Mask1DTestHBD, RandomValues) {
246 for (bit_depth_ = 8; bit_depth_ <= 12; bit_depth_ += 2) {
247 for (int bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) {
248 const int hi = 1 << bit_depth_;
249
250 for (int i = 0; i < kBufSize; ++i) {
251 dst_ref_[i] = rng_(hi);
252 dst_tst_[i] = rng_(hi);
253 src0_[i] = rng_(hi);
254 src1_[i] = rng_(hi);
255 }
256
257 for (int i = 0; i < kMaxMaskSize; ++i)
258 mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
259
260 Common(bsize);
261 }
262 }
263 }
264
TEST_P(BlendA64Mask1DTestHBD,ExtremeValues)265 TEST_P(BlendA64Mask1DTestHBD, ExtremeValues) {
266 for (bit_depth_ = 8; bit_depth_ <= 12; bit_depth_ += 2) {
267 const int hi = 1 << bit_depth_;
268 const int lo = hi - 2;
269
270 for (int i = 0; i < kBufSize; ++i) {
271 dst_ref_[i] = rng_(hi - lo) + lo;
272 dst_tst_[i] = rng_(hi - lo) + lo;
273 src0_[i] = rng_(hi - lo) + lo;
274 src1_[i] = rng_(hi - lo) + lo;
275 }
276
277 for (int i = 0; i < kMaxMaskSize; ++i)
278 mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
279
280 for (int bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) {
281 Common(bsize);
282 }
283 }
284 }
285
highbd_blend_a64_hmask_ref(uint8_t * dst,uint32_t dst_stride,const uint8_t * src0,uint32_t src0_stride,const uint8_t * src1,uint32_t src1_stride,const uint8_t * mask,int w,int h,int bd)286 static void highbd_blend_a64_hmask_ref(
287 uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
288 uint32_t src0_stride, const uint8_t *src1, uint32_t src1_stride,
289 const uint8_t *mask, int w, int h, int bd) {
290 uint8_t mask2d[BlendA64Mask1DTestHBD::kMaxMaskSize]
291 [BlendA64Mask1DTestHBD::kMaxMaskSize];
292
293 for (int row = 0; row < h; ++row)
294 for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
295
296 aom_highbd_blend_a64_mask_c(
297 dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
298 BlendA64Mask1DTestHBD::kMaxMaskSize, w, h, 0, 0, bd);
299 }
300
highbd_blend_a64_vmask_ref(uint8_t * dst,uint32_t dst_stride,const uint8_t * src0,uint32_t src0_stride,const uint8_t * src1,uint32_t src1_stride,const uint8_t * mask,int w,int h,int bd)301 static void highbd_blend_a64_vmask_ref(
302 uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
303 uint32_t src0_stride, const uint8_t *src1, uint32_t src1_stride,
304 const uint8_t *mask, int w, int h, int bd) {
305 uint8_t mask2d[BlendA64Mask1DTestHBD::kMaxMaskSize]
306 [BlendA64Mask1DTestHBD::kMaxMaskSize];
307
308 for (int row = 0; row < h; ++row)
309 for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
310
311 aom_highbd_blend_a64_mask_c(
312 dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
313 BlendA64Mask1DTestHBD::kMaxMaskSize, w, h, 0, 0, bd);
314 }
315
316 INSTANTIATE_TEST_SUITE_P(
317 C, BlendA64Mask1DTestHBD,
318 ::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
319 aom_highbd_blend_a64_hmask_c),
320 TestFuncsHBD(highbd_blend_a64_vmask_ref,
321 aom_highbd_blend_a64_vmask_c)));
322
323 #if HAVE_SSE4_1
324 INSTANTIATE_TEST_SUITE_P(
325 SSE4_1, BlendA64Mask1DTestHBD,
326 ::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
327 aom_highbd_blend_a64_hmask_sse4_1),
328 TestFuncsHBD(highbd_blend_a64_vmask_ref,
329 aom_highbd_blend_a64_vmask_sse4_1)));
330 #endif // HAVE_SSE4_1
331
332 #if HAVE_NEON
333 INSTANTIATE_TEST_SUITE_P(
334 NEON, BlendA64Mask1DTestHBD,
335 ::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
336 aom_highbd_blend_a64_hmask_neon),
337 TestFuncsHBD(highbd_blend_a64_vmask_ref,
338 aom_highbd_blend_a64_vmask_neon)));
339 #endif // HAVE_NEON
340
341 #endif // CONFIG_AV1_HIGHBITDEPTH
342 } // namespace
343