FFmpeg
Loading...
Searching...
No Matches
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
63
64static 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
190static 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
258static 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
331static 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
398void 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}
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
int32_t
int32_t
Definition audioconvert.c:56
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
rgb2yuv
static void fn rgb2yuv(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], int16_t *rgb[3], ptrdiff_t s, int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], const int16_t yuv_offset[8])
Definition colorspacedsp_template.c:130
common.h
common internal and external API header
NULL
#define NULL
Definition coverity.c:32
declare_func
#define declare_func
Definition test.h:489
fail
#define fail
Definition test.h:479
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
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:1884
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext and set its fields to default values.
Definition utils.c:1032
sws_freeContext
void sws_freeContext(SwsContext *swsContext)
Free the swscaler context swsContext.
Definition utils.c:2250
SWS_FULL_CHR_H_INT
@ SWS_FULL_CHR_H_INT
Perform full chroma upsampling when upscaling to RGB.
Definition swscale.h:154
alpha
static const int16_t alpha[]
Definition ilbcdata.h:55
desc
const char * desc
Definition libsvtav1.c:83
w
uint8_t w
Definition llvidencdsp.c:39
mem_internal.h
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition mem_internal.h:128
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3460
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_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition pixfmt.h:169
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition pixfmt.h:341
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition pixfmt.h:168
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition pixfmt.h:279
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition pixfmt.h:310
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition pixfmt.h:213
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_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition pixfmt.h:212
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition pixfmt.h:280
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition pixfmt.h:171
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition pixfmt.h:311
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition pixfmt.h:167
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_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition pixfmt.h:344
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition pixfmt.h:282
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition pixfmt.h:170
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition pixfmt.h:313
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition pixfmt.h:314
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition pixfmt.h:165
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition pixfmt.h:214
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition pixfmt.h:281
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition pixfmt.h:172
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition pixfmt.h:603
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
SwsContext
Main external API structure.
Definition swscale.h:227
SwsContext::dst_format
int dst_format
Destination pixel format.
Definition swscale.h:275
SwsContext::src_format
int src_format
Source pixel format.
Definition swscale.h:274
SwsContext::flags
unsigned flags
Bitmask of SWS_*.
Definition swscale.h:238
checkasm_check_sw_gbrp
void checkasm_check_sw_gbrp(void)
Definition sw_gbrp.c:398
FILTER_SIZES
#define FILTER_SIZES
randomize_buffers
#define randomize_buffers(buf, size)
Definition sw_gbrp.c:32
planar_fmts
static const int planar_fmts[]
Definition sw_gbrp.c:39
check_input_planar_rgb_to_uv
static void check_input_planar_rgb_to_uv(void)
Definition sw_gbrp.c:258
LARGEST_INPUT_SIZE
#define LARGEST_INPUT_SIZE
check_input_planar_rgb_to_a
static void check_input_planar_rgb_to_a(void)
Definition sw_gbrp.c:331
check_input_planar_rgb_to_y
static void check_input_planar_rgb_to_y(void)
Definition sw_gbrp.c:190
LARGEST_FILTER
#define LARGEST_FILTER
check_output_yuv2gbrp
static void check_output_yuv2gbrp(void)
Definition sw_gbrp.c:64
input_sizes
static const int input_sizes[]
Definition sw_rgb.c:351
ff_sws_init_scale
void ff_sws_init_scale(SwsInternal *c)
Definition swscale.c:697
swscale.h
external API header
swscale_internal.h
sws_internal
static SwsInternal * sws_internal(const SwsContext *sws)
Definition swscale_internal.h:79
src
#define src
Definition vp8dsp.c:248
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Tue Aug 18 2026 20:21:09 for FFmpeg by doxygen 1.13.2