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"
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[] = {
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 
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 
134  if (sws_init_context(ctx, NULL, NULL) < 0)
135  fail();
136 
138  ctx->yuv2rgb_y_offset = rnd();
139  ctx->yuv2rgb_y_coeff = rnd();
140  ctx->yuv2rgb_v2r_coeff = rnd();
141  ctx->yuv2rgb_v2g_coeff = rnd();
142  ctx->yuv2rgb_u2g_coeff = rnd();
143  ctx->yuv2rgb_u2b_coeff = rnd();
144 
145  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
146  for (fsi = 0; fsi < FILTER_SIZES; fsi++) {
147  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
149  ctx->dstFormat = planar_fmts[fmi];
150 
151  dstW = input_sizes[isi];
152  luma_filter_size = filter_sizes[fsi];
153  chr_filter_size = filter_sizes[fsi];
154 
155  if (desc->comp[0].depth > 16) {
156  byte_size = 4;
157  } else if (desc->comp[0].depth > 8) {
158  byte_size = 2;
159  } else {
160  byte_size = 1;
161  }
162 
164  if (check_func(ctx->yuv2anyX, "yuv2%s_full_X_%d_%d", desc->name, luma_filter_size, dstW)) {
165  for (i = 0; i < 4; i ++) {
166  memset(dst0[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
167  memset(dst1[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
168  }
169 
170  call_ref(ctx, luma_filter, luma, luma_filter_size,
171  chr_filter, chru, chrv, chr_filter_size,
172  alpha, dst0, dstW, 0);
173  call_new(ctx, luma_filter, luma, luma_filter_size,
174  chr_filter, chru, chrv, chr_filter_size,
175  alpha, dst1, dstW, 0);
176 
177  if (memcmp(dst0[0], dst1[0], dstW * byte_size) ||
178  memcmp(dst0[1], dst1[1], dstW * byte_size) ||
179  memcmp(dst0[2], dst1[2], dstW * byte_size) ||
180  memcmp(dst0[3], dst1[3], dstW * byte_size) )
181  fail();
182 
183  bench_new(ctx, luma_filter, luma, luma_filter_size,
184  chr_filter, chru, chrv, chr_filter_size,
185  alpha, dst1, dstW, 0);
186  }
187  }
188  }
189  }
191 }
192 
193 #undef LARGEST_INPUT_SIZE
194 #undef INPUT_SIZES
195 
197 {
198  struct SwsContext *ctx;
199  const AVPixFmtDescriptor *desc;
200  int fmi, isi;
201  int dstW, byte_size;
202 #define LARGEST_INPUT_SIZE 512
203 #define INPUT_SIZES 6
204  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
205  const uint8_t *src[4];
206  int32_t rgb2yuv[9] = {0};
207 
208  declare_func(void, uint8_t *dst, const uint8_t *src[4],
209  int w, int32_t *rgb2yuv, void *opaque);
210 
215 
216  LOCAL_ALIGNED_8(uint8_t, dst0_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
217  LOCAL_ALIGNED_8(uint8_t, dst1_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
218 
219  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
220  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
221  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
222  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
223  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
224 
225  src[0] = (uint8_t*)src_g;
226  src[1] = (uint8_t*)src_b;
227  src[2] = (uint8_t*)src_r;
228  src[3] = (uint8_t*)src_a;
229 
231  if (sws_init_context(ctx, NULL, NULL) < 0)
232  fail();
233 
234  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
235  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
237  ctx->srcFormat = planar_fmts[fmi];
238  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
239  byte_size = 2;
240  dstW = input_sizes[isi];
241 
243  if(check_func(ctx->readLumPlanar, "planar_%s_to_y_%d", desc->name, dstW)) {
244  memset(dst0_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
245  memset(dst1_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
246 
247  call_ref(dst0_y, src, dstW, rgb2yuv, NULL);
248  call_new(dst1_y, src, dstW, rgb2yuv, NULL);
249 
250  if (memcmp(dst0_y, dst1_y, dstW * byte_size))
251  fail();
252 
253  bench_new(dst1_y, src, dstW, rgb2yuv, NULL);
254 
255  }
256  }
257  }
259 }
260 
261 #undef LARGEST_INPUT_SIZE
262 #undef INPUT_SIZES
263 
265 {
266  struct SwsContext *ctx;
267  const AVPixFmtDescriptor *desc;
268  int fmi, isi;
269  int dstW, byte_size;
270 #define LARGEST_INPUT_SIZE 512
271 #define INPUT_SIZES 6
272  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
273  const uint8_t *src[4];
274  int32_t rgb2yuv[9] = {0};
275 
276  declare_func(void, uint8_t *dstU, uint8_t *dstV,
277  const uint8_t *src[4], int w, int32_t *rgb2yuv, void *opaque);
278 
283 
284  LOCAL_ALIGNED_8(uint8_t, dst0_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
285  LOCAL_ALIGNED_8(uint8_t, dst0_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
286 
287  LOCAL_ALIGNED_8(uint8_t, dst1_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
288  LOCAL_ALIGNED_8(uint8_t, dst1_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
289 
290  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
291  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
292  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
293  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
294  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
295 
296  src[0] = (uint8_t*)src_g;
297  src[1] = (uint8_t*)src_b;
298  src[2] = (uint8_t*)src_r;
299  src[3] = (uint8_t*)src_a;
300 
302  if (sws_init_context(ctx, NULL, NULL) < 0)
303  fail();
304 
305  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
306  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
308  ctx->srcFormat = planar_fmts[fmi];
309  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
310  byte_size = 2;
311  dstW = input_sizes[isi];
312 
314  if(check_func(ctx->readChrPlanar, "planar_%s_to_uv_%d", desc->name, dstW)) {
315  memset(dst0_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
316  memset(dst0_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
317  memset(dst1_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
318  memset(dst1_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));
319 
320  call_ref(dst0_u, dst0_v, src, dstW, rgb2yuv, NULL);
321  call_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
322 
323  if (memcmp(dst0_u, dst1_u, dstW * byte_size) ||
324  memcmp(dst0_v, dst1_v, dstW * byte_size))
325  fail();
326 
327  bench_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);
328  }
329  }
330  }
332 }
333 
334 #undef LARGEST_INPUT_SIZE
335 #undef INPUT_SIZES
336 
338 {
339  struct SwsContext *ctx;
340  const AVPixFmtDescriptor *desc;
341  int fmi, isi;
342  int dstW, byte_size;
343 #define LARGEST_INPUT_SIZE 512
344 #define INPUT_SIZES 6
345  static const int input_sizes[] = {8, 24, 128, 144, 256, 512};
346  const uint8_t *src[4];
347  int32_t rgb2yuv[9] = {0};
348 
349  declare_func(void, uint8_t *dst, const uint8_t *src[4],
350  int w, int32_t *rgb2yuv, void *opaque);
351 
356 
357  LOCAL_ALIGNED_8(uint8_t, dst0_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
358  LOCAL_ALIGNED_8(uint8_t, dst1_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);
359 
360  randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));
361  randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));
362  randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));
363  randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));
364  randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));
365 
366  src[0] = (uint8_t*)src_g;
367  src[1] = (uint8_t*)src_b;
368  src[2] = (uint8_t*)src_r;
369  src[3] = (uint8_t*)src_a;
370 
372  if (sws_init_context(ctx, NULL, NULL) < 0)
373  fail();
374 
375  for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
376  for (isi = 0; isi < INPUT_SIZES; isi++ ) {
378  if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))
379  continue;
380 
381  ctx->srcFormat = planar_fmts[fmi];
382  ctx->dstFormat = AV_PIX_FMT_YUVA444P16;
383  byte_size = 2;
384  dstW = input_sizes[isi];
385 
387  if(check_func(ctx->readAlpPlanar, "planar_%s_to_a_%d", desc->name, dstW)) {
388  memset(dst0_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
389  memset(dst1_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));
390 
391  call_ref(dst0_a, src, dstW, rgb2yuv, NULL);
392  call_new(dst1_a, src, dstW, rgb2yuv, NULL);
393 
394  if (memcmp(dst0_a, dst1_a, dstW * byte_size))
395  fail();
396  bench_new(dst1_a, src, dstW, rgb2yuv, NULL);
397  }
398  }
399  }
401 }
402 
404 {
406  report("output_yuv2gbrp");
407 
409  report("input_planar_rgb_y");
410 
412  report("input_planar_rgb_uv");
413 
415  report("input_planar_rgb_a");
416 }
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:516
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:173
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:70
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:188
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:182
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:403
FILTER_SIZES
#define FILTER_SIZES
rnd
#define rnd()
Definition: checkasm.h:166
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:1406
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:196
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition: mem_internal.h:144
call_new
#define call_new(...)
Definition: checkasm.h:291
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:1213
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:264
ff_sws_init_scale
void ff_sws_init_scale(SwsContext *c)
Definition: swscale.c:591
SWS_FULL_CHR_H_INT
#define SWS_FULL_CHR_H_INT
Definition: swscale.h:86
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:185
bench_new
#define bench_new(...)
Definition: checkasm.h:362
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:2069
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:337
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2433
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:177
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:301
swscale.h