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  struct SwsContext *ctx;
67  const AVPixFmtDescriptor *desc;
68  int fmi, fsi, isi, i;
69  int dstW, byte_size, luma_filter_size, chr_filter_size;
70 #define LARGEST_FILTER 16
71 #define FILTER_SIZES 4
72  static const int filter_sizes[] = {1, 4, 8, 16};
73 #define LARGEST_INPUT_SIZE 512
74 #define INPUT_SIZES 6
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, struct SwsContext *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  ctx = sws_alloc_context();
134  if (sws_init_context(ctx, NULL, NULL) < 0)
135  fail();
136 
137  ctx->flags |= SWS_FULL_CHR_H_INT;
138 
139  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
140  for (fsi = 0; fsi < FILTER_SIZES; fsi++) {
141  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
142  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
143  ctx->dstFormat = planar_fmts[fmi];
144 
145  dstW = input_sizes[isi];
146  luma_filter_size = filter_sizes[fsi];
147  chr_filter_size = filter_sizes[fsi];
148 
149  if (desc->comp[0].depth > 16) {
150  byte_size = 4;
151  } else if (desc->comp[0].depth > 8) {
152  byte_size = 2;
153  } else {
154  byte_size = 1;
155  }
156 
157  ff_sws_init_scale(ctx);
158  if (check_func(ctx->yuv2anyX, "yuv2%s_full_X_%d_%d", desc->name, luma_filter_size, dstW)) {
159  for (i = 0; i < 4; i ++) {
160  memset(dst0[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
161  memset(dst1[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
162  }
163 
164  call_ref(ctx, luma_filter, luma, luma_filter_size,
165  chr_filter, chru, chrv, chr_filter_size,
166  alpha, dst0, dstW, 0);
167  call_new(ctx, luma_filter, luma, luma_filter_size,
168  chr_filter, chru, chrv, chr_filter_size,
169  alpha, dst1, dstW, 0);
170 
171  if (memcmp(dst0[0], dst1[0], dstW * byte_size) ||
172  memcmp(dst0[1], dst1[1], dstW * byte_size) ||
173  memcmp(dst0[2], dst1[2], dstW * byte_size) ||
174  memcmp(dst0[3], dst1[3], dstW * byte_size) )
175  fail();
176 
177  bench_new(ctx, luma_filter, luma, luma_filter_size,
178  chr_filter, chru, chrv, chr_filter_size,
179  alpha, dst1, dstW, 0);
180  }
181  }
182  }
183  }
184  sws_freeContext(ctx);
185 }
186 
187 #undef LARGEST_INPUT_SIZE
188 #undef INPUT_SIZES
189 
190 static void check_input_planar_rgb_to_y(void)
191 {
192  struct SwsContext *ctx;
193  const AVPixFmtDescriptor *desc;
194  int fmi, isi;
195  int dstW, byte_size;
196 #define LARGEST_INPUT_SIZE 512
197 #define INPUT_SIZES 6
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  ctx = sws_alloc_context();
225  if (sws_init_context(ctx, NULL, NULL) < 0)
226  fail();
227 
228  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
229  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
230  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
231  ctx->srcFormat = planar_fmts[fmi];
232  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
233  byte_size = 2;
234  dstW = input_sizes[isi];
235 
236  ff_sws_init_scale(ctx);
237  if(check_func(ctx->readLumPlanar, "planar_%s_to_y_%d", desc->name, dstW)) {
238  memset(dst0_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
239  memset(dst1_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
240 
241  call_ref(dst0_y, src, dstW, rgb2yuv, NULL);
242  call_new(dst1_y, src, dstW, rgb2yuv, NULL);
243 
244  if (memcmp(dst0_y, dst1_y, dstW * byte_size))
245  fail();
246 
247  bench_new(dst1_y, src, dstW, rgb2yuv, NULL);
248 
249  }
250  }
251  }
252  sws_freeContext(ctx);
253 }
254 
255 #undef LARGEST_INPUT_SIZE
256 #undef INPUT_SIZES
257 
258 static void check_input_planar_rgb_to_uv(void)
259 {
260  struct SwsContext *ctx;
261  const AVPixFmtDescriptor *desc;
262  int fmi, isi;
263  int dstW, byte_size;
264 #define LARGEST_INPUT_SIZE 512
265 #define INPUT_SIZES 6
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  ctx = sws_alloc_context();
296  if (sws_init_context(ctx, NULL, NULL) < 0)
297  fail();
298 
299  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
300  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
301  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
302  ctx->srcFormat = planar_fmts[fmi];
303  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
304  byte_size = 2;
305  dstW = input_sizes[isi];
306 
307  ff_sws_init_scale(ctx);
308  if(check_func(ctx->readChrPlanar, "planar_%s_to_uv_%d", desc->name, dstW)) {
309  memset(dst0_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
310  memset(dst0_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
311  memset(dst1_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
312  memset(dst1_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
313 
314  call_ref(dst0_u, dst0_v, src, dstW, rgb2yuv, NULL);
315  call_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
316 
317  if (memcmp(dst0_u, dst1_u, dstW * byte_size) ||
318  memcmp(dst0_v, dst1_v, dstW * byte_size))
319  fail();
320 
321  bench_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
322  }
323  }
324  }
325  sws_freeContext(ctx);
326 }
327 
328 #undef LARGEST_INPUT_SIZE
329 #undef INPUT_SIZES
330 
331 static void check_input_planar_rgb_to_a(void)
332 {
333  struct SwsContext *ctx;
334  const AVPixFmtDescriptor *desc;
335  int fmi, isi;
336  int dstW, byte_size;
337 #define LARGEST_INPUT_SIZE 512
338 #define INPUT_SIZES 6
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  ctx = sws_alloc_context();
366  if (sws_init_context(ctx, NULL, NULL) < 0)
367  fail();
368 
369  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
370  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
371  desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
372  if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))
373  continue;
374 
375  ctx->srcFormat = planar_fmts[fmi];
376  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
377  byte_size = 2;
378  dstW = input_sizes[isi];
379 
380  ff_sws_init_scale(ctx);
381  if(check_func(ctx->readAlpPlanar, "planar_%s_to_a_%d", desc->name, dstW)) {
382  memset(dst0_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
383  memset(dst1_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
384 
385  call_ref(dst0_a, src, dstW, rgb2yuv, NULL);
386  call_new(dst1_a, src, dstW, rgb2yuv, NULL);
387 
388  if (memcmp(dst0_a, dst1_a, dstW * byte_size))
389  fail();
390  bench_new(dst1_a, src, dstW, rgb2yuv, NULL);
391  }
392  }
393  }
394  sws_freeContext(ctx);
395 }
396 
397 void checkasm_check_sw_gbrp(void)
398 {
399  check_output_yuv2gbrp();
400  report("output_yuv2gbrp");
401 
402  check_input_planar_rgb_to_y();
403  report("input_planar_rgb_y");
404 
405  check_input_planar_rgb_to_uv();
406  report("input_planar_rgb_uv");
407 
408  check_input_planar_rgb_to_a();
409  report("input_planar_rgb_a");
410 }
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:514
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:2965
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:179
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:69
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:194
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:188
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:523
checkasm.h
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:397
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
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1451
input_sizes
static const int input_sizes[]
Definition: sw_rgb.c:346
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
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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:144
call_new
#define call_new(...)
Definition: checkasm.h:297
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
sws_alloc_context
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1217
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
ff_sws_init_scale
void ff_sws_init_scale(SwsContext *c)
Definition: swscale.c:591
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
SWS_FULL_CHR_H_INT
#define SWS_FULL_CHR_H_INT
Perform full chroma upsampling when upscaling to RGB.
Definition: swscale.h:97
INPUT_SIZES
#define INPUT_SIZES
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
report
#define report
Definition: checkasm.h:191
bench_new
#define bench_new(...)
Definition: checkasm.h:368
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
sws_init_context
av_warn_unused_result int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:2068
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
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2432
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
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:183
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
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
SwsContext
Definition: swscale_internal.h:299
src
#define src
Definition: vp8dsp.c:248
swscale.h
Generated on Fri Oct 4 2024 19:23:01 for FFmpeg by   doxygen 1.8.17