FFmpeg
Loading...
Searching...
No Matches
hevc_pel.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015 Henrik Gramner
3 * Copyright (c) 2021 Josh Dekker
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22#include <string.h>
23#include "checkasm.h"
24#include "libavcodec/hevc/dsp.h"
25#include "libavutil/common.h"
26#include "libavutil/internal.h"
27#include "libavutil/intreadwrite.h"
28
29static const uint32_t pixel_mask[] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff, 0x07ff07ff, 0x0fff0fff };
30static const uint32_t pixel_mask16[] = { 0x00ff00ff, 0x01ff01ff, 0x03ff03ff, 0x07ff07ff, 0x0fff0fff };
31static const int sizes[] = { -1, 4, 6, 8, 12, 16, 24, 32, 48, 64 };
32static const int weights[] = { 0, 128, 255, -1 };
33static const int denoms[] = {0, 7, -1 };
34static const int offsets[] = {0, 255, -1 };
35
36#define SIZEOF_PIXEL ((bit_depth + 7) / 8)
37#define BUF_SIZE (2 * MAX_PB_SIZE * (2 * 4 + MAX_PB_SIZE))
38
39#define randomize_buffers() \
40 do { \
41 uint32_t mask = pixel_mask[bit_depth - 8]; \
42 int k; \
43 for (k = 0; k < BUF_SIZE + SRC_EXTRA; k += 4) { \
44 uint32_t r = rnd() & mask; \
45 AV_WN32A(buf0 + k, r); \
46 AV_WN32A(buf1 + k, r); \
47 } \
48 } while (0)
49
50#define randomize_buffers_dst() \
51 do { \
52 int k; \
53 for (k = 0; k < BUF_SIZE; k += 4) { \
54 uint32_t r = rnd(); \
55 AV_WN32A(dst0 + k, r); \
56 AV_WN32A(dst1 + k, r); \
57 } \
58 } while (0)
59
60#define randomize_buffers_ref() \
61 randomize_buffers(); \
62 do { \
63 uint32_t mask = pixel_mask16[bit_depth - 8]; \
64 int k; \
65 for (k = 0; k < BUF_SIZE; k += 2) { \
66 uint32_t r = rnd() & mask; \
67 AV_WN32A(ref0 + k, r); \
68 AV_WN32A(ref1 + k, r); \
69 } \
70 } while (0)
71
72#define src0 (buf0 + 2 * 4 * MAX_PB_SIZE) /* hevc qpel functions read data from negative src pointer offsets */
73#define src1 (buf1 + 2 * 4 * MAX_PB_SIZE)
74
75/* FIXME: Does the need for SRC_EXTRA for these tests indicate a bug? */
76#define SRC_EXTRA 8
77
78static void checkasm_check_hevc_qpel(void)
79{
80 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]);
81 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]);
82 LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
83 LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
84
85 HEVCDSPContext h;
86 int idx, bit_depth, i, j;
87 declare_func(void, int16_t *dst, const uint8_t *src, ptrdiff_t srcstride,
88 int height, intptr_t mx, intptr_t my, int width);
89
90 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
91 ff_hevc_dsp_init(&h, bit_depth);
92
93 for (i = 0; i < 2; i++) {
94 for (j = 0; j < 2; j++) {
95 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
96 const char *type;
97 switch ((j << 1) | i) {
98 case 0: type = "pel_pixels"; break; // 0 0
99 case 1: type = "qpel_h"; break; // 0 1
100 case 2: type = "qpel_v"; break; // 1 0
101 case 3: type = "qpel_hv"; break; // 1 1
102 }
103
104 if (check_func(h.put_hevc_qpel[idx][j][i],
105 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
106 int16_t *dstw0 = (int16_t *) dst0, *dstw1 = (int16_t *) dst1;
107 randomize_buffers();
108 randomize_buffers_dst();
109 call_ref(dstw0, src0, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
110 call_new(dstw1, src1, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
111 checkasm_check(int16_t, dstw0, MAX_PB_SIZE * sizeof(int16_t),
112 dstw1, MAX_PB_SIZE * sizeof(int16_t),
113 sizes[idx], sizes[idx], "dst");
114 bench_new(dstw1, src1, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
115 }
116 }
117 }
118 }
119 }
120 report("qpel");
121}
122
123static void checkasm_check_hevc_qpel_uni(void)
124{
125 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]);
126 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]);
127 PIXEL_RECT(dst0, 64, 64);
128 PIXEL_RECT(dst1, 64, 64);
129
130 HEVCDSPContext h;
131 int idx, bit_depth, i, j;
132 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
133 int height, intptr_t mx, intptr_t my, int width);
134
135 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
136 ff_hevc_dsp_init(&h, bit_depth);
137
138 for (i = 0; i < 2; i++) {
139 for (j = 0; j < 2; j++) {
140 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
141 const char *type;
142 switch ((j << 1) | i) {
143 case 0: type = "pel_uni_pixels"; break; // 0 0
144 case 1: type = "qpel_uni_h"; break; // 0 1
145 case 2: type = "qpel_uni_v"; break; // 1 0
146 case 3: type = "qpel_uni_hv"; break; // 1 1
147 }
148
149 if (check_func(h.put_hevc_qpel_uni[idx][j][i],
150 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
151 randomize_buffers();
152 CLEAR_PIXEL_RECT(dst0);
153 CLEAR_PIXEL_RECT(dst1);
154 call_ref(dst0, dst0_stride,
155 src0, sizes[idx] * SIZEOF_PIXEL,
156 sizes[idx], i, j, sizes[idx]);
157 call_new(dst1, dst1_stride,
158 src1, sizes[idx] * SIZEOF_PIXEL,
159 sizes[idx], i, j, sizes[idx]);
160 checkasm_check_pixel_padded(dst0, dst0_stride,
161 dst1, dst1_stride,
162 sizes[idx], sizes[idx], "dst");
163 bench_new(dst1, dst1_stride,
164 src1, sizes[idx] * SIZEOF_PIXEL,
165 sizes[idx], i, j, sizes[idx]);
166 }
167 }
168 }
169 }
170 }
171 report("qpel_uni");
172}
173
174static void checkasm_check_hevc_qpel_uni_w(void)
175{
176 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]);
177 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]);
178 PIXEL_RECT(dst0, 64, 64);
179 PIXEL_RECT(dst1, 64, 64);
180
181 HEVCDSPContext h;
182 int idx, bit_depth, i, j;
183 const int *denom, *wx, *ox;
184 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
185 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width);
186
187 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
188 ff_hevc_dsp_init(&h, bit_depth);
189
190 for (i = 0; i < 2; i++) {
191 for (j = 0; j < 2; j++) {
192 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
193 const char *type;
194 switch ((j << 1) | i) {
195 case 0: type = "pel_uni_w_pixels"; break; // 0 0
196 case 1: type = "qpel_uni_w_h"; break; // 0 1
197 case 2: type = "qpel_uni_w_v"; break; // 1 0
198 case 3: type = "qpel_uni_w_hv"; break; // 1 1
199 }
200
201 if (check_func(h.put_hevc_qpel_uni_w[idx][j][i],
202 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
203 for (denom = denoms; *denom >= 0; denom++) {
204 for (wx = weights; *wx >= 0; wx++) {
205 for (ox = offsets; *ox >= 0; ox++) {
206 randomize_buffers();
207 CLEAR_PIXEL_RECT(dst0);
208 CLEAR_PIXEL_RECT(dst1);
209 call_ref(dst0, dst0_stride,
210 src0, sizes[idx] * SIZEOF_PIXEL,
211 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
212 call_new(dst1, dst1_stride,
213 src1, sizes[idx] * SIZEOF_PIXEL,
214 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
215 checkasm_check_pixel_padded(dst0, dst0_stride,
216 dst1, dst1_stride,
217 sizes[idx], sizes[idx], "dst");
218 bench_new(dst1, dst1_stride,
219 src1, sizes[idx] * SIZEOF_PIXEL,
220 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
221 }
222 }
223 }
224 }
225 }
226 }
227 }
228 }
229 report("qpel_uni_w");
230}
231
232static void checkasm_check_hevc_qpel_bi(void)
233{
234 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]);
235 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]);
236 PIXEL_RECT(dst0, 64, 64);
237 PIXEL_RECT(dst1, 64, 64);
238 LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
239 LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
240
241 HEVCDSPContext h;
242 int idx, bit_depth, i, j;
243 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
244 const int16_t *src2,
245 int height, intptr_t mx, intptr_t my, int width);
246
247 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
248 ff_hevc_dsp_init(&h, bit_depth);
249
250 for (i = 0; i < 2; i++) {
251 for (j = 0; j < 2; j++) {
252 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
253 const char *type;
254 switch ((j << 1) | i) {
255 case 0: type = "pel_bi_pixels"; break; // 0 0
256 case 1: type = "qpel_bi_h"; break; // 0 1
257 case 2: type = "qpel_bi_v"; break; // 1 0
258 case 3: type = "qpel_bi_hv"; break; // 1 1
259 }
260
261 if (check_func(h.put_hevc_qpel_bi[idx][j][i],
262 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
263 randomize_buffers_ref();
264 CLEAR_PIXEL_RECT(dst0);
265 CLEAR_PIXEL_RECT(dst1);
266 call_ref(dst0, dst0_stride,
267 src0, sizes[idx] * SIZEOF_PIXEL,
268 ref0, sizes[idx], i, j, sizes[idx]);
269 call_new(dst1, dst1_stride,
270 src1, sizes[idx] * SIZEOF_PIXEL,
271 ref1, sizes[idx], i, j, sizes[idx]);
272 checkasm_check_pixel_padded(dst0, dst0_stride,
273 dst1, dst1_stride,
274 sizes[idx], sizes[idx], "dst");
275 bench_new(dst1, dst1_stride,
276 src1, sizes[idx] * SIZEOF_PIXEL,
277 ref1, sizes[idx], i, j, sizes[idx]);
278 }
279 }
280 }
281 }
282 }
283 report("qpel_bi");
284}
285
286static void checkasm_check_hevc_qpel_bi_w(void)
287{
288 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE + SRC_EXTRA]);
289 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE + SRC_EXTRA]);
290 PIXEL_RECT(dst0, 64, 64);
291 PIXEL_RECT(dst1, 64, 64);
292 LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
293 LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
294
295 HEVCDSPContext h;
296 int idx, bit_depth, i, j;
297 const int *denom, *wx, *ox;
298 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
299 const int16_t *src2,
300 int height, int denom, int wx0, int wx1,
301 int ox, intptr_t mx, intptr_t my, int width);
302
303 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
304 ff_hevc_dsp_init(&h, bit_depth);
305
306 for (i = 0; i < 2; i++) {
307 for (j = 0; j < 2; j++) {
308 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
309 const char *type;
310 switch ((j << 1) | i) {
311 case 0: type = "pel_bi_w_pixels"; break; // 0 0
312 case 1: type = "qpel_bi_w_h"; break; // 0 1
313 case 2: type = "qpel_bi_w_v"; break; // 1 0
314 case 3: type = "qpel_bi_w_hv"; break; // 1 1
315 }
316
317 if (check_func(h.put_hevc_qpel_bi_w[idx][j][i],
318 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
319 for (denom = denoms; *denom >= 0; denom++) {
320 for (wx = weights; *wx >= 0; wx++) {
321 for (ox = offsets; *ox >= 0; ox++) {
322 randomize_buffers_ref();
323 CLEAR_PIXEL_RECT(dst0);
324 CLEAR_PIXEL_RECT(dst1);
325 call_ref(dst0, dst0_stride,
326 src0, sizes[idx] * SIZEOF_PIXEL,
327 ref0, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
328 call_new(dst1, dst1_stride,
329 src1, sizes[idx] * SIZEOF_PIXEL,
330 ref1, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
331 checkasm_check_pixel_padded(dst0, dst0_stride,
332 dst1, dst1_stride,
333 sizes[idx], sizes[idx], "dst");
334 bench_new(dst1, dst1_stride,
335 src1, sizes[idx] * SIZEOF_PIXEL,
336 ref1, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
337 }
338 }
339 }
340 }
341 }
342 }
343 }
344 }
345 report("qpel_bi_w");
346}
347
348#undef SRC_EXTRA
349#define SRC_EXTRA 0
350
351static void checkasm_check_hevc_epel(void)
352{
353 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
354 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
355 LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
356 LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
357
358 HEVCDSPContext h;
359 int idx, bit_depth, i, j;
360 declare_func(void, int16_t *dst, const uint8_t *src, ptrdiff_t srcstride,
361 int height, intptr_t mx, intptr_t my, int width);
362
363 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
364 ff_hevc_dsp_init(&h, bit_depth);
365
366 for (i = 0; i < 2; i++) {
367 for (j = 0; j < 2; j++) {
368 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
369 const char *type;
370 switch ((j << 1) | i) {
371 case 0: type = "pel_pixels"; break; // 0 0
372 case 1: type = "epel_h"; break; // 0 1
373 case 2: type = "epel_v"; break; // 1 0
374 case 3: type = "epel_hv"; break; // 1 1
375 }
376
377 if (check_func(h.put_hevc_epel[idx][j][i],
378 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
379 int16_t *dstw0 = (int16_t *) dst0, *dstw1 = (int16_t *) dst1;
380 randomize_buffers();
381 randomize_buffers_dst();
382 call_ref(dstw0, src0, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
383 call_new(dstw1, src1, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
384 checkasm_check(int16_t, dstw0, MAX_PB_SIZE * sizeof(int16_t),
385 dstw1, MAX_PB_SIZE * sizeof(int16_t),
386 sizes[idx], sizes[idx], "dst");
387 bench_new(dstw1, src1, sizes[idx] * SIZEOF_PIXEL, sizes[idx], i, j, sizes[idx]);
388 }
389 }
390 }
391 }
392 }
393 report("epel");
394}
395
396static void checkasm_check_hevc_epel_uni(void)
397{
398 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
399 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
400 PIXEL_RECT(dst0, 64, 64);
401 PIXEL_RECT(dst1, 64, 64);
402
403 HEVCDSPContext h;
404 int idx, bit_depth, i, j;
405 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
406 int height, intptr_t mx, intptr_t my, int width);
407
408 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
409 ff_hevc_dsp_init(&h, bit_depth);
410
411 for (i = 0; i < 2; i++) {
412 for (j = 0; j < 2; j++) {
413 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
414 const char *type;
415 switch ((j << 1) | i) {
416 case 0: type = "pel_uni_pixels"; break; // 0 0
417 case 1: type = "epel_uni_h"; break; // 0 1
418 case 2: type = "epel_uni_v"; break; // 1 0
419 case 3: type = "epel_uni_hv"; break; // 1 1
420 }
421
422 if (check_func(h.put_hevc_epel_uni[idx][j][i],
423 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
424 randomize_buffers();
425 CLEAR_PIXEL_RECT(dst0);
426 CLEAR_PIXEL_RECT(dst1);
427 call_ref(dst0, dst0_stride,
428 src0, sizes[idx] * SIZEOF_PIXEL,
429 sizes[idx], i, j, sizes[idx]);
430 call_new(dst1, dst1_stride,
431 src1, sizes[idx] * SIZEOF_PIXEL,
432 sizes[idx], i, j, sizes[idx]);
433 checkasm_check_pixel_padded(dst0, dst0_stride,
434 dst1, dst1_stride,
435 sizes[idx], sizes[idx], "dst");
436 bench_new(dst1, dst1_stride,
437 src1, sizes[idx] * SIZEOF_PIXEL,
438 sizes[idx], i, j, sizes[idx]);
439 }
440 }
441 }
442 }
443 }
444 report("epel_uni");
445}
446
447static void checkasm_check_hevc_epel_uni_w(void)
448{
449 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
450 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
451 PIXEL_RECT(dst0, 64, 64);
452 PIXEL_RECT(dst1, 64, 64);
453
454 HEVCDSPContext h;
455 int idx, bit_depth, i, j;
456 const int *denom, *wx, *ox;
457 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
458 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width);
459
460 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
461 ff_hevc_dsp_init(&h, bit_depth);
462
463 for (i = 0; i < 2; i++) {
464 for (j = 0; j < 2; j++) {
465 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
466 const char *type;
467 switch ((j << 1) | i) {
468 case 0: type = "pel_uni_w_pixels"; break; // 0 0
469 case 1: type = "epel_uni_w_h"; break; // 0 1
470 case 2: type = "epel_uni_w_v"; break; // 1 0
471 case 3: type = "epel_uni_w_hv"; break; // 1 1
472 }
473
474 if (check_func(h.put_hevc_epel_uni_w[idx][j][i],
475 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
476 for (denom = denoms; *denom >= 0; denom++) {
477 for (wx = weights; *wx >= 0; wx++) {
478 for (ox = offsets; *ox >= 0; ox++) {
479 randomize_buffers();
480 CLEAR_PIXEL_RECT(dst0);
481 CLEAR_PIXEL_RECT(dst1);
482 call_ref(dst0, dst0_stride,
483 src0, sizes[idx] * SIZEOF_PIXEL,
484 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
485 call_new(dst1, dst1_stride,
486 src1, sizes[idx] * SIZEOF_PIXEL,
487 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
488 checkasm_check_pixel_padded(dst0, dst0_stride,
489 dst1, dst1_stride,
490 sizes[idx], sizes[idx], "dst");
491 bench_new(dst1, dst1_stride,
492 src1, sizes[idx] * SIZEOF_PIXEL,
493 sizes[idx], *denom, *wx, *ox, i, j, sizes[idx]);
494 }
495 }
496 }
497 }
498 }
499 }
500 }
501 }
502 report("epel_uni_w");
503}
504
505static void checkasm_check_hevc_epel_bi(void)
506{
507 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
508 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
509 PIXEL_RECT(dst0, 64, 64);
510 PIXEL_RECT(dst1, 64, 64);
511 LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
512 LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
513
514 HEVCDSPContext h;
515 int idx, bit_depth, i, j;
516 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
517 const int16_t *src2,
518 int height, intptr_t mx, intptr_t my, int width);
519
520 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
521 ff_hevc_dsp_init(&h, bit_depth);
522
523 for (i = 0; i < 2; i++) {
524 for (j = 0; j < 2; j++) {
525 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
526 const char *type;
527 switch ((j << 1) | i) {
528 case 0: type = "pel_bi_pixels"; break; // 0 0
529 case 1: type = "epel_bi_h"; break; // 0 1
530 case 2: type = "epel_bi_v"; break; // 1 0
531 case 3: type = "epel_bi_hv"; break; // 1 1
532 }
533
534 if (check_func(h.put_hevc_epel_bi[idx][j][i],
535 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
536 randomize_buffers_ref();
537 CLEAR_PIXEL_RECT(dst0);
538 CLEAR_PIXEL_RECT(dst1);
539 call_ref(dst0, dst0_stride,
540 src0, sizes[idx] * SIZEOF_PIXEL,
541 ref0, sizes[idx], i, j, sizes[idx]);
542 call_new(dst1, dst1_stride,
543 src1, sizes[idx] * SIZEOF_PIXEL,
544 ref1, sizes[idx], i, j, sizes[idx]);
545 checkasm_check_pixel_padded(dst0, dst0_stride,
546 dst1, dst1_stride,
547 sizes[idx], sizes[idx], "dst");
548 bench_new(dst1, dst1_stride,
549 src1, sizes[idx] * SIZEOF_PIXEL,
550 ref1, sizes[idx], i, j, sizes[idx]);
551 }
552 }
553 }
554 }
555 }
556 report("epel_bi");
557}
558
559static void checkasm_check_hevc_epel_bi_w(void)
560{
561 LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
562 LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
563 PIXEL_RECT(dst0, 64, 64);
564 PIXEL_RECT(dst1, 64, 64);
565 LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
566 LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
567
568 HEVCDSPContext h;
569 int idx, bit_depth, i, j;
570 const int *denom, *wx, *ox;
571 declare_func(void, uint8_t *dst, ptrdiff_t dststride, const uint8_t *src, ptrdiff_t srcstride,
572 const int16_t *src2,
573 int height, int denom, int wx0, int wx1,
574 int ox, intptr_t mx, intptr_t my, int width);
575
576 for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
577 ff_hevc_dsp_init(&h, bit_depth);
578
579 for (i = 0; i < 2; i++) {
580 for (j = 0; j < 2; j++) {
581 for (idx = 1; idx < FF_ARRAY_ELEMS(sizes); idx++) {
582 const char *type;
583 switch ((j << 1) | i) {
584 case 0: type = "pel_bi_w_pixels"; break; // 0 0
585 case 1: type = "epel_bi_w_h"; break; // 0 1
586 case 2: type = "epel_bi_w_v"; break; // 1 0
587 case 3: type = "epel_bi_w_hv"; break; // 1 1
588 }
589
590 if (check_func(h.put_hevc_epel_bi_w[idx][j][i],
591 "put_hevc_%s%d_%d", type, sizes[idx], bit_depth)) {
592 for (denom = denoms; *denom >= 0; denom++) {
593 for (wx = weights; *wx >= 0; wx++) {
594 for (ox = offsets; *ox >= 0; ox++) {
595 randomize_buffers_ref();
596 CLEAR_PIXEL_RECT(dst0);
597 CLEAR_PIXEL_RECT(dst1);
598 call_ref(dst0, dst0_stride,
599 src0, sizes[idx] * SIZEOF_PIXEL,
600 ref0, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
601 call_new(dst1, dst1_stride,
602 src1, sizes[idx] * SIZEOF_PIXEL,
603 ref1, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
604 checkasm_check_pixel_padded(dst0, dst0_stride,
605 dst1, dst1_stride,
606 sizes[idx], sizes[idx], "dst");
607 bench_new(dst1, dst1_stride,
608 src1, sizes[idx] * SIZEOF_PIXEL,
609 ref1, sizes[idx], *denom, *wx, *wx, *ox + *ox, i, j, sizes[idx]);
610 }
611 }
612 }
613 }
614 }
615 }
616 }
617 }
618 report("epel_bi_w");
619}
620
srcstride
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t const uint8_t ptrdiff_t srcstride
Definition dsp.h:88
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition dsp.h:57
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition dsp.h:57
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition af_astats.c:246
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
checkasm_check_pixel_padded
#define checkasm_check_pixel_padded(...)
Definition checkasm.h:167
CLEAR_PIXEL_RECT
#define CLEAR_PIXEL_RECT(name)
Definition checkasm.h:152
PIXEL_RECT
#define PIXEL_RECT(name, w, h)
Definition checkasm.h:145
common.h
common internal and external API header
declare_func
#define declare_func
Definition test.h:489
bench_new
#define bench_new
Definition test.h:487
check_func
#define check_func
Definition test.h:481
call_new
#define call_new
Definition test.h:486
call_ref
#define call_ref
Definition test.h:485
report
#define report
Definition test.h:480
src2
const pixel * src2
Definition h264pred_template.c:421
ff_hevc_dsp_init
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition dsp.c:128
MAX_PB_SIZE
#define MAX_PB_SIZE
Definition dsp.h:32
checkasm_check_hevc_qpel_bi
static void checkasm_check_hevc_qpel_bi(void)
Definition hevc_pel.c:232
randomize_buffers
#define randomize_buffers()
Definition hevc_pel.c:39
checkasm_check_hevc_epel_bi_w
static void checkasm_check_hevc_epel_bi_w(void)
Definition hevc_pel.c:559
pixel_mask16
static const uint32_t pixel_mask16[]
Definition hevc_pel.c:30
checkasm_check_hevc_epel
static void checkasm_check_hevc_epel(void)
Definition hevc_pel.c:351
randomize_buffers_dst
#define randomize_buffers_dst()
Definition hevc_pel.c:50
SRC_EXTRA
#define SRC_EXTRA
Definition hevc_pel.c:76
checkasm_check_hevc_qpel_uni
static void checkasm_check_hevc_qpel_uni(void)
Definition hevc_pel.c:123
denoms
static const int denoms[]
Definition hevc_pel.c:33
checkasm_check_hevc_qpel_uni_w
static void checkasm_check_hevc_qpel_uni_w(void)
Definition hevc_pel.c:174
checkasm_check_hevc_qpel_bi_w
static void checkasm_check_hevc_qpel_bi_w(void)
Definition hevc_pel.c:286
randomize_buffers_ref
#define randomize_buffers_ref()
Definition hevc_pel.c:60
checkasm_check_hevc_pel
void checkasm_check_hevc_pel(void)
Definition hevc_pel.c:621
offsets
static const int offsets[]
Definition hevc_pel.c:34
checkasm_check_hevc_epel_bi
static void checkasm_check_hevc_epel_bi(void)
Definition hevc_pel.c:505
checkasm_check_hevc_epel_uni_w
static void checkasm_check_hevc_epel_uni_w(void)
Definition hevc_pel.c:447
weights
static const int weights[]
Definition hevc_pel.c:32
checkasm_check_hevc_epel_uni
static void checkasm_check_hevc_epel_uni(void)
Definition hevc_pel.c:396
checkasm_check_hevc_qpel
static void checkasm_check_hevc_qpel(void)
Definition hevc_pel.c:78
type
cl_device_type type
Definition hwcontext_opencl.c:213
sizes
static const int sizes[][2]
Definition img2dec.c:62
internal.h
common internal API header
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition mem_internal.h:132
BUF_SIZE
#define BUF_SIZE
Definition setpts.c:159
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
SIZEOF_PIXEL
#define SIZEOF_PIXEL
Definition h264chroma.c:28
pixel_mask
static const uint32_t pixel_mask[5]
Definition h264dsp.c:31
src1
#define src1
Definition h264pred.c:141
src0
#define src0
Definition h264pred.c:140
src
#define src
Definition vp8dsp.c:248
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
h
h
Definition vp9dsp_template.c:2070
Generated on Mon Aug 17 2026 20:21:13 for FFmpeg by doxygen 1.13.2