1 /*
2 * Copyright © 2019, VideoLAN and dav1d authors
3 * Copyright © 2019, Two Orioles, LLC
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright notice, this
10 * list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "tests/checkasm/checkasm.h"
29
30 #include <string.h>
31
32 #include "src/levels.h"
33 #include "src/filmgrain.h"
34 #define UNIT_TEST 1
35 #include "src/fg_apply_tmpl.c"
36
37 #if BITDEPTH == 8
38 #define checkasm_check_entry(...) checkasm_check(int8_t, __VA_ARGS__)
39 #else
40 #define checkasm_check_entry(...) checkasm_check(int16_t, __VA_ARGS__)
41 #endif
42
43 static const char ss_name[][4] = {
44 [DAV1D_PIXEL_LAYOUT_I420 - 1] = "420",
45 [DAV1D_PIXEL_LAYOUT_I422 - 1] = "422",
46 [DAV1D_PIXEL_LAYOUT_I444 - 1] = "444",
47 };
48
check_gen_grny(const Dav1dFilmGrainDSPContext * const dsp)49 static void check_gen_grny(const Dav1dFilmGrainDSPContext *const dsp) {
50 ALIGN_STK_16(entry, grain_lut_c, GRAIN_HEIGHT,[GRAIN_WIDTH]);
51 ALIGN_STK_16(entry, grain_lut_a, GRAIN_HEIGHT + 1,[GRAIN_WIDTH]);
52
53 declare_func(void, entry grain_lut[][GRAIN_WIDTH],
54 const Dav1dFilmGrainData *data HIGHBD_DECL_SUFFIX);
55
56 for (int i = 0; i < 4; i++) {
57 if (check_func(dsp->generate_grain_y, "gen_grain_y_ar%d_%dbpc", i, BITDEPTH)) {
58 ALIGN_STK_16(Dav1dFilmGrainData, fg_data, 1,);
59 fg_data[0].seed = rnd() & 0xFFFF;
60
61 #if BITDEPTH == 16
62 const int bitdepth_max = rnd() & 1 ? 0x3ff : 0xfff;
63 #endif
64
65 fg_data[0].grain_scale_shift = rnd() & 3;
66 fg_data[0].ar_coeff_shift = (rnd() & 3) + 6;
67 fg_data[0].ar_coeff_lag = i;
68 const int num_y_pos = 2 * fg_data[0].ar_coeff_lag * (fg_data[0].ar_coeff_lag + 1);
69 for (int n = 0; n < num_y_pos; n++)
70 fg_data[0].ar_coeffs_y[n] = (rnd() & 0xff) - 128;
71
72 call_ref(grain_lut_c, fg_data HIGHBD_TAIL_SUFFIX);
73 call_new(grain_lut_a, fg_data HIGHBD_TAIL_SUFFIX);
74 checkasm_check_entry(grain_lut_c[0], sizeof(entry) * GRAIN_WIDTH,
75 grain_lut_a[0], sizeof(entry) * GRAIN_WIDTH,
76 GRAIN_WIDTH, GRAIN_HEIGHT, "grain_lut");
77
78 bench_new(grain_lut_a, fg_data HIGHBD_TAIL_SUFFIX);
79 }
80 }
81
82 report("gen_grain_y");
83 }
84
check_gen_grnuv(const Dav1dFilmGrainDSPContext * const dsp)85 static void check_gen_grnuv(const Dav1dFilmGrainDSPContext *const dsp) {
86 ALIGN_STK_16(entry, grain_lut_y, GRAIN_HEIGHT + 1,[GRAIN_WIDTH]);
87 ALIGN_STK_16(entry, grain_lut_c, GRAIN_HEIGHT, [GRAIN_WIDTH]);
88 ALIGN_STK_16(entry, grain_lut_a, GRAIN_HEIGHT + 1,[GRAIN_WIDTH]);
89
90 declare_func(void, entry grain_lut[][GRAIN_WIDTH],
91 const entry grain_lut_y[][GRAIN_WIDTH],
92 const Dav1dFilmGrainData *data, intptr_t uv HIGHBD_DECL_SUFFIX);
93
94 for (int layout_idx = 0; layout_idx < 3; layout_idx++) {
95 const enum Dav1dPixelLayout layout = layout_idx + 1;
96 const int ss_x = layout != DAV1D_PIXEL_LAYOUT_I444;
97 const int ss_y = layout == DAV1D_PIXEL_LAYOUT_I420;
98
99 for (int i = 0; i < 4; i++) {
100 if (check_func(dsp->generate_grain_uv[layout_idx],
101 "gen_grain_uv_ar%d_%dbpc_%s",
102 i, BITDEPTH, ss_name[layout_idx]))
103 {
104 ALIGN_STK_16(Dav1dFilmGrainData, fg_data, 1,);
105 fg_data[0].seed = rnd() & 0xFFFF;
106
107 #if BITDEPTH == 16
108 const int bitdepth_max = rnd() & 1 ? 0x3ff : 0xfff;
109 #endif
110
111 fg_data[0].num_y_points = rnd() & 1;
112 fg_data[0].grain_scale_shift = rnd() & 3;
113 fg_data[0].ar_coeff_shift = (rnd() & 3) + 6;
114 fg_data[0].ar_coeff_lag = i;
115 const int num_y_pos = 2 * fg_data[0].ar_coeff_lag * (fg_data[0].ar_coeff_lag + 1);
116 for (int n = 0; n < num_y_pos; n++)
117 fg_data[0].ar_coeffs_y[n] = (rnd() & 0xff) - 128;
118 dsp->generate_grain_y(grain_lut_y, fg_data HIGHBD_TAIL_SUFFIX);
119
120 const int uv = rnd() & 1;
121 const int num_uv_pos = num_y_pos + !!fg_data[0].num_y_points;
122 for (int n = 0; n < num_uv_pos; n++)
123 fg_data[0].ar_coeffs_uv[uv][n] = (rnd() & 0xff) - 128;
124 if (!fg_data[0].num_y_points)
125 fg_data[0].ar_coeffs_uv[uv][num_uv_pos] = 0;
126 memset(grain_lut_c, 0xff, sizeof(grain_lut_c));
127 memset(grain_lut_a, 0xff, sizeof(grain_lut_a));
128 call_ref(grain_lut_c, grain_lut_y, fg_data, uv HIGHBD_TAIL_SUFFIX);
129 call_new(grain_lut_a, grain_lut_y, fg_data, uv HIGHBD_TAIL_SUFFIX);
130 int w = ss_x ? 44 : GRAIN_WIDTH;
131 int h = ss_y ? 38 : GRAIN_HEIGHT;
132 checkasm_check_entry(grain_lut_c[0], sizeof(entry) * GRAIN_WIDTH,
133 grain_lut_a[0], sizeof(entry) * GRAIN_WIDTH,
134 w, h, "grain_lut");
135
136 bench_new(grain_lut_a, grain_lut_y, fg_data, uv HIGHBD_TAIL_SUFFIX);
137 }
138 }
139 }
140
141 report("gen_grain_uv");
142 }
143
check_fgy_sbrow(const Dav1dFilmGrainDSPContext * const dsp)144 static void check_fgy_sbrow(const Dav1dFilmGrainDSPContext *const dsp) {
145 PIXEL_RECT(c_dst, 128, 32);
146 PIXEL_RECT(a_dst, 128, 32);
147 PIXEL_RECT(src, 128, 32);
148 const ptrdiff_t stride = c_dst_stride;
149
150 declare_func(void, pixel *dst_row, const pixel *src_row, ptrdiff_t stride,
151 const Dav1dFilmGrainData *data, size_t pw,
152 const uint8_t scaling[SCALING_SIZE],
153 const entry grain_lut[][GRAIN_WIDTH],
154 int bh, int row_num HIGHBD_DECL_SUFFIX);
155
156 if (check_func(dsp->fgy_32x32xn, "fgy_32x32xn_%dbpc", BITDEPTH)) {
157 ALIGN_STK_16(Dav1dFilmGrainData, fg_data, 16,);
158 ALIGN_STK_16(entry, grain_lut, GRAIN_HEIGHT + 1,[GRAIN_WIDTH]);
159 ALIGN_STK_64(uint8_t, scaling, SCALING_SIZE,);
160 fg_data[0].seed = rnd() & 0xFFFF;
161
162 #if BITDEPTH == 16
163 const int bitdepth_max = rnd() & 1 ? 0x3ff : 0xfff;
164 #else
165 const int bitdepth_max = 0xff;
166 #endif
167
168 fg_data[0].grain_scale_shift = rnd() & 3;
169 fg_data[0].ar_coeff_shift = (rnd() & 3) + 6;
170 fg_data[0].ar_coeff_lag = rnd() & 3;
171 const int num_y_pos = 2 * fg_data[0].ar_coeff_lag * (fg_data[0].ar_coeff_lag + 1);
172 for (int n = 0; n < num_y_pos; n++)
173 fg_data[0].ar_coeffs_y[n] = (rnd() & 0xff) - 128;
174 dsp->generate_grain_y(grain_lut, fg_data HIGHBD_TAIL_SUFFIX);
175
176 fg_data[0].num_y_points = 2 + (rnd() % 13);
177 const int pad = 0xff / fg_data[0].num_y_points;
178 for (int n = 0; n < fg_data[0].num_y_points; n++) {
179 fg_data[0].y_points[n][0] = 0xff * n / fg_data[0].num_y_points;
180 fg_data[0].y_points[n][0] += rnd() % pad;
181 fg_data[0].y_points[n][1] = rnd() & 0xff;
182 }
183 generate_scaling(bitdepth_from_max(bitdepth_max), fg_data[0].y_points,
184 fg_data[0].num_y_points, scaling);
185
186 fg_data[0].clip_to_restricted_range = rnd() & 1;
187 fg_data[0].scaling_shift = (rnd() & 3) + 8;
188 for (fg_data[0].overlap_flag = 0; fg_data[0].overlap_flag <= 1;
189 fg_data[0].overlap_flag++)
190 {
191 for (int i = 0; i <= 2 * fg_data[0].overlap_flag; i++) {
192 int w, h, row_num;
193 if (fg_data[0].overlap_flag) {
194 w = 35 + (rnd() % 93);
195 if (i == 0) {
196 row_num = 0;
197 h = 1 + (rnd() % 31);
198 } else {
199 row_num = 1 + (rnd() & 0x7ff);
200 if (i == 1) {
201 h = 3 + (rnd() % 30);
202 } else {
203 h = 1 + (rnd() & 1);
204 }
205 }
206 } else {
207 w = 1 + (rnd() & 127);
208 h = 1 + (rnd() & 31);
209 row_num = rnd() & 0x7ff;
210 }
211
212 for (int y = 0; y < 32; y++) {
213 // Src pixels past the right edge can be uninitialized
214 for (int x = 0; x < 128; x++)
215 src[y * PXSTRIDE(stride) + x] = rnd();
216 for (int x = 0; x < w; x++)
217 src[y * PXSTRIDE(stride) + x] &= bitdepth_max;
218 }
219
220 CLEAR_PIXEL_RECT(c_dst);
221 CLEAR_PIXEL_RECT(a_dst);
222 call_ref(c_dst, src, stride, fg_data, w, scaling, grain_lut, h,
223 row_num HIGHBD_TAIL_SUFFIX);
224 call_new(a_dst, src, stride, fg_data, w, scaling, grain_lut, h,
225 row_num HIGHBD_TAIL_SUFFIX);
226
227 checkasm_check_pixel_padded_align(c_dst, stride, a_dst, stride,
228 w, h, "dst", 32, 2);
229 }
230 }
231 fg_data[0].overlap_flag = 1;
232 for (int y = 0; y < 32; y++) {
233 // Make sure all pixels are in range
234 for (int x = 0; x < 128; x++)
235 src[y * PXSTRIDE(stride) + x] &= bitdepth_max;
236 }
237 bench_new(a_dst, src, stride, fg_data, 64, scaling, grain_lut, 32,
238 1 HIGHBD_TAIL_SUFFIX);
239 }
240
241 report("fgy_32x32xn");
242 }
243
check_fguv_sbrow(const Dav1dFilmGrainDSPContext * const dsp)244 static void check_fguv_sbrow(const Dav1dFilmGrainDSPContext *const dsp) {
245 PIXEL_RECT(c_dst, 128, 32);
246 PIXEL_RECT(a_dst, 128, 32);
247 PIXEL_RECT(src, 128, 32);
248 PIXEL_RECT(luma_src, 128, 32);
249 const ptrdiff_t lstride = luma_src_stride;
250
251 declare_func(void, pixel *dst_row, const pixel *src_row, ptrdiff_t stride,
252 const Dav1dFilmGrainData *data, size_t pw,
253 const uint8_t scaling[SCALING_SIZE],
254 const entry grain_lut[][GRAIN_WIDTH], int bh, int row_num,
255 const pixel *luma_row, ptrdiff_t luma_stride, int uv_pl,
256 int is_identity HIGHBD_DECL_SUFFIX);
257
258 for (int layout_idx = 0; layout_idx < 3; layout_idx++) {
259 const enum Dav1dPixelLayout layout = layout_idx + 1;
260 const int ss_x = layout != DAV1D_PIXEL_LAYOUT_I444;
261 const int ss_y = layout == DAV1D_PIXEL_LAYOUT_I420;
262 const ptrdiff_t stride = c_dst_stride;
263
264 for (int csfl = 0; csfl <= 1; csfl++) {
265 if (check_func(dsp->fguv_32x32xn[layout_idx],
266 "fguv_32x32xn_%dbpc_%s_csfl%d",
267 BITDEPTH, ss_name[layout_idx], csfl))
268 {
269 ALIGN_STK_16(Dav1dFilmGrainData, fg_data, 1,);
270 ALIGN_STK_16(entry, grain_lut, 2,[GRAIN_HEIGHT + 1][GRAIN_WIDTH]);
271 ALIGN_STK_64(uint8_t, scaling, SCALING_SIZE,);
272
273 fg_data[0].seed = rnd() & 0xFFFF;
274
275 #if BITDEPTH == 16
276 const int bitdepth_max = rnd() & 1 ? 0x3ff : 0xfff;
277 #else
278 const int bitdepth_max = 0xff;
279 #endif
280 const int uv_pl = rnd() & 1;
281 const int is_identity = rnd() & 1;
282
283 fg_data[0].grain_scale_shift = rnd() & 3;
284 fg_data[0].ar_coeff_shift = (rnd() & 3) + 6;
285 fg_data[0].ar_coeff_lag = rnd() & 3;
286 fg_data[0].num_y_points = csfl ? 2 + (rnd() % 13) : 0;
287 const int num_y_pos = 2 * fg_data[0].ar_coeff_lag * (fg_data[0].ar_coeff_lag + 1);
288 for (int n = 0; n < num_y_pos; n++)
289 fg_data[0].ar_coeffs_y[n] = (rnd() & 0xff) - 128;
290 const int num_uv_pos = num_y_pos + 1;
291 for (int n = 0; n < num_uv_pos; n++)
292 fg_data[0].ar_coeffs_uv[uv_pl][n] = (rnd() & 0xff) - 128;
293 dsp->generate_grain_y(grain_lut[0], fg_data HIGHBD_TAIL_SUFFIX);
294 dsp->generate_grain_uv[layout_idx](grain_lut[1], grain_lut[0],
295 fg_data, uv_pl HIGHBD_TAIL_SUFFIX);
296
297 if (csfl) {
298 const int pad = 0xff / fg_data[0].num_y_points;
299 for (int n = 0; n < fg_data[0].num_y_points; n++) {
300 fg_data[0].y_points[n][0] = 0xff * n / fg_data[0].num_y_points;
301 fg_data[0].y_points[n][0] += rnd() % pad;
302 fg_data[0].y_points[n][1] = rnd() & 0xff;
303 }
304 generate_scaling(bitdepth_from_max(bitdepth_max), fg_data[0].y_points,
305 fg_data[0].num_y_points, scaling);
306 } else {
307 fg_data[0].num_uv_points[uv_pl] = 2 + (rnd() % 9);
308 const int pad = 0xff / fg_data[0].num_uv_points[uv_pl];
309 for (int n = 0; n < fg_data[0].num_uv_points[uv_pl]; n++) {
310 fg_data[0].uv_points[uv_pl][n][0] = 0xff * n / fg_data[0].num_uv_points[uv_pl];
311 fg_data[0].uv_points[uv_pl][n][0] += rnd() % pad;
312 fg_data[0].uv_points[uv_pl][n][1] = rnd() & 0xff;
313 }
314 generate_scaling(bitdepth_from_max(bitdepth_max), fg_data[0].uv_points[uv_pl],
315 fg_data[0].num_uv_points[uv_pl], scaling);
316
317 fg_data[0].uv_mult[uv_pl] = (rnd() & 0xff) - 128;
318 fg_data[0].uv_luma_mult[uv_pl] = (rnd() & 0xff) - 128;
319 fg_data[0].uv_offset[uv_pl] = (rnd() & 0x1ff) - 256;
320 }
321
322 fg_data[0].clip_to_restricted_range = rnd() & 1;
323 fg_data[0].scaling_shift = (rnd() & 3) + 8;
324 fg_data[0].chroma_scaling_from_luma = csfl;
325 for (fg_data[0].overlap_flag = 0; fg_data[0].overlap_flag <= 1;
326 fg_data[0].overlap_flag++)
327 {
328 for (int i = 0; i <= 2 * fg_data[0].overlap_flag; i++) {
329 int w, h, row_num;
330 if (fg_data[0].overlap_flag) {
331 w = (36 >> ss_x) + (rnd() % (92 >> ss_x));
332 if (i == 0) {
333 row_num = 0;
334 h = 1 + (rnd() & (31 >> ss_y));
335 } else {
336 row_num = 1 + (rnd() & 0x7ff);
337 if (i == 1) {
338 h = (ss_y ? 2 : 3) + (rnd() % (ss_y ? 15 : 30));
339 } else {
340 h = ss_y ? 1 : 1 + (rnd() & 1);
341 }
342 }
343 } else {
344 w = 1 + (rnd() & (127 >> ss_x));
345 h = 1 + (rnd() & (31 >> ss_y));
346 row_num = rnd() & 0x7ff;
347 }
348
349 for (int y = 0; y < 32; y++) {
350 // Src pixels past the right edge can be uninitialized
351 for (int x = 0; x < 128; x++) {
352 src[y * PXSTRIDE(stride) + x] = rnd();
353 luma_src[y * PXSTRIDE(lstride) + x] = rnd();
354 }
355 for (int x = 0; x < w; x++)
356 src[y * PXSTRIDE(stride) + x] &= bitdepth_max;
357 for (int x = 0; x < (w << ss_x); x++)
358 luma_src[y * PXSTRIDE(lstride) + x] &= bitdepth_max;
359 }
360
361 CLEAR_PIXEL_RECT(c_dst);
362 CLEAR_PIXEL_RECT(a_dst);
363 call_ref(c_dst, src, stride, fg_data, w, scaling, grain_lut[1], h,
364 row_num, luma_src, lstride, uv_pl, is_identity HIGHBD_TAIL_SUFFIX);
365 call_new(a_dst, src, stride, fg_data, w, scaling, grain_lut[1], h,
366 row_num, luma_src, lstride, uv_pl, is_identity HIGHBD_TAIL_SUFFIX);
367
368 checkasm_check_pixel_padded_align(c_dst, stride,
369 a_dst, stride,
370 w, h, "dst",
371 32 >> ss_x, 4);
372 }
373 }
374
375 fg_data[0].overlap_flag = 1;
376 for (int y = 0; y < 32; y++) {
377 // Make sure all pixels are in range
378 for (int x = 0; x < 128; x++) {
379 src[y * PXSTRIDE(stride) + x] &= bitdepth_max;
380 luma_src[y * PXSTRIDE(lstride) + x] &= bitdepth_max;
381 }
382 }
383 bench_new(a_dst, src, stride, fg_data, 64 >> ss_x, scaling, grain_lut[1], 32 >> ss_y,
384 1, luma_src, lstride, uv_pl, is_identity HIGHBD_TAIL_SUFFIX);
385 }
386 }
387 }
388
389 report("fguv_32x32xn");
390 }
391
bitfn(checkasm_check_filmgrain)392 void bitfn(checkasm_check_filmgrain)(void) {
393 Dav1dFilmGrainDSPContext c;
394
395 bitfn(dav1d_film_grain_dsp_init)(&c);
396
397 check_gen_grny(&c);
398 check_gen_grnuv(&c);
399 check_fgy_sbrow(&c);
400 check_fguv_sbrow(&c);
401 }
402