FFmpeg
sw_gbrp.c
Go to the documentation of this file.
1 /*
2  *
3  * This file is part of FFmpeg.
4  *
5  * FFmpeg is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * FFmpeg is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 
20 #include <string.h>
21 
22 #include "libavutil/common.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/mem_internal.h"
25 #include "libavutil/pixdesc.h"
26 
27 #include "libswscale/swscale.h"
28 #include "libswscale/swscale_internal.h"
29 
30 #include "checkasm.h"
31 
32 #define randomize_buffers(buf, size) \
33  do { \
34  int j; \
35  for (j = 0; j < size; j+=4) \
36  AV_WN32(buf + j, rnd()); \
37  } while (0)
38 
39 static const int planar_fmts[] = {
40  AV_PIX_FMT_GBRP,
41  AV_PIX_FMT_GBRP9BE,
42  AV_PIX_FMT_GBRP9LE,
43  AV_PIX_FMT_GBRP10BE,
44  AV_PIX_FMT_GBRP10LE,
45  AV_PIX_FMT_GBRP12BE,
46  AV_PIX_FMT_GBRP12LE,
47  AV_PIX_FMT_GBRP14BE,
48  AV_PIX_FMT_GBRP14LE,
49  AV_PIX_FMT_GBRAP,
50  AV_PIX_FMT_GBRAP10BE,
51  AV_PIX_FMT_GBRAP10LE,
52  AV_PIX_FMT_GBRAP12BE,
53  AV_PIX_FMT_GBRAP12LE,
54  AV_PIX_FMT_GBRP16BE,
55  AV_PIX_FMT_GBRP16LE,
56  AV_PIX_FMT_GBRAP16BE,
57  AV_PIX_FMT_GBRAP16LE,
58  AV_PIX_FMT_GBRPF32BE,
59  AV_PIX_FMT_GBRPF32LE,
60  AV_PIX_FMT_GBRAPF32BE,
61  AV_PIX_FMT_GBRAPF32LE
62 };
63 
64 static void check_output_yuv2gbrp(void)
65 {
66  SwsContext *sws;
67  SwsInternal *c;
68  const AVPixFmtDescriptor *desc;
69  int fmi, fsi, isi, i;
70  int dstW, byte_size, luma_filter_size, chr_filter_size;
71 #define LARGEST_FILTER 16
72 #define FILTER_SIZES 4
73  static const int filter_sizes[] = {1, 4, 8, 16};
74 #define LARGEST_INPUT_SIZE 512
75  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
76  uint8_t *dst0[4];
77  uint8_t *dst1[4];
78 
79  declare_func(void, SwsInternal *c, const int16_t *lumFilter,
80  const int16_t **lumSrcx, int lumFilterSize,
81  const int16_t *chrFilter, const int16_t **chrUSrcx,
82  const int16_t **chrVSrcx, int chrFilterSize,
83  const int16_t **alpSrcx, uint8_t **dest,
84  int dstW, int y);
85 
86  const int16_t *luma[LARGEST_FILTER];
87  const int16_t *chru[LARGEST_FILTER];
88  const int16_t *chrv[LARGEST_FILTER];
89  const int16_t *alpha[LARGEST_FILTER];
90 
91  LOCAL_ALIGNED_8(int16_t, luma_filter, [LARGEST_FILTER]);
92  LOCAL_ALIGNED_8(int16_t, chr_filter, [LARGEST_FILTER]);
93 
94  LOCAL_ALIGNED_8(int32_t, src_y, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);
95  LOCAL_ALIGNED_8(int32_t, src_u, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);
96  LOCAL_ALIGNED_8(int32_t, src_v, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);
97  LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);
98 
99  LOCAL_ALIGNED_8(uint8_t, dst0_r, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
100  LOCAL_ALIGNED_8(uint8_t, dst0_g, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
101  LOCAL_ALIGNED_8(uint8_t, dst0_b, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
102  LOCAL_ALIGNED_8(uint8_t, dst0_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
103 
104  LOCAL_ALIGNED_8(uint8_t, dst1_r, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
105  LOCAL_ALIGNED_8(uint8_t, dst1_g, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
106  LOCAL_ALIGNED_8(uint8_t, dst1_b, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
107  LOCAL_ALIGNED_8(uint8_t, dst1_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
108 
109  randomize_buffers((uint8_t*)src_y, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));
110  randomize_buffers((uint8_t*)src_u, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));
111  randomize_buffers((uint8_t*)src_v, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));
112  randomize_buffers((uint8_t*)src_a, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));
113  randomize_buffers((uint8_t*)luma_filter, LARGEST_FILTER * sizeof(int16_t));
114  randomize_buffers((uint8_t*)chr_filter, LARGEST_FILTER * sizeof(int16_t));
115 
116  dst0[0] = (uint8_t*)dst0_g;
117  dst0[1] = (uint8_t*)dst0_b;
118  dst0[2] = (uint8_t*)dst0_r;
119  dst0[3] = (uint8_t*)dst0_a;
120 
121  dst1[0] = (uint8_t*)dst1_g;
122  dst1[1] = (uint8_t*)dst1_b;
123  dst1[2] = (uint8_t*)dst1_r;
124  dst1[3] = (uint8_t*)dst1_a;
125 
126  for (i = 0; i < LARGEST_FILTER; i++) {
127  luma[i] = (int16_t *)(src_y + i*LARGEST_INPUT_SIZE);
128  chru[i] = (int16_t *)(src_u + i*LARGEST_INPUT_SIZE);
129  chrv[i] = (int16_t *)(src_v + i*LARGEST_INPUT_SIZE);
130  alpha[i] = (int16_t *)(src_a + i*LARGEST_INPUT_SIZE);
131  }
132 
133  sws = sws_alloc_context();
134  if (sws_init_context(sws, NULL, NULL) < 0)
135  fail();
136 
137  c = sws_internal(sws);
138  sws->flags |= SWS_FULL_CHR_H_INT;
139 
140  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
141  for (fsi = 0; fsi < FILTER_SIZES; fsi++) {
142  for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
143  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
144  sws->dst_format = planar_fmts[fmi];
145 
146  dstW = input_sizes[isi];
147  luma_filter_size = filter_sizes[fsi];
148  chr_filter_size = filter_sizes[fsi];
149 
150  if (desc->comp[0].depth > 16) {
151  byte_size = 4;
152  } else if (desc->comp[0].depth > 8) {
153  byte_size = 2;
154  } else {
155  byte_size = 1;
156  }
157 
158  ff_sws_init_scale(c);
159  if (check_func(c->yuv2anyX, "yuv2%s_full_X_%d_%d", desc->name, luma_filter_size, dstW)) {
160  for (i = 0; i < 4; i ++) {
161  memset(dst0[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
162  memset(dst1[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
163  }
164 
165  call_ref(c, luma_filter, luma, luma_filter_size,
166  chr_filter, chru, chrv, chr_filter_size,
167  alpha, dst0, dstW, 0);
168  call_new(c, luma_filter, luma, luma_filter_size,
169  chr_filter, chru, chrv, chr_filter_size,
170  alpha, dst1, dstW, 0);
171 
172  if (memcmp(dst0[0], dst1[0], dstW * byte_size) ||
173  memcmp(dst0[1], dst1[1], dstW * byte_size) ||
174  memcmp(dst0[2], dst1[2], dstW * byte_size) ||
175  memcmp(dst0[3], dst1[3], dstW * byte_size) )
176  fail();
177 
178  bench_new(c, luma_filter, luma, luma_filter_size,
179  chr_filter, chru, chrv, chr_filter_size,
180  alpha, dst1, dstW, 0);
181  }
182  }
183  }
184  }
185  sws_freeContext(sws);
186 }
187 
188 #undef LARGEST_INPUT_SIZE
189 
190 static void check_input_planar_rgb_to_y(void)
191 {
192  SwsContext *sws;
193  SwsInternal *c;
194  const AVPixFmtDescriptor *desc;
195  int fmi, isi;
196  int dstW, byte_size;
197 #define LARGEST_INPUT_SIZE 512
198  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
199  const uint8_t *src[4];
200  int32_t rgb2yuv[9] = {0};
201 
202  declare_func(void, uint8_t *dst, const uint8_t *src[4],
203  int w, int32_t *rgb2yuv, void *opaque);
204 
205  LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);
206  LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);
207  LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);
208  LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);
209 
210  LOCAL_ALIGNED_8(uint8_t, dst0_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
211  LOCAL_ALIGNED_8(uint8_t, dst1_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
212 
213  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
214  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
215  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
216  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
217  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
218 
219  src[0] = (uint8_t*)src_g;
220  src[1] = (uint8_t*)src_b;
221  src[2] = (uint8_t*)src_r;
222  src[3] = (uint8_t*)src_a;
223 
224  sws = sws_alloc_context();
225  if (sws_init_context(sws, NULL, NULL) < 0)
226  fail();
227 
228  c = sws_internal(sws);
229  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
230  for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
231  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
232  sws->src_format = planar_fmts[fmi];
233  sws->dst_format = AV_PIX_FMT_YUVA444P16;
234  byte_size = 2;
235  dstW = input_sizes[isi];
236 
237  ff_sws_init_scale(c);
238  if(check_func(c->readLumPlanar, "planar_%s_to_y_%d", desc->name, dstW)) {
239  memset(dst0_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
240  memset(dst1_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
241 
242  call_ref(dst0_y, src, dstW, rgb2yuv, NULL);
243  call_new(dst1_y, src, dstW, rgb2yuv, NULL);
244 
245  if (memcmp(dst0_y, dst1_y, dstW * byte_size))
246  fail();
247 
248  bench_new(dst1_y, src, dstW, rgb2yuv, NULL);
249 
250  }
251  }
252  }
253  sws_freeContext(sws);
254 }
255 
256 #undef LARGEST_INPUT_SIZE
257 
258 static void check_input_planar_rgb_to_uv(void)
259 {
260  SwsContext *sws;
261  SwsInternal *c;
262  const AVPixFmtDescriptor *desc;
263  int fmi, isi;
264  int dstW, byte_size;
265 #define LARGEST_INPUT_SIZE 512
266  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
267  const uint8_t *src[4];
268  int32_t rgb2yuv[9] = {0};
269 
270  declare_func(void, uint8_t *dstU, uint8_t *dstV,
271  const uint8_t *src[4], int w, int32_t *rgb2yuv, void *opaque);
272 
273  LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);
274  LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);
275  LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);
276  LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);
277 
278  LOCAL_ALIGNED_8(uint8_t, dst0_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
279  LOCAL_ALIGNED_8(uint8_t, dst0_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
280 
281  LOCAL_ALIGNED_8(uint8_t, dst1_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
282  LOCAL_ALIGNED_8(uint8_t, dst1_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
283 
284  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
285  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
286  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
287  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
288  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
289 
290  src[0] = (uint8_t*)src_g;
291  src[1] = (uint8_t*)src_b;
292  src[2] = (uint8_t*)src_r;
293  src[3] = (uint8_t*)src_a;
294 
295  sws = sws_alloc_context();
296  if (sws_init_context(sws, NULL, NULL) < 0)
297  fail();
298 
299  c = sws_internal(sws);
300  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
301  for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
302  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
303  sws->src_format = planar_fmts[fmi];
304  sws->dst_format = AV_PIX_FMT_YUVA444P16;
305  byte_size = 2;
306  dstW = input_sizes[isi];
307 
308  ff_sws_init_scale(c);
309  if(check_func(c->readChrPlanar, "planar_%s_to_uv_%d", desc->name, dstW)) {
310  memset(dst0_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
311  memset(dst0_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
312  memset(dst1_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
313  memset(dst1_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
314 
315  call_ref(dst0_u, dst0_v, src, dstW, rgb2yuv, NULL);
316  call_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
317 
318  if (memcmp(dst0_u, dst1_u, dstW * byte_size) ||
319  memcmp(dst0_v, dst1_v, dstW * byte_size))
320  fail();
321 
322  bench_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
323  }
324  }
325  }
326  sws_freeContext(sws);
327 }
328 
329 #undef LARGEST_INPUT_SIZE
330 
331 static void check_input_planar_rgb_to_a(void)
332 {
333  SwsContext *sws;
334  SwsInternal *c;
335  const AVPixFmtDescriptor *desc;
336  int fmi, isi;
337  int dstW, byte_size;
338 #define LARGEST_INPUT_SIZE 512
339  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
340  const uint8_t *src[4];
341  int32_t rgb2yuv[9] = {0};
342 
343  declare_func(void, uint8_t *dst, const uint8_t *src[4],
344  int w, int32_t *rgb2yuv, void *opaque);
345 
346  LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);
347  LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);
348  LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);
349  LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);
350 
351  LOCAL_ALIGNED_8(uint8_t, dst0_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
352  LOCAL_ALIGNED_8(uint8_t, dst1_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
353 
354  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
355  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
356  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
357  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
358  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
359 
360  src[0] = (uint8_t*)src_g;
361  src[1] = (uint8_t*)src_b;
362  src[2] = (uint8_t*)src_r;
363  src[3] = (uint8_t*)src_a;
364 
365  sws = sws_alloc_context();
366  if (sws_init_context(sws, NULL, NULL) < 0)
367  fail();
368 
369  c = sws_internal(sws);
370  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
371  for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
372  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
373  if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))
374  continue;
375 
376  sws->src_format = planar_fmts[fmi];
377  sws->dst_format = AV_PIX_FMT_YUVA444P16;
378  byte_size = 2;
379  dstW = input_sizes[isi];
380 
381  ff_sws_init_scale(c);
382  if(check_func(c->readAlpPlanar, "planar_%s_to_a_%d", desc->name, dstW)) {
383  memset(dst0_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
384  memset(dst1_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
385 
386  call_ref(dst0_a, src, dstW, rgb2yuv, NULL);
387  call_new(dst1_a, src, dstW, rgb2yuv, NULL);
388 
389  if (memcmp(dst0_a, dst1_a, dstW * byte_size))
390  fail();
391  bench_new(dst1_a, src, dstW, rgb2yuv, NULL);
392  }
393  }
394  }
395  sws_freeContext(sws);
396 }
397 
398 void checkasm_check_sw_gbrp(void)
399 {
400  check_output_yuv2gbrp();
401  report("output_yuv2gbrp");
402 
403  check_input_planar_rgb_to_y();
404  report("input_planar_rgb_y");
405 
406  check_input_planar_rgb_to_uv();
407  report("input_planar_rgb_uv");
408 
409  check_input_planar_rgb_to_a();
410  report("input_planar_rgb_a");
411 }
mem_internal.h
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
sws_freeContext
void sws_freeContext(SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2450
pixdesc.h
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
w
uint8_t w
Definition: llviddspenc.c:38
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
check_func
#define check_func(func,...)
Definition: checkasm.h:184
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:69
SwsContext::flags
unsigned flags
Bitmask of SWS_*.
Definition: swscale.h:195
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
LARGEST_FILTER
#define LARGEST_FILTER
call_ref
#define call_ref(...)
Definition: checkasm.h:199
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:311
planar_fmts
static const int planar_fmts[]
Definition: sw_gbrp.c:39
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
fail
#define fail()
Definition: checkasm.h:193
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:547
checkasm.h
sws_init_context
av_warn_unused_result int sws_init_context(SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:2085
check_output_yuv2gbrp
static void check_output_yuv2gbrp(void)
Definition: sw_gbrp.c:64
checkasm_check_sw_gbrp
void checkasm_check_sw_gbrp(void)
Definition: sw_gbrp.c:398
FILTER_SIZES
#define FILTER_SIZES
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
randomize_buffers
#define randomize_buffers(buf, size)
Definition: sw_gbrp.c:32
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
intreadwrite.h
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:172
input_sizes
static const int input_sizes[]
Definition: sw_rgb.c:347
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:280
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:170
check_input_planar_rgb_to_y
static void check_input_planar_rgb_to_y(void)
Definition: sw_gbrp.c:190
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition: mem_internal.h:128
call_new
#define call_new(...)
Definition: checkasm.h:302
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:310
NULL
#define NULL
Definition: coverity.c:32
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
check_input_planar_rgb_to_uv
static void check_input_planar_rgb_to_uv(void)
Definition: sw_gbrp.c:258
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext and set its fields to default values.
Definition: utils.c:1230
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
LARGEST_INPUT_SIZE
#define LARGEST_INPUT_SIZE
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:314
SwsContext::dst_format
int dst_format
Destination pixel format.
Definition: swscale.h:231
sws
static SwsContext * sws[3]
Definition: swscale.c:69
report
#define report
Definition: checkasm.h:196
bench_new
#define bench_new(...)
Definition: checkasm.h:373
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_sws_init_scale
void ff_sws_init_scale(SwsInternal *c)
Definition: swscale.c:691
common.h
swscale_internal.h
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
SwsInternal
Definition: swscale_internal.h:317
SWS_FULL_CHR_H_INT
@ SWS_FULL_CHR_H_INT
Perform full chroma upsampling when upscaling to RGB.
Definition: swscale.h:132
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:279
check_input_planar_rgb_to_a
static void check_input_planar_rgb_to_a(void)
Definition: sw_gbrp.c:331
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
SwsContext::src_format
int src_format
Source pixel format.
Definition: swscale.h:230
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
declare_func
#define declare_func(ret,...)
Definition: checkasm.h:188
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
int32_t
int32_t
Definition: audioconvert.c:56
sws_internal
static SwsInternal * sws_internal(const SwsContext *sws)
Definition: swscale_internal.h:74
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
SwsContext
Main external API structure.
Definition: swscale.h:182
src
#define src
Definition: vp8dsp.c:248
swscale.h
Generated on Tue Dec 24 2024 19:23:09 for FFmpeg by   doxygen 1.8.17