Go to the documentation of this file.
35 #define MERGE_REF(ret, a, fmts, type, fail_statement) \
40 if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
45 for (i = 0; i < a->refcount; i ++) { \
46 ret->refs[ret->refcount] = a->refs[i]; \
47 *ret->refs[ret->refcount++] = ret; \
62 #define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
64 int i, j, k = 0, skip = 0; \
66 if (empty_allowed) { \
67 if (!a->nb || !b->nb) { \
71 FFSWAP(type *, a, b); \
76 for (i = 0; i < a->nb; i++) \
77 for (j = 0; j < b->nb; j++) \
78 if (a->fmts[i] == b->fmts[j]) { \
81 a->fmts[k++] = a->fmts[i]; \
92 MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
99 int alpha1=0, alpha2=0;
100 int chroma1=0, chroma2=0;
115 for (
i = 0;
i <
a->nb_formats;
i++) {
117 for (j = 0; j <
b->nb_formats; j++) {
121 if (
a->formats[
i] ==
b->formats[j]) {
129 if (alpha2 > alpha1 || chroma2 > chroma1)
188 if (
a ==
b)
return 1;
217 unsigned a_all =
a->all_layouts +
a->all_counts;
218 unsigned b_all =
b->all_layouts +
b->all_counts;
219 int ret_max, ret_nb = 0,
i, j,
round;
223 if (
a ==
b)
return 1;
228 FFSWAP(
unsigned, a_all, b_all);
231 if (a_all == 1 && !b_all) {
233 for (
i = j = 0;
i <
b->nb_channel_layouts;
i++)
234 if (
KNOWN(&
b->channel_layouts[
i]) &&
i != j++) {
243 b->nb_channel_layouts = j;
249 ret_max =
a->nb_channel_layouts +
b->nb_channel_layouts;
254 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
255 if (!
KNOWN(&
a->channel_layouts[
i]))
257 for (j = 0; j <
b->nb_channel_layouts; j++) {
271 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
276 for (j = 0; j <
b->nb_channel_layouts; j++)
287 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
288 if (
KNOWN(&
a->channel_layouts[
i]))
290 for (j = 0; j <
b->nb_channel_layouts; j++)
303 if (
a->refcount >
b->refcount)
310 b->nb_channel_layouts = ret_nb;
388 .conversion_filter =
"scale",
389 .conversion_opts_offset = offsetof(
AVFilterGraph, scale_sws_opts),
395 .conversion_filter =
"aresample",
396 .conversion_opts_offset = offsetof(
AVFilterGraph, aresample_swr_opts),
401 switch (
link->type) {
404 default:
return NULL;
412 for (p = fmts; *p != -1; p++) {
419 #define MAKE_FORMAT_LIST(type, field, count_field) \
423 for (count = 0; fmts[count] != -1; count++) \
425 formats = av_mallocz(sizeof(*formats)); \
428 formats->count_field = count; \
430 formats->field = av_malloc_array(count, sizeof(*formats->field)); \
431 if (!formats->field) { \
432 av_freep(&formats); \
441 formats->formats[count] = fmts[count];
464 for (
int i = 0;
i < count;
i++) {
474 for (
int i = 0;
i < count;
i++)
482 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
486 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
487 return AVERROR(ENOMEM); \
490 fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
491 sizeof(*(*f)->list)); \
494 return AVERROR(ENOMEM); \
498 ASSIGN_FMT(f, fmt, list, nb); \
501 #define ASSIGN_FMT(f, fmt, list, nb) \
503 (*f)->list[(*f)->nb++] = fmt; \
513 #define ASSIGN_FMT(f, fmt, list, nb) \
516 memset((*f)->list + (*f)->nb, 0, sizeof(*(*f)->list)); \
517 ret = av_channel_layout_copy(&(*f)->list[(*f)->nb], fmt); \
533 int fmts[2] = { fmt, -1 };
557 unsigned nb_formats, fmt,
flags;
562 for (fmt = 0;; fmt++) {
569 (
desc->log2_chroma_w ||
desc->log2_chroma_h))
571 if ((
flags & (want | rej)) != want)
574 formats->formats[nb_formats] = fmt;
584 formats->nb_formats = nb_formats;
619 ret->all_layouts = 1;
628 ret->all_layouts =
ret->all_counts = 1;
659 #define FORMATS_REF(f, ref, unref_fn) \
663 return AVERROR(ENOMEM); \
665 tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
668 return AVERROR(ENOMEM); \
671 f->refs[f->refcount++] = ref; \
685 #define FIND_REF_INDEX(ref, idx) \
688 for (i = 0; i < (*ref)->refcount; i ++) \
689 if((*ref)->refs[i] == ref) { \
695 #define FORMATS_UNREF(ref, list) \
702 FIND_REF_INDEX(ref, idx); \
705 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
706 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
707 --(*ref)->refcount; \
709 if (!(*ref)->refcount) { \
710 FREE_LIST(ref, list); \
711 av_free((*ref)->list); \
712 av_free((*ref)->refs); \
718 #define FREE_LIST(ref, list) do { } while(0)
725 #define FREE_LIST(ref, list) \
727 for (int i = 0; i < (*ref)->nb_channel_layouts; i++) \
728 av_channel_layout_uninit(&(*ref)->list[i]); \
736 #define FORMATS_CHANGEREF(oldref, newref) \
740 FIND_REF_INDEX(oldref, idx); \
743 (*oldref)->refs[idx] = newref; \
760 #define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
764 return AVERROR(ENOMEM); \
766 for (i = 0; i < ctx->nb_inputs; i++) { \
767 AVFilterLink *const link = ctx->inputs[i]; \
768 if (link && !link->outcfg.fmts && \
769 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
770 int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
776 for (i = 0; i < ctx->nb_outputs; i++) { \
777 AVFilterLink *const link = ctx->outputs[i]; \
778 if (link && !link->incfg.fmts && \
779 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
780 int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
787 if (!fmts->refcount) \
818 const int *samplerates)
836 const int *color_ranges)
854 const int *color_ranges)
887 switch (
f->formats_state) {
911 ctx->nb_outputs ?
ctx->outputs[0]->type :
960 if (*tail || srate < 1 || (
int)srate != srate || srate > INT_MAX) {
A list of supported channel layouts.
AVPixelFormat
Pixel format.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
@ AVCOL_SPC_NB
Not part of ABI.
enum AVChannelOrder order
Channel order used in this layout.
int nb_channels
Number of channels in this layout.
A link between two filters.
@ FF_FILTER_FORMATS_SAMPLEFMTS_LIST
formats.samples_list active.
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
@ AVCOL_RANGE_NB
Not part of ABI.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Callbacks and properties to describe the steps of a format negotiation.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
@ FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
formats.sample_fmt active.
#define check(x, y, S, v)
static enum AVPixelFormat pix_fmt
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
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.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
uint8_t nb_components
The number of components each pixel has, (1-4)
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
An AVChannelLayout holds information about the channel layout of audio data.
AVChannelLayout * channel_layouts
list of channel layouts
char all_layouts
accept any known channel layout
char all_counts
accept any channel layout or count
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
#define i(width, name, range_min, range_max)
static av_always_inline av_const double round(double x)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
@ FF_FILTER_FORMATS_PASSTHROUGH
The default value meaning that this filter supports all formats and (for audio) sample rates and chan...
#define av_malloc_array(a, b)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
AVSampleFormat
Audio sample formats.
static const AVChannelLayout ch_layouts[]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_calloc(size_t nmemb, size_t size)
#define FFSWAP(type, a, b)
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
static int ref[MAX_W *MAX_W]
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
int nb_channel_layouts
number of channel layouts
@ FF_FILTER_FORMATS_PIXFMT_LIST
formats.pixels_list active.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const uint16_t channel_layouts[7]
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
#define flags(name, subs,...)
@ FF_FILTER_FORMATS_SINGLE_PIXFMT
formats.pix_fmt active