FFmpeg
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/hevcdsp.h"
25 #include "libavutil/common.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/intreadwrite.h"
28 
29 static const uint32_t pixel_mask[] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff, 0x07ff07ff, 0x0fff0fff };
30 static const uint32_t pixel_mask16[] = { 0x00ff00ff, 0x01ff01ff, 0x03ff03ff, 0x07ff07ff, 0x0fff0fff };
31 static const int sizes[] = { -1, 4, 6, 8, 12, 16, 24, 32, 48, 64 };
32 static const int weights[] = { 0, 128, 255, -1 };
33 static const int denoms[] = {0, 7, 12, -1 };
34 static 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; k += 4) { \
44  uint32_t r = rnd() & mask; \
45  AV_WN32A(buf0 + k, r); \
46  AV_WN32A(buf1 + k, r); \
47  r = rnd(); \
48  AV_WN32A(dst0 + k, r); \
49  AV_WN32A(dst1 + k, r); \
50  } \
51  } while (0)
52 
53 #define randomize_buffers_ref() \
54  randomize_buffers(); \
55  do { \
56  uint32_t mask = pixel_mask16[bit_depth - 8]; \
57  int k; \
58  for (k = 0; k < BUF_SIZE; k += 2) { \
59  uint32_t r = rnd() & mask; \
60  AV_WN32A(ref0 + k, r); \
61  AV_WN32A(ref1 + k, r); \
62  } \
63  } while (0)
64 
65 #define src0 (buf0 + 2 * 4 * MAX_PB_SIZE) /* hevc qpel functions read data from negative src pointer offsets */
66 #define src1 (buf1 + 2 * 4 * MAX_PB_SIZE)
67 
68 void checkasm_check_hevc_qpel(void)
69 {
70  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
71  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
72  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
73  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
74 
75  HEVCDSPContext h;
76  int size, bit_depth, i, j, row;
77  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, int16_t *dst, uint8_t *src, ptrdiff_t srcstride,
78  int height, intptr_t mx, intptr_t my, int width);
79 
80  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
81  ff_hevc_dsp_init(&h, bit_depth);
82 
83  for (i = 0; i < 2; i++) {
84  for (j = 0; j < 2; j++) {
85  for (size = 1; size < 10; size++) {
86  const char *type;
87  switch ((j << 1) | i) {
88  case 0: type = "pel_pixels"; break; // 0 0
89  case 1: type = "qpel_h"; break; // 0 1
90  case 2: type = "qpel_v"; break; // 1 0
91  case 3: type = "qpel_hv"; break; // 1 1
92  }
93 
94  if (check_func(h.put_hevc_qpel[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
95  int16_t *dstw0 = (int16_t *) dst0, *dstw1 = (int16_t *) dst1;
96  randomize_buffers();
97  call_ref(dstw0, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
98  call_new(dstw1, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
99  for (row = 0; row < size[sizes]; row++) {
100  if (memcmp(dstw0 + row * MAX_PB_SIZE, dstw1 + row * MAX_PB_SIZE, sizes[size] * SIZEOF_PIXEL))
101  fail();
102  }
103  bench_new(dstw1, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
104  }
105  }
106  }
107  }
108  }
109  report("qpel");
110 }
111 
112 void checkasm_check_hevc_qpel_uni(void)
113 {
114  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
115  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
116  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
117  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
118 
119  HEVCDSPContext h;
120  int size, bit_depth, i, j;
121  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
122  int height, intptr_t mx, intptr_t my, int width);
123 
124  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
125  ff_hevc_dsp_init(&h, bit_depth);
126 
127  for (i = 0; i < 2; i++) {
128  for (j = 0; j < 2; j++) {
129  for (size = 1; size < 10; size++) {
130  const char *type;
131  switch ((j << 1) | i) {
132  case 0: type = "pel_uni_pixels"; break; // 0 0
133  case 1: type = "qpel_uni_h"; break; // 0 1
134  case 2: type = "qpel_uni_v"; break; // 1 0
135  case 3: type = "qpel_uni_hv"; break; // 1 1
136  }
137 
138  if (check_func(h.put_hevc_qpel_uni[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
139  randomize_buffers();
140  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
141  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
142  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
143  fail();
144  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
145  }
146  }
147  }
148  }
149  }
150  report("qpel_uni");
151 }
152 
153 void checkasm_check_hevc_qpel_uni_w(void)
154 {
155  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
156  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
157  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
158  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
159 
160  HEVCDSPContext h;
161  int size, bit_depth, i, j;
162  const int *denom, *wx, *ox;
163  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
164  int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width);
165 
166  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
167  ff_hevc_dsp_init(&h, bit_depth);
168 
169  for (i = 0; i < 2; i++) {
170  for (j = 0; j < 2; j++) {
171  for (size = 1; size < 10; size++) {
172  const char *type;
173  switch ((j << 1) | i) {
174  case 0: type = "pel_uni_w_pixels"; break; // 0 0
175  case 1: type = "qpel_uni_w_h"; break; // 0 1
176  case 2: type = "qpel_uni_w_v"; break; // 1 0
177  case 3: type = "qpel_uni_w_hv"; break; // 1 1
178  }
179 
180  if (check_func(h.put_hevc_qpel_uni_w[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
181  for (denom = denoms; *denom >= 0; denom++) {
182  for (wx = weights; *wx >= 0; wx++) {
183  for (ox = offsets; *ox >= 0; ox++) {
184  randomize_buffers();
185  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
186  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
187  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
188  fail();
189  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
190  }
191  }
192  }
193  }
194  }
195  }
196  }
197  }
198  report("qpel_uni_w");
199 }
200 
201 void checkasm_check_hevc_qpel_bi(void)
202 {
203  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
204  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
205  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
206  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
207  LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
208  LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
209 
210  HEVCDSPContext h;
211  int size, bit_depth, i, j;
212  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
213  int16_t *src2,
214  int height, intptr_t mx, intptr_t my, int width);
215 
216  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
217  ff_hevc_dsp_init(&h, bit_depth);
218 
219  for (i = 0; i < 2; i++) {
220  for (j = 0; j < 2; j++) {
221  for (size = 1; size < 10; size++) {
222  const char *type;
223  switch ((j << 1) | i) {
224  case 0: type = "pel_bi_pixels"; break; // 0 0
225  case 1: type = "qpel_bi_h"; break; // 0 1
226  case 2: type = "qpel_bi_v"; break; // 1 0
227  case 3: type = "qpel_bi_hv"; break; // 1 1
228  }
229 
230  if (check_func(h.put_hevc_qpel_bi[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
231  randomize_buffers_ref();
232  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, ref0, sizes[size], i, j, sizes[size]);
233  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], i, j, sizes[size]);
234  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
235  fail();
236  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], i, j, sizes[size]);
237  }
238  }
239  }
240  }
241  }
242  report("qpel_bi");
243 }
244 
245 void checkasm_check_hevc_qpel_bi_w(void)
246 {
247  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
248  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
249  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
250  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
251  LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
252  LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
253 
254  HEVCDSPContext h;
255  int size, bit_depth, i, j;
256  const int *denom, *wx, *ox;
257  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
258  int16_t *src2,
259  int height, int denom, int wx0, int wx1,
260  int ox0, int ox1, intptr_t mx, intptr_t my, int width);
261 
262  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
263  ff_hevc_dsp_init(&h, bit_depth);
264 
265  for (i = 0; i < 2; i++) {
266  for (j = 0; j < 2; j++) {
267  for (size = 1; size < 10; size++) {
268  const char *type;
269  switch ((j << 1) | i) {
270  case 0: type = "pel_bi_w_pixels"; break; // 0 0
271  case 1: type = "qpel_bi_w_h"; break; // 0 1
272  case 2: type = "qpel_bi_w_v"; break; // 1 0
273  case 3: type = "qpel_bi_w_hv"; break; // 1 1
274  }
275 
276  if (check_func(h.put_hevc_qpel_bi_w[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
277  for (denom = denoms; *denom >= 0; denom++) {
278  for (wx = weights; *wx >= 0; wx++) {
279  for (ox = offsets; *ox >= 0; ox++) {
280  randomize_buffers_ref();
281  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, ref0, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
282  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
283  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
284  fail();
285  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
286  }
287  }
288  }
289  }
290  }
291  }
292  }
293  }
294  report("qpel_bi_w");
295 }
296 
297 void checkasm_check_hevc_epel(void)
298 {
299  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
300  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
301  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
302  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
303 
304  HEVCDSPContext h;
305  int size, bit_depth, i, j, row;
306  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, int16_t *dst, uint8_t *src, ptrdiff_t srcstride,
307  int height, intptr_t mx, intptr_t my, int width);
308 
309  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
310  ff_hevc_dsp_init(&h, bit_depth);
311 
312  for (i = 0; i < 2; i++) {
313  for (j = 0; j < 2; j++) {
314  for (size = 1; size < 10; size++) {
315  const char *type;
316  switch ((j << 1) | i) {
317  case 0: type = "pel_pixels"; break; // 0 0
318  case 1: type = "epel_h"; break; // 0 1
319  case 2: type = "epel_v"; break; // 1 0
320  case 3: type = "epel_hv"; break; // 1 1
321  }
322 
323  if (check_func(h.put_hevc_epel[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
324  int16_t *dstw0 = (int16_t *) dst0, *dstw1 = (int16_t *) dst1;
325  randomize_buffers();
326  call_ref(dstw0, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
327  call_new(dstw1, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
328  for (row = 0; row < size[sizes]; row++) {
329  if (memcmp(dstw0 + row * MAX_PB_SIZE, dstw1 + row * MAX_PB_SIZE, sizes[size] * SIZEOF_PIXEL))
330  fail();
331  }
332  bench_new(dstw1, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
333  }
334  }
335  }
336  }
337  }
338  report("epel");
339 }
340 
341 void checkasm_check_hevc_epel_uni(void)
342 {
343  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
344  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
345  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
346  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
347 
348  HEVCDSPContext h;
349  int size, bit_depth, i, j;
350  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
351  int height, intptr_t mx, intptr_t my, int width);
352 
353  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
354  ff_hevc_dsp_init(&h, bit_depth);
355 
356  for (i = 0; i < 2; i++) {
357  for (j = 0; j < 2; j++) {
358  for (size = 1; size < 10; size++) {
359  const char *type;
360  switch ((j << 1) | i) {
361  case 0: type = "pel_uni_pixels"; break; // 0 0
362  case 1: type = "epel_uni_h"; break; // 0 1
363  case 2: type = "epel_uni_v"; break; // 1 0
364  case 3: type = "epel_uni_hv"; break; // 1 1
365  }
366 
367  if (check_func(h.put_hevc_epel_uni[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
368  randomize_buffers();
369  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
370  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
371  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
372  fail();
373  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], i, j, sizes[size]);
374  }
375  }
376  }
377  }
378  }
379  report("epel_uni");
380 }
381 
382 void checkasm_check_hevc_epel_uni_w(void)
383 {
384  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
385  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
386  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
387  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
388 
389  HEVCDSPContext h;
390  int size, bit_depth, i, j;
391  const int *denom, *wx, *ox;
392  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
393  int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width);
394 
395  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
396  ff_hevc_dsp_init(&h, bit_depth);
397 
398  for (i = 0; i < 2; i++) {
399  for (j = 0; j < 2; j++) {
400  for (size = 1; size < 10; size++) {
401  const char *type;
402  switch ((j << 1) | i) {
403  case 0: type = "pel_uni_w_pixels"; break; // 0 0
404  case 1: type = "epel_uni_w_h"; break; // 0 1
405  case 2: type = "epel_uni_w_v"; break; // 1 0
406  case 3: type = "epel_uni_w_hv"; break; // 1 1
407  }
408 
409  if (check_func(h.put_hevc_epel_uni_w[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
410  for (denom = denoms; *denom >= 0; denom++) {
411  for (wx = weights; *wx >= 0; wx++) {
412  for (ox = offsets; *ox >= 0; ox++) {
413  randomize_buffers();
414  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
415  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
416  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
417  fail();
418  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, sizes[size], *denom, *wx, *ox, i, j, sizes[size]);
419  }
420  }
421  }
422  }
423  }
424  }
425  }
426  }
427  report("epel_uni_w");
428 }
429 
430 void checkasm_check_hevc_epel_bi(void)
431 {
432  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
433  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
434  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
435  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
436  LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
437  LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
438 
439  HEVCDSPContext h;
440  int size, bit_depth, i, j;
441  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
442  int16_t *src2,
443  int height, intptr_t mx, intptr_t my, int width);
444 
445  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
446  ff_hevc_dsp_init(&h, bit_depth);
447 
448  for (i = 0; i < 2; i++) {
449  for (j = 0; j < 2; j++) {
450  for (size = 1; size < 10; size++) {
451  const char *type;
452  switch ((j << 1) | i) {
453  case 0: type = "pel_bi_pixels"; break; // 0 0
454  case 1: type = "epel_bi_h"; break; // 0 1
455  case 2: type = "epel_bi_v"; break; // 1 0
456  case 3: type = "epel_bi_hv"; break; // 1 1
457  }
458 
459  if (check_func(h.put_hevc_epel_bi[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
460  randomize_buffers_ref();
461  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, ref0, sizes[size], i, j, sizes[size]);
462  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], i, j, sizes[size]);
463  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
464  fail();
465  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], i, j, sizes[size]);
466  }
467  }
468  }
469  }
470  }
471  report("epel_bi");
472 }
473 
474 void checkasm_check_hevc_epel_bi_w(void)
475 {
476  LOCAL_ALIGNED_32(uint8_t, buf0, [BUF_SIZE]);
477  LOCAL_ALIGNED_32(uint8_t, buf1, [BUF_SIZE]);
478  LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
479  LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
480  LOCAL_ALIGNED_32(int16_t, ref0, [BUF_SIZE]);
481  LOCAL_ALIGNED_32(int16_t, ref1, [BUF_SIZE]);
482 
483  HEVCDSPContext h;
484  int size, bit_depth, i, j;
485  const int *denom, *wx, *ox;
486  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
487  int16_t *src2,
488  int height, int denom, int wx0, int wx1,
489  int ox0, int ox1, intptr_t mx, intptr_t my, int width);
490 
491  for (bit_depth = 8; bit_depth <= 12; bit_depth++) {
492  ff_hevc_dsp_init(&h, bit_depth);
493 
494  for (i = 0; i < 2; i++) {
495  for (j = 0; j < 2; j++) {
496  for (size = 1; size < 10; size++) {
497  const char *type;
498  switch ((j << 1) | i) {
499  case 0: type = "pel_bi_w_pixels"; break; // 0 0
500  case 1: type = "epel_bi_w_h"; break; // 0 1
501  case 2: type = "epel_bi_w_v"; break; // 1 0
502  case 3: type = "epel_bi_w_hv"; break; // 1 1
503  }
504 
505  if (check_func(h.put_hevc_epel_bi_w[size][j][i], "put_hevc_%s%d_%d", type, sizes[size], bit_depth)) {
506  for (denom = denoms; *denom >= 0; denom++) {
507  for (wx = weights; *wx >= 0; wx++) {
508  for (ox = offsets; *ox >= 0; ox++) {
509  randomize_buffers_ref();
510  call_ref(dst0, sizes[size] * SIZEOF_PIXEL, src0, sizes[size] * SIZEOF_PIXEL, ref0, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
511  call_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
512  if (memcmp(dst0, dst1, sizes[size] * sizes[size] * SIZEOF_PIXEL))
513  fail();
514  bench_new(dst1, sizes[size] * SIZEOF_PIXEL, src1, sizes[size] * SIZEOF_PIXEL, ref1, sizes[size], *denom, *wx, *wx, *ox, *ox, i, j, sizes[size]);
515  }
516  }
517  }
518  }
519  }
520  }
521  }
522  }
523  report("epel_bi_w");
524 }
declare_func_emms
#define declare_func_emms(cpu_flags, ret,...)
Definition: checkasm.h:130
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
src0
#define src0
Definition: hevc_pel.c:65
pixel_mask16
static const uint32_t pixel_mask16[]
Definition: hevc_pel.c:30
check_func
#define check_func(func,...)
Definition: checkasm.h:124
checkasm_check_hevc_qpel_bi
void checkasm_check_hevc_qpel_bi(void)
Definition: hevc_pel.c:201
call_ref
#define call_ref(...)
Definition: checkasm.h:139
fail
#define fail()
Definition: checkasm.h:133
checkasm.h
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
checkasm_check_hevc_epel_bi_w
void checkasm_check_hevc_epel_bi_w(void)
Definition: hevc_pel.c:474
checkasm_check_hevc_epel_uni
void checkasm_check_hevc_epel_uni(void)
Definition: hevc_pel.c:341
width
#define width
intreadwrite.h
offsets
static const int offsets[]
Definition: hevc_pel.c:34
SIZEOF_PIXEL
#define SIZEOF_PIXEL
Definition: hevc_pel.c:36
hevcdsp.h
call_new
#define call_new(...)
Definition: checkasm.h:211
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
src
#define src
Definition: vp8dsp.c:255
checkasm_check_hevc_qpel_uni_w
void checkasm_check_hevc_qpel_uni_w(void)
Definition: hevc_pel.c:153
checkasm_check_hevc_qpel_uni
void checkasm_check_hevc_qpel_uni(void)
Definition: hevc_pel.c:112
size
int size
Definition: twinvq_data.h:10344
checkasm_check_hevc_epel_bi
void checkasm_check_hevc_epel_bi(void)
Definition: hevc_pel.c:430
height
#define height
HEVCDSPContext
Definition: hevcdsp.h:47
report
#define report
Definition: checkasm.h:136
i
int i
Definition: input.c:407
bench_new
#define bench_new(...)
Definition: checkasm.h:271
internal.h
MAX_PB_SIZE
#define MAX_PB_SIZE
Definition: hevcdsp.h:32
weights
static const int weights[]
Definition: hevc_pel.c:32
common.h
uint8_t
uint8_t
Definition: audio_convert.c:194
checkasm_check_hevc_qpel
void checkasm_check_hevc_qpel(void)
Definition: hevc_pel.c:68
ff_hevc_dsp_init
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition: hevcdsp.c:126
randomize_buffers_ref
#define randomize_buffers_ref()
Definition: hevc_pel.c:53
pixel_mask
static const uint32_t pixel_mask[]
Definition: hevc_pel.c:29
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:31
denoms
static const int denoms[]
Definition: hevc_pel.c:33
checkasm_check_hevc_qpel_bi_w
void checkasm_check_hevc_qpel_bi_w(void)
Definition: hevc_pel.c:245
checkasm_check_hevc_epel_uni_w
void checkasm_check_hevc_epel_uni_w(void)
Definition: hevc_pel.c:382
AV_CPU_FLAG_MMXEXT
#define AV_CPU_FLAG_MMXEXT
SSE integer functions or AMD MMX ext.
Definition: cpu.h:32
BUF_SIZE
#define BUF_SIZE
Definition: hevc_pel.c:37
sizes
static const int sizes[]
Definition: hevc_pel.c:31
src1
#define src1
Definition: hevc_pel.c:66
h
h
Definition: vp9dsp_template.c:2038
checkasm_check_hevc_epel
void checkasm_check_hevc_epel(void)
Definition: hevc_pel.c:297
randomize_buffers
#define randomize_buffers()
Definition: hevc_pel.c:39
Generated on Wed Aug 24 2022 21:34:54 for FFmpeg by   doxygen 1.8.17