FFmpeg: libavfilter/formats.c Source File

FFmpeg
Loading...
Searching...
No Matches
formats.c
Go to the documentation of this file.
1/*
2 * Filter layer - format negotiation
3 * Copyright (c) 2007 Bobby Bingham
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (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 GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "libavutil/attributes.h"
23#include "libavutil/avassert.h"
24#include "libavutil/bprint.h"
25#include "libavutil/channel_layout.h"
26#include "libavutil/common.h"
27#include "libavutil/mem.h"
28#include "libavutil/pixdesc.h"
29#include "avfilter.h"
30#include "filters.h"
31#include "formats.h"
32
33/**
34 * Add all refs from a to ret and destroy a.
35 */
36 #define MERGE_REF(ret, a, fmts, type, fail_statement) \
37do { \
38 type ***tmp; \
39 int i; \
40 \
41 if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
42 sizeof(*tmp)))) \
43 { fail_statement } \
44 ret->refs = tmp; \
45 \
46 for (i = 0; i < a->refcount; i ++) { \
47 ret->refs[ret->refcount] = a->refs[i]; \
48 *ret->refs[ret->refcount++] = ret; \
49 } \
50 \
51 av_freep(&a->refs); \
52 av_freep(&a->fmts); \
53 av_freep(&a); \
54} while (0)
55
56/**
57 * Add all formats common to a and b to a, add b's refs to a and destroy b.
58 * If check is set, nothing is modified and it is only checked whether
59 * the formats are compatible.
60 * If empty_allowed is set and one of a,b->nb is zero, the lists are
61 * merged; otherwise, 0 (for nonmergeability) is returned.
62 */
63 #define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
64do { \
65 int i, j, k = 0, skip = 0; \
66 \
67 if (empty_allowed) { \
68 if (!a->nb || !b->nb) { \
69 if (check) \
70 return 1; \
71 if (!a->nb) \
72 FFSWAP(type *, a, b); \
73 skip = 1; \
74 } \
75 } \
76 if (!skip) { \
77 for (i = 0; i < a->nb; i++) \
78 for (j = 0; j < b->nb; j++) \
79 if (a->fmts[i] == b->fmts[j]) { \
80 if (check) \
81 return 1; \
82 a->fmts[k++] = a->fmts[i]; \
83 break; \
84 } \
85/* Check that there was at least one common format. \
86 * Notice that both a and b are unchanged if not. */ \
87 if (!k) \
88 return 0; \
89 av_assert2(!check); \
90 a->nb = k; \
91 } \
92 \
93 MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
94} while (0)
97 enum AVMediaType type, int check)
98{
99 int i, j;
100 int alpha1=0, alpha2=0;
101 int chroma1=0, chroma2=0;
102
103 av_assert2(check || (a->refcount && b->refcount));
104
105 if (a == b)
106 return 1;
107
108 /* Do not lose chroma or alpha in merging.
109 It happens if both lists have formats with chroma (resp. alpha), but
110 the only formats in common do not have it (e.g. YUV+gray vs.
111 RGB+gray): in that case, the merging would select the gray format,
112 possibly causing a lossy conversion elsewhere in the graph.
113 To avoid that, pretend that there are no common formats to force the
114 insertion of a conversion filter. */
116 for (i = 0; i < a->nb_formats; i++) {
117 const AVPixFmtDescriptor *const adesc = av_pix_fmt_desc_get(a->formats[i]);
118 for (j = 0; j < b->nb_formats; j++) {
119 const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
120 alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
121 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
122 if (a->formats[i] == b->formats[j]) {
123 alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
124 chroma1|= adesc->nb_components > 1;
125 }
126 }
127 }
128
129 // If chroma or alpha can be lost through merging then do not merge
130 if (alpha2 > alpha1 || chroma2 > chroma1)
131 return 0;
132
133 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
134
135 return 1;
136}
137
138
139/**
140 * Check the formats lists for compatibility for merging without actually
141 * merging.
142 *
143 * @return 1 if they are compatible, 0 if not.
144 */
145static int can_merge_pix_fmts(const void *a, const void *b)
146{
149}
150
151/**
152 * Merge the formats lists if they are compatible and update all the
153 * references of a and b to point to the combined list and free the old
154 * lists as needed. The combined list usually contains the intersection of
155 * the lists of a and b.
156 *
157 * Both a and b must have owners (i.e. refcount > 0) for these functions.
158 *
159 * @return 1 if merging succeeded, 0 if a and b are incompatible
160 * and negative AVERROR code on failure.
161 * a and b are unmodified if 0 is returned.
162 */
163static int merge_pix_fmts(void *a, void *b)
164{
166}
167
168/**
169 * See can_merge_pix_fmts().
170 */
171static int can_merge_sample_fmts(const void *a, const void *b)
172{
175}
176
177/**
178 * See merge_pix_fmts().
179 */
180static int merge_sample_fmts(void *a, void *b)
181{
183}
186 AVFilterFormats *b, int check)
187{
188 av_assert2(check || (a->refcount && b->refcount));
189 if (a == b) return 1;
190
191 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
192 return 1;
193}
194
195/**
196 * See can_merge_pix_fmts().
197 */
198static int can_merge_samplerates(const void *a, const void *b)
199{
201}
202
203/**
204 * See merge_pix_fmts().
205 */
206static int merge_samplerates(void *a, void *b)
207{
208 return merge_samplerates_internal(a, b, 0);
209}
210
211/**
212 * See merge_pix_fmts().
213 */
216{
218 unsigned a_all = a->all_layouts + a->all_counts;
219 unsigned b_all = b->all_layouts + b->all_counts;
220 int ret_max, ret_nb = 0, i, j, round;
221
222 av_assert2(a->refcount && b->refcount);
223
224 if (a == b) return 1;
225
226 /* Put the most generic set in a, to avoid doing everything twice */
227 if (a_all < b_all) {
229 FFSWAP(unsigned, a_all, b_all);
230 }
231 if (a_all) {
232 if (a_all == 1 && !b_all) {
233 /* keep only known layouts in b; works also for b_all = 1 */
234 for (i = j = 0; i < b->nb_channel_layouts; i++)
235 if (KNOWN(&b->channel_layouts[i]) && i != j++) {
236 if (check)
237 return 1;
238 av_channel_layout_copy(&b->channel_layouts[j], &b->channel_layouts[i]);
239 }
240 /* Not optimal: the unknown layouts of b may become known after
241 another merge. */
242 if (!j)
243 return 0;
244 b->nb_channel_layouts = j;
245 }
247 return 1;
248 }
249
250 ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
251 if (!check && !(channel_layouts = av_calloc(ret_max, sizeof(*channel_layouts))))
252 return AVERROR(ENOMEM);
253
254 /* a[known] intersect b[known] */
255 for (i = 0; i < a->nb_channel_layouts; i++) {
256 if (!KNOWN(&a->channel_layouts[i]))
257 continue;
258 for (j = 0; j < b->nb_channel_layouts; j++) {
259 if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
260 if (check)
261 return 1;
262 av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
263 av_channel_layout_uninit(&a->channel_layouts[i]);
264 av_channel_layout_uninit(&b->channel_layouts[j]);
265 break;
266 }
267 }
268 }
269 /* 1st round: a[known] intersect b[generic]
270 2nd round: a[generic] intersect b[known] */
271 for (round = 0; round < 2; round++) {
272 for (i = 0; i < a->nb_channel_layouts; i++) {
273 AVChannelLayout *fmt = &a->channel_layouts[i], bfmt = { 0 };
274 if (!av_channel_layout_check(fmt) || !KNOWN(fmt))
275 continue;
276 bfmt = FF_COUNT2LAYOUT(fmt->nb_channels);
277 for (j = 0; j < b->nb_channel_layouts; j++)
278 if (!av_channel_layout_compare(&b->channel_layouts[j], &bfmt)) {
279 if (check)
280 return 1;
282 }
283 }
284 /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
286 }
287 /* a[generic] intersect b[generic] */
288 for (i = 0; i < a->nb_channel_layouts; i++) {
289 if (KNOWN(&a->channel_layouts[i]))
290 continue;
291 for (j = 0; j < b->nb_channel_layouts; j++)
292 if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
293 if (check)
294 return 1;
295 av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
296 }
297 }
298
299 if (!ret_nb) {
301 return 0;
302 }
303
304 if (a->refcount > b->refcount)
306
308 { av_free(channel_layouts); return AVERROR(ENOMEM); });
309 av_freep(&b->channel_layouts);
310 b->channel_layouts = channel_layouts;
311 b->nb_channel_layouts = ret_nb;
312 return 1;
313}
315static int can_merge_channel_layouts(const void *a, const void *b)
316{
319}
321static int merge_channel_layouts(void *a, void *b)
322{
324}
327 AVFilterFormats *b, int check)
328{
329 av_assert2(check || (a->refcount && b->refcount));
330
331 if (a == b)
332 return 1;
333
334 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
335
336 return 1;
337}
339static int can_merge_generic(const void *a, const void *b)
340{
342 (AVFilterFormats *)b, 1);
343}
345static int merge_generic(void *a, void *b)
346{
347 return merge_generic_internal(a, b, 0);
348}
350#define PRINT_NAME(type, type_name) \
351static void print_##type_name(AVBPrint *bp, const void *fmtsp) \
352{ \
353 const AVFilterFormats *fmts = fmtsp; \
354 for (int i = 0; i < fmts->nb_formats; i++) { \
355 const char *name = av_##type_name(fmts->formats[i]); \
356 av_bprint_chars(bp, ' ', i ? 1 : 0); \
357 av_bprint_append_data(bp, name, name ? strlen(name) : 0); \
358 } \
359}
360
361PRINT_NAME(enum AVSampleFormat, get_sample_fmt_name)
362PRINT_NAME(enum AVPixelFormat, get_pix_fmt_name)
363PRINT_NAME(enum AVColorSpace, color_space_name)
364PRINT_NAME(enum AVColorRange, color_range_name)
365PRINT_NAME(enum AVAlphaMode, alpha_mode_name)
367static void print_channel_layout_desc(AVBPrint *bp, const void *layoutsp)
368{
369 const AVFilterChannelLayouts *layouts = layoutsp;
370 for (int i = 0; i < layouts->nb_channel_layouts; i++) {
371 av_bprint_chars(bp, ' ', i ? 1 : 0);
372 av_channel_layout_describe_bprint(&layouts->channel_layouts[i], bp);
373 }
374}
376static void print_sample_rate(AVBPrint *bp, const void *ratesp)
377{
378 const AVFilterFormats *rates = ratesp;
379 for (int i = 0; i < rates->nb_formats; i++)
380 av_bprintf(bp, "%s%d", i ? " " : "", rates->formats[i]);
381}
383#define CONVERSION_FILTER_SWSCALE \
384 .conversion_filter = "scale", \
385 .conversion_opts_offset = offsetof(AVFilterGraph, scale_sws_opts),
387#define CONVERSION_FILTER_ARESAMPLE \
388 .conversion_filter = "aresample", \
389 .conversion_opts_offset = offsetof(AVFilterGraph, aresample_swr_opts),
391static const AVFilterFormatsMerger mergers_video[] = {
392 {
393 .name = "Pixel formats",
394 .offset = offsetof(AVFilterFormatsConfig, formats),
395 .merge = merge_pix_fmts,
396 .can_merge = can_merge_pix_fmts,
397 .print_list = print_get_pix_fmt_name,
399 },
400 {
401 .name = "Color spaces",
402 .offset = offsetof(AVFilterFormatsConfig, color_spaces),
403 .merge = merge_generic,
404 .can_merge = can_merge_generic,
405 .print_list = print_color_space_name,
407 },
408 {
409 .name = "Color ranges",
410 .offset = offsetof(AVFilterFormatsConfig, color_ranges),
411 .merge = merge_generic,
412 .can_merge = can_merge_generic,
413 .print_list = print_color_range_name,
415 },
416 {
417 .name = "Alpha modes",
418 .offset = offsetof(AVFilterFormatsConfig, alpha_modes),
419 .merge = merge_generic,
420 .can_merge = can_merge_generic,
421 .print_list = print_alpha_mode_name,
422 .conversion_filter = "premultiply_dynamic",
423 },
424};
426static const AVFilterFormatsMerger mergers_audio[] = {
427 {
428 .name = "Channel layouts",
429 .offset = offsetof(AVFilterFormatsConfig, channel_layouts),
430 .merge = merge_channel_layouts,
431 .can_merge = can_merge_channel_layouts,
432 .print_list = print_channel_layout_desc,
434 },
435 {
436 .name = "Sample rates",
437 .offset = offsetof(AVFilterFormatsConfig, samplerates),
438 .merge = merge_samplerates,
439 .can_merge = can_merge_samplerates,
440 .print_list = print_sample_rate,
442 },
443 {
444 .name = "Sample formats",
445 .offset = offsetof(AVFilterFormatsConfig, formats),
446 .merge = merge_sample_fmts,
447 .can_merge = can_merge_sample_fmts,
448 .print_list = print_get_sample_fmt_name,
450 },
451};
454 .nb_mergers = FF_ARRAY_ELEMS(mergers_video),
455 .mergers = mergers_video,
456};
459 .nb_mergers = FF_ARRAY_ELEMS(mergers_audio),
460 .mergers = mergers_audio,
461};
464{
465 switch (link->type) {
468 default: return NULL;
469 }
470}
472int ff_pixfmt_is_in(enum AVPixelFormat fmt, const enum AVPixelFormat *fmts)
473{
474 for (; *fmts != AV_PIX_FMT_NONE; ++fmts) {
475 if (fmt == *fmts)
476 return 1;
477 }
478 return 0;
479}
481#define MAKE_FORMAT_LIST(type, field, count_field) \
482 type *formats; \
483 int count = 0; \
484 if (fmts) \
485 for (count = 0; fmts[count] != -1; count++) \
486 ; \
487 formats = av_mallocz(sizeof(*formats)); \
488 if (!formats) \
489 return NULL; \
490 formats->count_field = count; \
491 if (count) { \
492 formats->field = av_malloc_array(count, sizeof(*formats->field)); \
493 if (!formats->field) { \
494 av_freep(&formats); \
495 return NULL; \
496 } \
497 }
499#define MAKE_FORMAT_LIST_TYPE(name, type) \
500 AVFilterFormats *ff_make_ ## name ## _list(const type* fmts) \
501 { \
502 MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats); \
503 while (count--) \
504 formats->formats[count] = (int)fmts[count]; \
505 return formats; \
506 }
507
508MAKE_FORMAT_LIST_TYPE(format, int)
509MAKE_FORMAT_LIST_TYPE(sample_format, enum AVSampleFormat)
510MAKE_FORMAT_LIST_TYPE(pixel_format, enum AVPixelFormat)
513{
514 AVFilterChannelLayouts *ch_layouts;
515 int count = 0;
516 if (fmts)
517 for (count = 0; fmts[count].nb_channels; count++)
518 ;
519 ch_layouts = av_mallocz(sizeof(*ch_layouts));
520 if (!ch_layouts)
521 return NULL;
522 ch_layouts->nb_channel_layouts = count;
523 if (count) {
524 ch_layouts->channel_layouts =
525 av_calloc(count, sizeof(*ch_layouts->channel_layouts));
526 if (!ch_layouts->channel_layouts) {
527 av_freep(&ch_layouts);
528 return NULL;
529 }
530 for (int i = 0; i < count; i++) {
531 int ret = av_channel_layout_copy(&ch_layouts->channel_layouts[i], &fmts[i]);
532 if (ret < 0)
533 goto fail;
534 }
535 }
536
537 return ch_layouts;
538
539fail:
540 for (int i = 0; i < count; i++)
542 av_free(ch_layouts->channel_layouts);
543 av_freep(&ch_layouts);
544
545 return NULL;
546}
548#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
549do { \
550 type *fmts; \
551 \
552 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
553 return AVERROR(ENOMEM); \
554 } \
555 \
556 fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
557 sizeof(*(*f)->list)); \
558 if (!fmts) { \
559 unref_fn(f); \
560 return AVERROR(ENOMEM); \
561 } \
562 \
563 (*f)->list = fmts; \
564 ASSIGN_FMT(f, fmt, list, nb); \
565} while (0)
567#define ASSIGN_FMT(f, fmt, list, nb) \
568do { \
569 (*f)->list[(*f)->nb++] = fmt; \
570} while (0)
573{
574 ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
575 return 0;
576}
577
578#undef ASSIGN_FMT
579#define ASSIGN_FMT(f, fmt, list, nb) \
580do { \
581 int ret; \
582 memset((*f)->list + (*f)->nb, 0, sizeof(*(*f)->list)); \
583 ret = av_channel_layout_copy(&(*f)->list[(*f)->nb], fmt); \
584 if (ret < 0) \
585 return ret; \
586 (*f)->nb++; \
587} while (0)
590 const AVChannelLayout *channel_layout)
591{
592 av_assert1(!(*l && (*l)->all_layouts));
593 ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, AVChannelLayout, channel_layouts, nb_channel_layouts);
594 return 0;
595}
598{
599 int fmts[2] = { fmt, -1 };
600 return ff_make_format_list(fmts);
601}
604{
605 AVFilterFormats *ret = NULL;
606
607 if (type == AVMEDIA_TYPE_VIDEO) {
608 return ff_formats_pixdesc_filter(0, 0);
609 } else if (type == AVMEDIA_TYPE_AUDIO) {
610 enum AVSampleFormat fmt = 0;
611 while (av_get_sample_fmt_name(fmt)) {
612 if (ff_add_format(&ret, fmt) < 0)
613 return NULL;
614 fmt++;
615 }
616 }
617
618 return ret;
619}
621AVFilterFormats *ff_formats_pixdesc_filter(unsigned want, unsigned rej)
622{
623 unsigned nb_formats, fmt, flags;
625
626 while (1) {
627 nb_formats = 0;
628 for (fmt = 0;; fmt++) {
630 if (!desc)
631 break;
632 flags = desc->flags;
633 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
634 !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
635 (desc->log2_chroma_w || desc->log2_chroma_h))
637 if ((flags & (want | rej)) != want)
638 continue;
639 if (formats)
640 formats->formats[nb_formats] = fmt;
641 nb_formats++;
642 }
643 if (formats) {
644 av_assert0(formats->nb_formats == nb_formats);
645 return formats;
646 }
647 formats = av_mallocz(sizeof(*formats));
648 if (!formats)
649 return NULL;
650 formats->nb_formats = nb_formats;
651 if (nb_formats) {
652 formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
653 if (!formats->formats) {
655 return NULL;
656 }
657 }
658 }
659}
662{
663 AVFilterFormats *ret = NULL;
664 int fmt;
665
666 for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
668 if (ff_add_format(&ret, fmt) < 0)
669 return NULL;
670
671 return ret;
672}
675{
676 AVFilterFormats *ret = av_mallocz(sizeof(*ret));
677 return ret;
678}
681{
682 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
683 if (!ret)
684 return NULL;
685 ret->all_layouts = 1;
686 return ret;
687}
690{
691 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
692 if (!ret)
693 return NULL;
694 ret->all_layouts = ret->all_counts = 1;
695 return ret;
696}
699{
700 AVFilterFormats *ret = NULL;
702 return NULL;
703 for (int csp = 0; csp < AVCOL_SPC_NB; csp++) {
704 if (csp == AVCOL_SPC_RESERVED ||
706 continue;
707 if (ff_add_format(&ret, csp) < 0)
708 return NULL;
709 }
710
711 return ret;
712}
715{
716 AVFilterFormats *ret = NULL;
717 for (int range = 0; range < AVCOL_RANGE_NB; range++) {
718 if (ff_add_format(&ret, range) < 0)
719 return NULL;
720 }
721
722 return ret;
723}
726{
727 AVFilterFormats *ret = NULL;
728 for (int am = 0; am < AVALPHA_MODE_NB; am++) {
729 if (ff_add_format(&ret, am) < 0)
730 return NULL;
731 }
732
733 return ret;
734}
736#define FORMATS_REF(f, ref, unref_fn) \
737 void *tmp; \
738 \
739 if (!f) \
740 return AVERROR(ENOMEM); \
741 \
742 tmp = av_realloc_array(f->refs, f->refcount + 1, sizeof(*f->refs)); \
743 if (!tmp) { \
744 unref_fn(&f); \
745 return AVERROR(ENOMEM); \
746 } \
747 f->refs = tmp; \
748 f->refs[f->refcount++] = ref; \
749 *ref = f; \
750 return 0
755}
760}
762#define FIND_REF_INDEX(ref, idx) \
763do { \
764 int i; \
765 for (i = 0; i < (*ref)->refcount; i ++) \
766 if((*ref)->refs[i] == ref) { \
767 idx = i; \
768 break; \
769 } \
770} while (0)
772#define FORMATS_UNREF(ref, list) \
773do { \
774 int idx = -1; \
775 \
776 if (!*ref) \
777 return; \
778 \
779 FIND_REF_INDEX(ref, idx); \
780 \
781 if (idx >= 0) { \
782 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
783 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
784 --(*ref)->refcount; \
785 } \
786 if (!(*ref)->refcount) { \
787 FREE_LIST(ref, list); \
788 av_free((*ref)->list); \
789 av_free((*ref)->refs); \
790 av_free(*ref); \
791 } \
792 *ref = NULL; \
793} while (0)
794
795 #define FREE_LIST(ref, list) do { } while(0)
797{
799}
800
801#undef FREE_LIST
802#define FREE_LIST(ref, list) \
803 do { \
804 for (int i = 0; i < (*ref)->nb_channel_layouts; i++) \
805 av_channel_layout_uninit(&(*ref)->list[i]); \
806 } while(0)
811}
813#define FORMATS_CHANGEREF(oldref, newref) \
814do { \
815 int idx = -1; \
816 \
817 FIND_REF_INDEX(oldref, idx); \
818 \
819 if (idx >= 0) { \
820 (*oldref)->refs[idx] = newref; \
821 *newref = *oldref; \
822 *oldref = NULL; \
823 } \
824} while (0)
827 AVFilterChannelLayouts **newref)
828{
829 FORMATS_CHANGEREF(oldref, newref);
830}
833{
834 FORMATS_CHANGEREF(oldref, newref);
835}
837#define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
838 int i; \
839 \
840 if (!fmts) \
841 return AVERROR(ENOMEM); \
842 \
843 for (i = 0; i < ctx->nb_inputs; i++) { \
844 AVFilterLink *const link = ctx->inputs[i]; \
845 if (link && !link->outcfg.fmts && \
846 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
847 int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
848 if (ret < 0) { \
849 return ret; \
850 } \
851 } \
852 } \
853 for (i = 0; i < ctx->nb_outputs; i++) { \
854 AVFilterLink *const link = ctx->outputs[i]; \
855 if (link && !link->incfg.fmts && \
856 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
857 int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
858 if (ret < 0) { \
859 return ret; \
860 } \
861 } \
862 } \
863 \
864 if (!fmts->refcount) \
865 unref_fn(&fmts); \
866 \
867 return 0;
874}
880}
885}
892}
895 const int *samplerates)
896{
898}
903}
910}
913 const int *color_spaces)
914{
916}
921}
928}
931 const int *color_ranges)
932{
934}
939}
946}
949 const int *alpha_modes)
950{
952}
957}
958
959/**
960 * A helper for query_formats() which sets all links to the same list of
961 * formats. If there are no links hooked to this filter, the list of formats is
962 * freed.
968}
973}
978}
983}
984
985#define SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, fmts, media_type, \
986 ref_fn, unref_fn) \
987 if (!fmts) \
988 return AVERROR(ENOMEM); \
989 \
990 for (unsigned i = 0; i < ctx->nb_inputs; i++) { \
991 const AVFilterLink *const link = ctx->inputs[i]; \
992 if (!cfg_in[i]->fmts && \
993 (media_type == AVMEDIA_TYPE_UNKNOWN || \
994 link->type == media_type)) { \
995 int ret = ref_fn(fmts, &cfg_in[i]->fmts); \
996 if (ret < 0) { \
997 return ret; \
998 } \
999 } \
1000 } \
1001 for (unsigned i = 0; i < ctx->nb_outputs; i++) { \
1002 const AVFilterLink *const link = ctx->outputs[i]; \
1003 if (!cfg_out[i]->fmts && \
1004 (media_type == AVMEDIA_TYPE_UNKNOWN || \
1005 link->type == media_type)) { \
1006 int ret = ref_fn(fmts, &cfg_out[i]->fmts); \
1007 if (ret < 0) { \
1008 return ret; \
1009 } \
1010 } \
1011 } \
1012 \
1013 if (!fmts->refcount) \
1014 unref_fn(&fmts); \
1015 \
1016 return 0;
1025}
1033}
1040}
1043 AVFilterFormatsConfig **cfg_in,
1044 AVFilterFormatsConfig **cfg_out,
1045 AVFilterFormats *samplerates)
1046{
1047 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, samplerates, AVMEDIA_TYPE_AUDIO,
1049}
1052 AVFilterFormatsConfig **cfg_in,
1053 AVFilterFormatsConfig **cfg_out,
1054 const int *samplerates)
1055{
1056 return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_make_format_list(samplerates));
1057}
1060 AVFilterFormatsConfig **cfg_in,
1061 AVFilterFormatsConfig **cfg_out)
1062{
1063 return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_all_samplerates());
1064}
1067 AVFilterFormatsConfig **cfg_in,
1068 AVFilterFormatsConfig **cfg_out,
1069 AVFilterFormats *color_spaces)
1070{
1071 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_spaces, AVMEDIA_TYPE_VIDEO,
1073}
1076 AVFilterFormatsConfig **cfg_in,
1077 AVFilterFormatsConfig **cfg_out,
1078 const int *color_spaces)
1079{
1080 return ff_set_common_color_spaces2(ctx, cfg_in, cfg_out, ff_make_format_list(color_spaces));
1081}
1088}
1091 AVFilterFormatsConfig **cfg_in,
1092 AVFilterFormatsConfig **cfg_out,
1093 AVFilterFormats *color_ranges)
1094{
1095 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_ranges, AVMEDIA_TYPE_VIDEO,
1097}
1100 AVFilterFormatsConfig **cfg_in,
1101 AVFilterFormatsConfig **cfg_out,
1102 const int *color_ranges)
1103{
1104 return ff_set_common_color_ranges2(ctx, cfg_in, cfg_out, ff_make_format_list(color_ranges));
1105}
1112}
1115 AVFilterFormatsConfig **cfg_in,
1116 AVFilterFormatsConfig **cfg_out,
1117 AVFilterFormats *alpha_modes)
1118{
1119 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, alpha_modes, AVMEDIA_TYPE_VIDEO,
1121}
1124 AVFilterFormatsConfig **cfg_in,
1125 AVFilterFormatsConfig **cfg_out,
1126 const int *alpha_modes)
1127{
1128 return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_make_format_list(alpha_modes));
1129}
1132 AVFilterFormatsConfig **cfg_in,
1133 AVFilterFormatsConfig **cfg_out)
1134{
1135 return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_all_alpha_modes());
1136}
1145}
1148 AVFilterFormatsConfig **cfg_in,
1149 AVFilterFormatsConfig **cfg_out,
1150 const int *fmts)
1151{
1152 return ff_set_common_formats2(ctx, cfg_in, cfg_out, ff_make_format_list(fmts));
1153}
1156 AVFilterFormatsConfig **cfg_in,
1157 AVFilterFormatsConfig **cfg_out,
1158 const enum AVSampleFormat *fmts)
1159{
1160 return ff_set_common_formats2(ctx, cfg_in, cfg_out, ff_make_sample_format_list(fmts));
1161}
1164 AVFilterFormatsConfig **cfg_in,
1165 AVFilterFormatsConfig **cfg_out,
1166 const enum AVPixelFormat *fmts)
1167{
1168 return ff_set_common_formats2(ctx, cfg_in, cfg_out, ff_make_pixel_format_list(fmts));
1169}
1172{
1173 const FFFilter *const f = fffilter(ctx->filter);
1175 enum AVMediaType type;
1176 int ret;
1177
1178 switch (f->formats_state) {
1181 formats = ff_make_pixel_format_list(f->formats.pixels_list);
1182 break;
1185 formats = ff_make_sample_format_list(f->formats.samples_list);
1186 break;
1189 formats = ff_make_formats_list_singleton(f->formats.pix_fmt);
1190 break;
1193 formats = ff_make_formats_list_singleton(f->formats.sample_fmt);
1194 break;
1195 default:
1196 av_assert2(!"Unreachable");
1202 formats = ff_all_formats(ctx->nb_inputs ? ctx->inputs [0]->type :
1203 ctx->nb_outputs ? ctx->outputs[0]->type :
1205 break;
1206 }
1207
1209 if (ret < 0)
1210 return ret;
1211 if (type != AVMEDIA_TYPE_AUDIO) {
1213 if (ret < 0)
1214 return ret;
1216 if (ret < 0)
1217 return ret;
1219 if (ret < 0)
1220 return ret;
1221 }
1222 if (type != AVMEDIA_TYPE_VIDEO) {
1224 if (ret < 0)
1225 return ret;
1227 if (ret < 0)
1228 return ret;
1229 }
1230
1231 return 0;
1232}
1234static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
1235{
1236 unsigned i, j;
1237
1238 if (!fmts)
1239 return 0;
1240 if (!fmts->nb_formats) {
1241 av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
1242 return AVERROR(EINVAL);
1243 }
1244 for (i = 0; i < fmts->nb_formats; i++) {
1245 for (j = i + 1; j < fmts->nb_formats; j++) {
1246 if (fmts->formats[i] == fmts->formats[j]) {
1247 av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
1248 return AVERROR(EINVAL);
1249 }
1250 }
1251 }
1252 return 0;
1253}
1255int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
1256{
1257 return check_list(log, "pixel format", fmts);
1258}
1260int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
1261{
1262 return check_list(log, "sample format", fmts);
1263}
1265int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
1266{
1267 if (!fmts || !fmts->nb_formats)
1268 return 0;
1269 return check_list(log, "sample rate", fmts);
1270}
1272int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
1273{
1274 for (int i = 0; fmts && i < fmts->nb_formats; i++) {
1275 if (fmts->formats[i] == AVCOL_SPC_RESERVED) {
1276 av_log(log, AV_LOG_ERROR, "Invalid color space\n");
1277 return AVERROR(EINVAL);
1278 }
1279 }
1280 return check_list(log, "color space", fmts);
1281}
1283int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
1284{
1285 return check_list(log, "color range", fmts);
1286}
1288int ff_formats_check_alpha_modes(void *log, const AVFilterFormats *fmts)
1289{
1290 return check_list(log, "alpha mode", fmts);
1291}
1293static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
1294{
1295 return !av_channel_layout_compare(a, b) ||
1296 (KNOWN(a) && !KNOWN(b) && a->nb_channels == b->nb_channels) ||
1297 (KNOWN(b) && !KNOWN(a) && b->nb_channels == a->nb_channels);
1298}
1301{
1302 unsigned i, j;
1303
1304 if (!fmts)
1305 return 0;
1306 if (fmts->all_layouts < fmts->all_counts) {
1307 av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
1308 return AVERROR(EINVAL);
1309 }
1310 if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
1311 av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
1312 return AVERROR(EINVAL);
1313 }
1314 for (i = 0; i < fmts->nb_channel_layouts; i++) {
1315 for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
1316 if (layouts_compatible(&fmts->channel_layouts[i], &fmts->channel_layouts[j])) {
1317 av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
1318 return AVERROR(EINVAL);
1319 }
1320 }
1321 }
1322 return 0;
1323}
static const char *const format[]
Definition af_aiir.c:445
static AVFormatContext * ctx
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition avassert.h:68
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition avassert.h:58
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
Main libavfilter public API header.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition bprint.c:122
AVBPrint public header.
#define flags(name, subs,...)
Definition cbs_h264.c:74
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
f
#define f(width, name)
Definition cbs_vp8.c:236
Public libavutil channel layout APIs header.
common internal and external API header
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
static const uint16_t channel_layouts[7]
Definition dca_lbr.c:112
const AVFilterNegotiation * ff_filter_get_negotiation(const AVFilterLink *link)
Definition formats.c:462
int ff_set_common_alpha_modes(AVFilterContext *ctx, AVFilterFormats *alpha_modes)
Definition formats.c:940
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition formats.c:679
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition formats.c:825
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition formats.c:602
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample rates list.
Definition formats.c:1264
static const AVFilterNegotiation negotiate_audio
Definition formats.c:457
int ff_set_pixel_formats_from_list(AVFilterContext *ctx, const enum AVPixelFormat *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_pixel_format_list(fmts))
Definition formats.c:979
static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b, enum AVMediaType type, int check)
Definition formats.c:95
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition formats.c:547
int ff_default_query_formats(AVFilterContext *ctx)
Sets all remaining unset filter lists for all inputs/outputs to their corresponding ff_all_*() lists.
Definition formats.c:1170
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add ref as a new reference to formats.
Definition formats.c:756
int ff_set_common_color_spaces(AVFilterContext *ctx, AVFilterFormats *color_spaces)
Definition formats.c:904
AVFilterFormats * ff_all_color_spaces(void)
Construct an AVFilterFormats representing all possible color spaces.
Definition formats.c:697
#define FORMATS_CHANGEREF(oldref, newref)
Definition formats.c:812
#define PRINT_NAME(type, type_name)
Definition formats.c:349
static void print_channel_layout_desc(AVBPrint *bp, const void *layoutsp)
Definition formats.c:366
static int merge_sample_fmts(void *a, void *b)
See merge_pix_fmts().
Definition formats.c:179
int ff_set_common_samplerates2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *samplerates)
Definition formats.c:1041
static void print_sample_rate(AVBPrint *bp, const void *ratesp)
Definition formats.c:375
AVFilterFormats * ff_make_formats_list_singleton(int fmt)
Equivalent to ff_make_format_list({const int[]}{ fmt, -1 })
Definition formats.c:596
int ff_set_common_color_ranges2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *color_ranges)
Definition formats.c:1089
#define MERGE_REF(ret, a, fmts, type, fail_statement)
Add all refs from a to ret and destroy a.
Definition formats.c:36
static int merge_samplerates(void *a, void *b)
See merge_pix_fmts().
Definition formats.c:205
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
Definition formats.c:1233
static const AVFilterFormatsMerger mergers_video[]
Definition formats.c:390
int ff_pixfmt_is_in(enum AVPixelFormat fmt, const enum AVPixelFormat *fmts)
Tell if a pixel format is contained in the provided AV_PIX_FMT_NONE-terminated list.
Definition formats.c:471
static int merge_pix_fmts(void *a, void *b)
Merge the formats lists if they are compatible and update all the references of a and b to point to t...
Definition formats.c:162
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition formats.c:963
int ff_set_common_alpha_modes_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *alpha_modes)
Definition formats.c:1122
int ff_set_common_formats2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *formats)
Definition formats.c:1137
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition formats.c:571
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition formats.c:807
int ff_set_common_all_samplerates2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition formats.c:1058
int ff_set_common_all_alpha_modes2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition formats.c:1130
AVFilterFormats * ff_formats_pixdesc_filter(unsigned want, unsigned rej)
Construct a formats list containing all pixel formats with certain properties.
Definition formats.c:620
static const AVFilterFormatsMerger mergers_audio[]
Definition formats.c:425
int ff_set_common_channel_layouts2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterChannelLayouts *channel_layouts)
Helpers for query_formats2() which set all free audio links to the same list of channel layouts/sampl...
Definition formats.c:1017
#define SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, fmts, media_type, ref_fn, unref_fn)
Definition formats.c:984
static int merge_generic_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition formats.c:325
static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
Definition formats.c:1292
#define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed)
Add all formats common to a and b to a, add b's refs to a and destroy b.
Definition formats.c:63
#define CONVERSION_FILTER_ARESAMPLE
Definition formats.c:386
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition formats.c:660
int ff_set_common_all_color_ranges2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition formats.c:1106
static int can_merge_sample_fmts(const void *a, const void *b)
See can_merge_pix_fmts().
Definition formats.c:170
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid pixel formats list.
Definition formats.c:1254
int ff_set_common_color_spaces_from_list(AVFilterContext *ctx, const int *color_spaces)
Equivalent to ff_set_common_color_spaces(ctx, ff_make_format_list(color_spaces))
Definition formats.c:911
int ff_set_common_channel_layouts_from_list(AVFilterContext *ctx, const AVChannelLayout *fmts)
Equivalent to ff_set_common_channel_layouts(ctx, ff_make_channel_layout_list(fmts))
Definition formats.c:875
#define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn)
Definition formats.c:836
int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)
Definition formats.c:1146
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition formats.c:588
int ff_set_common_color_ranges_from_list(AVFilterContext *ctx, const int *color_ranges)
Equivalent to ff_set_common_color_ranges(ctx, ff_make_format_list(color_ranges))
Definition formats.c:929
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample formats list.
Definition formats.c:1259
int ff_set_sample_formats_from_list(AVFilterContext *ctx, const enum AVSampleFormat *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_sample_format_list(fmts))
Definition formats.c:974
static int can_merge_generic(const void *a, const void *b)
Definition formats.c:338
#define CONVERSION_FILTER_SWSCALE
Definition formats.c:382
int ff_set_common_color_spaces2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *color_spaces)
Definition formats.c:1065
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition formats.c:969
int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid formats list for YUV colorspace metadata.
Definition formats.c:1271
static int merge_channel_layouts(void *a, void *b)
Definition formats.c:320
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition formats.c:886
int ff_set_common_color_ranges_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *color_ranges)
Definition formats.c:1098
static const AVFilterNegotiation negotiate_video
Definition formats.c:452
void ff_formats_unref(AVFilterFormats **ref)
If *ref is non-NULL, remove *ref as a reference to the format list it currently points to,...
Definition formats.c:795
int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *samplerates)
Definition formats.c:1050
AVFilterFormats * ff_all_color_ranges(void)
Construct an AVFilterFormats representing all possible color ranges.
Definition formats.c:713
int ff_set_common_alpha_modes2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *alpha_modes)
Definition formats.c:1113
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition formats.c:688
static int can_merge_channel_layouts(const void *a, const void *b)
Definition formats.c:314
int ff_set_common_all_color_spaces2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition formats.c:1082
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition formats.c:831
int ff_set_common_all_channel_counts2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition formats.c:1034
int ff_set_common_color_spaces_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *color_spaces)
Definition formats.c:1074
static int can_merge_pix_fmts(const void *a, const void *b)
Check the formats lists for compatibility for merging without actually merging.
Definition formats.c:144
int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
Definition formats.c:1282
int ff_set_common_samplerates_from_list(AVFilterContext *ctx, const int *samplerates)
Equivalent to ff_set_common_samplerates(ctx, ff_make_format_list(samplerates))
Definition formats.c:893
#define FORMATS_REF(f, ref, unref_fn)
Definition formats.c:735
AVFilterFormats * ff_all_alpha_modes(void)
Construct an AVFilterFormats representing all possible alpha modes.
Definition formats.c:724
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
Check that fmts is a valid channel layouts list.
Definition formats.c:1299
static int can_merge_samplerates(const void *a, const void *b)
See can_merge_pix_fmts().
Definition formats.c:197
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition formats.c:899
#define FORMATS_UNREF(ref, list)
Definition formats.c:771
AVFilterChannelLayouts * ff_make_channel_layout_list(const AVChannelLayout *fmts)
Definition formats.c:511
int ff_set_common_all_channel_counts(AVFilterContext *ctx)
Equivalent to ff_set_common_channel_layouts(ctx, ff_all_channel_counts())
Definition formats.c:881
int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const AVChannelLayout *fmts)
Definition formats.c:1026
int ff_set_common_color_ranges(AVFilterContext *ctx, AVFilterFormats *color_ranges)
Definition formats.c:922
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition formats.c:751
static int merge_channel_layouts_internal(AVFilterChannelLayouts *a, AVFilterChannelLayouts *b, int check)
See merge_pix_fmts().
Definition formats.c:213
int ff_set_common_all_alpha_modes(AVFilterContext *ctx)
Equivalent to ff_set_common_alpha_modes(ctx, ff_all_alpha_modes())
Definition formats.c:953
AVFilterFormats * ff_all_samplerates(void)
Definition formats.c:673
int ff_formats_check_alpha_modes(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid formats list for alpha modes.
Definition formats.c:1287
int ff_set_common_all_color_spaces(AVFilterContext *ctx)
Equivalent to ff_set_common_color_spaces(ctx, ff_all_color_spaces())
Definition formats.c:917
int ff_set_common_alpha_modes_from_list(AVFilterContext *ctx, const int *alpha_modes)
Equivalent to ff_set_common_alpha_modes(ctx, ff_make_format_list(alpha_modes))
Definition formats.c:947
int ff_set_pixel_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const enum AVPixelFormat *fmts)
Definition formats.c:1162
int ff_set_sample_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const enum AVSampleFormat *fmts)
Definition formats.c:1154
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
Helpers for query_formats() which set all free audio links to the same list of channel layouts/sample...
Definition formats.c:868
#define MAKE_FORMAT_LIST_TYPE(name, type)
Definition formats.c:498
static int merge_generic(void *a, void *b)
Definition formats.c:344
static int merge_samplerates_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition formats.c:184
int ff_set_common_all_color_ranges(AVFilterContext *ctx)
Equivalent to ff_set_common_color_ranges(ctx, ff_all_color_ranges())
Definition formats.c:935
av_warn_unused_result AVFilterFormats * ff_make_sample_format_list(const enum AVSampleFormat *fmts)
Create a list of supported sample formats.
#define FF_PIX_FMT_FLAG_SW_FLAT_SUB
Definition formats.h:463
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition formats.h:102
av_warn_unused_result AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
#define KNOWN(l)
Definition formats.h:111
av_warn_unused_result AVFilterFormats * ff_make_pixel_format_list(const enum AVPixelFormat *fmts)
Create a list of supported pixel formats.
#define fail
Definition test.h:479
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition bprint.c:130
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
AVMediaType
Definition avutil.h:198
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition avutil.h:199
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition samplefmt.c:115
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition samplefmt.c:109
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition samplefmt.c:52
AVSampleFormat
Audio sample formats.
Definition samplefmt.h:55
a
int a
cl_device_type type
b
#define b
Definition input.c:43
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
Definition filters.h:230
@ FF_FILTER_FORMATS_SINGLE_PIXFMT
formats.pix_fmt active
Definition filters.h:234
@ FF_FILTER_FORMATS_SAMPLEFMTS_LIST
formats.samples_list active.
Definition filters.h:233
@ FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
formats.sample_fmt active.
Definition filters.h:235
@ FF_FILTER_FORMATS_PASSTHROUGH
The default value meaning that this filter supports all formats and (for audio) sample rates and chan...
Definition filters.h:229
@ FF_FILTER_FORMATS_PIXFMT_LIST
formats.pixels_list active.
Definition filters.h:232
@ FF_FILTER_FORMATS_QUERY_FUNC2
formats.query_func2 active.
Definition filters.h:231
static const FFFilter * fffilter(const AVFilter *f)
Definition filters.h:464
Macro definitions for various function/variable attributes.
#define av_fallthrough
Definition attributes.h:67
static av_always_inline av_const double round(double x)
Definition libm.h:446
const char * desc
Definition libsvtav1.c:83
#define FFSWAP(type, a, b)
Definition macros.h:52
enum AVColorRange range
enum AVSampleFormat sample_format
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:264
Memory handling functions.
#define check(x, y, S, v)
enum MovChannelLayoutTag * layouts
Definition mov_chan.c:335
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3460
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition pixdesc.h:147
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition pixdesc.h:128
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition pixdesc.h:132
AVColorRange
Visual content value range.
Definition pixfmt.h:748
@ AVCOL_RANGE_NB
Not part of ABI.
Definition pixfmt.h:784
AVAlphaMode
Correlation between the alpha channel and color values.
Definition pixfmt.h:816
@ AVALPHA_MODE_NB
Not part of ABI.
Definition pixfmt.h:820
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
AVColorSpace
YUV colorspace type.
Definition pixfmt.h:706
@ AVCOL_SPC_NB
Not part of ABI.
Definition pixfmt.h:726
@ AVCOL_SPC_UNSPECIFIED
Definition pixfmt.h:709
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition pixfmt.h:710
const char * name
Definition qsvenc.c:142
formats
Definition signature.h:47
#define FF_ARRAY_ELEMS(a)
An AVChannelLayout holds information about the channel layout of audio data.
int nb_channels
Number of channels in this layout.
A list of supported channel layouts.
Definition formats.h:85
char all_layouts
accept any known channel layout
Definition formats.h:88
char all_counts
accept any channel layout or count
Definition formats.h:89
AVChannelLayout * channel_layouts
list of channel layouts
Definition formats.h:86
int nb_channel_layouts
number of channel layouts
Definition formats.h:87
An instance of a filter.
Definition avfilter.h:273
Lists of formats / etc.
Definition avfilter.h:120
A list of supported formats for one end of a filter link.
Definition formats.h:64
int * formats
list of media formats
Definition formats.h:66
unsigned nb_formats
number of formats
Definition formats.h:65
Callbacks and properties to describe the steps of a format negotiation.
Definition formats.h:657
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
uint64_t flags
Combination of AV_PIX_FMT_FLAG_... flags.
Definition pixdesc.h:94
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition pixdesc.h:71
#define av_free(p)
#define av_malloc_array(a, b)
#define av_mallocz(s)
#define av_freep(p)
#define av_log(a,...)
static int ref[MAX_W *MAX_W]
Definition jpeg2000dwt.c:117
static const int rates[]
Definition swresample.c:99
Generated on Sun Sep 6 2026 19:21:03 for FFmpeg by doxygen 1.13.2

AltStyle によって変換されたページ (->オリジナル) /