Go to the documentation of this file.
34 #define FF_INTERNAL_FIELDS 1
43 #define OFFSET(x) offsetof(AVFilterGraph, x)
44 #define F AV_OPT_FLAG_FILTERING_PARAM
45 #define V AV_OPT_FLAG_VIDEO_PARAM
46 #define A AV_OPT_FLAG_AUDIO_PARAM
52 { .i64 = 0 }, 0, INT_MAX,
F|
V|
A,
"threads"},
53 {
"auto",
"autodetect a suitable number of threads to use", 0,
AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags =
F|
V|
A, .unit =
"threads"},
54 {
"scale_sws_opts" ,
"default scale filter options" ,
OFFSET(scale_sws_opts) ,
56 {
"aresample_swr_opts" ,
"default aresample filter options" ,
OFFSET(aresample_swr_opts) ,
110 for (j = 0; j<
filter->nb_outputs; j++)
124 while ((*graph)->nb_filters)
139 const char *
name,
const char *args,
void *opaque,
216 for (j = 0; j <
filt->nb_inputs; j++) {
217 if (!
filt->inputs[j] || !
filt->inputs[j]->src) {
218 pad = &
filt->input_pads[j];
220 "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
226 for (j = 0; j <
filt->nb_outputs; j++) {
227 if (!
filt->outputs[j] || !
filt->outputs[j]->dst) {
228 pad = &
filt->output_pads[j];
230 "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
253 if (!
filt->nb_outputs) {
271 for (j = 0; j <
f->nb_outputs; j++) {
298 switch (
link->type) {
328 for (
i = 0;
i <
ctx->nb_inputs;
i++) {
333 for (
i = 0;
i <
ctx->nb_outputs;
i++) {
347 ctx->outputs &&
ctx->outputs[0] ?
ctx->outputs[0]->type :
350 if ((
ret =
ctx->filter->formats.query_func(
ctx)) < 0) {
377 for (
i = 0;
i <
f->nb_inputs;
i++) {
378 if (!
f->inputs[
i]->outcfg.formats)
381 !(
f->inputs[
i]->outcfg.samplerates &&
382 f->inputs[
i]->outcfg.channel_layouts))
385 for (
i = 0;
i <
f->nb_outputs;
i++) {
386 if (!
f->outputs[
i]->incfg.formats)
389 !(
f->outputs[
i]->incfg.samplerates &&
390 f->outputs[
i]->incfg.channel_layouts))
409 int converter_count = 0;
410 int count_queried = 0;
411 int count_merged = 0;
412 int count_already_merged = 0;
413 int count_delayed = 0;
426 count_queried +=
ret >= 0;
433 for (j = 0; j <
filter->nb_inputs; j++) {
437 int convert_needed = 0;
444 for (neg_step = 1; neg_step < neg->
nb_mergers; neg_step++) {
445 const AVFilterFormatsMerger *m = &neg->
mergers[neg_step];
448 if (
a &&
b &&
a !=
b && !m->can_merge(
a,
b)) {
453 for (neg_step = 0; neg_step < neg->
nb_mergers; neg_step++) {
454 const AVFilterFormatsMerger *m = &neg->
mergers[neg_step];
460 count_already_merged++;
461 }
else if (!convert_needed) {
463 ret = m->merge(
a,
b);
471 if (convert_needed) {
480 "The filters '%s' and '%s' do not have a common format "
481 "and automatic conversion is disabled.\n",
489 "'%s' filter not present, cannot convert formats.\n",
493 snprintf(inst_name,
sizeof(inst_name),
"auto_%s_%d",
514 av_assert0(outlink-> incfg.samplerates->refcount > 0);
518 av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
521 #define MERGE(merger, link) \
522 ((merger)->merge(FF_FIELD_AT(void *, (merger)->offset, (link)->incfg), \
523 FF_FIELD_AT(void *, (merger)->offset, (link)->outcfg)))
524 for (neg_step = 0; neg_step < neg->
nb_mergers; neg_step++) {
525 const AVFilterFormatsMerger *m = &neg->
mergers[neg_step];
531 "Impossible to convert between the formats supported by the filter "
532 "'%s' and the filter '%s'\n",
link->src->name,
link->dst->name);
541 "%d queried, %d merged, %d already done, %d delayed\n",
542 count_queried, count_merged, count_already_merged, count_delayed);
551 if (count_queried || count_merged)
559 "The following filters could not choose their formats: %s\n"
560 "Consider inserting the (a)format filter near their input or "
561 "output.\n", bp.str);
598 return score1 < score2 ? dst_fmt1 : dst_fmt2;
612 for (
i = 0;
i <
link->incfg.formats->nb_formats;
i++) {
619 link->incfg.formats->formats[0] = best;
625 for (
i = 0;
i <
link->incfg.formats->nb_formats;
i++) {
632 link->incfg.formats->formats[0] = best;
636 link->incfg.formats->nb_formats = 1;
642 if (!
link->incfg.samplerates->nb_formats) {
644 " the link between filters %s and %s.\n",
link->src->name,
648 link->incfg.samplerates->nb_formats = 1;
651 if (
link->incfg.channel_layouts->all_layouts) {
653 " the link between filters %s and %s.\n",
link->src->name,
655 if (!
link->incfg.channel_layouts->all_counts)
657 "supported, try specifying a channel layout using "
658 "'aformat=channel_layouts=something'.\n");
661 link->incfg.channel_layouts->nb_channel_layouts = 1;
665 #if FF_API_OLD_CHANNEL_LAYOUT
683 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
685 for (i = 0; i < filter->nb_inputs; i++) { \
686 AVFilterLink *link = filter->inputs[i]; \
689 if (!link->outcfg.list || link->outcfg.list->nb != 1) \
691 fmt = link->outcfg.list->var[0]; \
693 for (j = 0; j < filter->nb_outputs; j++) { \
694 AVFilterLink *out_link = filter->outputs[j]; \
697 if (link->type != out_link->type || \
698 out_link->incfg.list->nb == 1) \
700 fmts = out_link->incfg.list; \
702 if (!out_link->incfg.list->nb) { \
703 if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
709 for (k = 0; k < out_link->incfg.list->nb; k++) \
710 if (fmts->var[k] == fmt) { \
711 fmts->var[0] = fmt; \
722 int i, j, k,
ret = 0;
730 for (
i = 0;
i <
filter->nb_inputs;
i++) {
734 if (!
inlink->outcfg.channel_layouts ||
735 inlink->outcfg.channel_layouts->nb_channel_layouts != 1)
739 for (j = 0; j <
filter->nb_outputs; j++) {
794 for (
i = 0;
i <
filter->nb_inputs;
i++) {
798 link->outcfg.samplerates->nb_formats== 1)
806 for (
i = 0;
i <
filter->nb_outputs;
i++) {
808 int best_idx, best_diff = INT_MAX;
819 if (
diff < best_diff) {
837 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
838 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
839 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
840 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
841 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
842 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
843 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
876 for (
i = 0;
i <
filter->nb_inputs;
i++) {
880 link->outcfg.channel_layouts->nb_channel_layouts == 1)
886 for (
i = 0;
i <
filter->nb_outputs;
i++) {
888 int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
899 int matched_channels, extra_channels;
905 out_channels = out_chlayout.nb_channels;
906 count_diff = out_channels - in_channels;
907 if (!
KNOWN(&in_chlayout) || !
KNOWN(&out_chlayout)) {
912 if (!
KNOWN(&in_chlayout))
914 if (!
KNOWN(&out_chlayout))
916 score -= 10000 +
FFABS(out_channels - in_channels) +
917 (in_channels > out_channels ? 10000 : 0);
949 score += 10 * matched_channels - 5 * extra_channels;
951 if (score > best_score ||
952 (count_diff < best_count_diff && score == best_score)) {
955 best_count_diff = count_diff;
979 for (
i = 0;
i <
filter->nb_inputs;
i++) {
983 link->outcfg.formats->nb_formats == 1)
992 for (
i = 0;
i <
filter->nb_outputs;
i++) {
994 int best_idx = -1, best_score = INT_MIN;
1012 if (
bps == 4 && out_bps == 8) {
1018 score = -
abs(out_bps -
bps);
1022 if (score > best_score) {
1052 for (j = 0; j <
filter->nb_inputs; j++){
1053 if (
filter->inputs[j]->incfg.formats &&
filter->inputs[j]->incfg.formats->nb_formats == 1) {
1061 for (j = 0; j <
filter->nb_outputs; j++){
1062 if (
filter->outputs[j]->incfg.formats &&
filter->outputs[j]->incfg.formats->nb_formats == 1) {
1070 for (j = 0; j <
filter->nb_outputs; j++) {
1071 if (
filter->outputs[j]->format<0) {
1084 for (j = 0; j <
filter->nb_inputs; j++)
1087 for (j = 0; j <
filter->nb_outputs; j++)
1128 int sink_links_count = 0, n = 0;
1134 for (j = 0; j <
f->nb_inputs; j++) {
1135 f->inputs[j]->graph = graph;
1136 f->inputs[j]->age_index = -1;
1138 for (j = 0; j <
f->nb_outputs; j++) {
1139 f->outputs[j]->graph = graph;
1140 f->outputs[j]->age_index= -1;
1142 if (!
f->nb_outputs) {
1143 if (
f->nb_inputs > INT_MAX - sink_links_count)
1145 sink_links_count +=
f->nb_inputs;
1148 sinks =
av_calloc(sink_links_count,
sizeof(*sinks));
1153 if (!
f->nb_outputs) {
1154 for (j = 0; j <
f->nb_inputs; j++) {
1155 sinks[n] =
f->inputs[j];
1156 f->inputs[j]->age_index = n++;
1202 if (!strcmp(target,
"all") || (
filter->name && !strcmp(target,
filter->name)) || !strcmp(target,
filter->filter->name)) {
1223 if(
filter && (!strcmp(target,
"all") || !strcmp(target,
filter->name) || !strcmp(target,
filter->filter->name))){
1225 while (*queue && (*queue)->
time <= ts)
1226 queue = &(*queue)->
next;
1234 (*queue)->time = ts;
1235 (*queue)->flags =
flags;
1236 (*queue)->next =
next;
1253 int parent = (
index - 1) >> 1;
1254 if (
links[parent]->current_pts_us >=
link->current_pts_us)
1272 int child = 2 *
index + 1;
1276 links[child + 1]->current_pts_us <
links[child]->current_pts_us)
1278 if (
link->current_pts_us <
links[child]->current_pts_us)
1297 int64_t frame_count;
avfilter_execute_func * execute
This callback may be set by the caller immediately after allocating the graph and before adding any f...
#define FF_ENABLE_DEPRECATION_WARNINGS
A list of supported channel layouts.
#define AVFILTER_CMD_FLAG_ONE
Stop once a filter understood the command (for target=all for example), fast filters are favored auto...
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
int nb_threads
Maximum number of threads used by filters in this graph.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
static const uint64_t ch_subst[][2]
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int frame_wanted_out
True if a frame is currently wanted on the output of this filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AVERROR_EOF
End of file.
AVFilterPad * dstpad
input pad on the dest filter
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
static int filter_query_formats(AVFilterContext *ctx)
int ff_filter_activate(AVFilterContext *filter)
static void swap_sample_fmts(AVFilterGraph *graph)
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
const char * conversion_filter
static int graph_check_validity(AVFilterGraph *graph, void *log_ctx)
Check for the validity of graph.
static int query_formats(AVFilterGraph *graph, void *log_ctx)
Perform one round of query_formats() and merging formats lists on the filter graph.
static int pick_formats(AVFilterGraph *graph)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
unsigned disable_auto_convert
uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout, uint64_t mask)
Find out what channels from a given set are present in a channel layout, without regard for their pos...
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
enum AVChannelOrder order
Channel order used in this layout.
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
int nb_channels
Number of channels in this layout.
A link between two filters.
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
static void convert(float y, float u, float v, float *b, float *g, float *r)
static void swap_samplerates(AVFilterGraph *graph)
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
static int reduce_formats(AVFilterGraph *graph)
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
Insert a filter in the middle of an existing link.
static int graph_config_formats(AVFilterGraph *graph, void *log_ctx)
Configure the formats of all the links in the graph.
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
#define AV_BPRINT_SIZE_AUTOMATIC
AVChannelLayout ch_layout
Channel layout of the audio data.
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
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Callbacks and properties to describe the steps of a format negotiation.
static void heap_bubble_down(AVFilterGraph *graph, AVFilterLink *link, int index)
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
A filter pad used for either input or output.
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
static int reduce_formats_on_filter(AVFilterContext *filter)
enum AVMediaType type
filter media type
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
#define MERGE(merger, link)
attribute_deprecated uint64_t channel_layout
Channel layout of the audio data.
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
#define AV_CH_LOW_FREQUENCY
#define AV_BUFFERSINK_FLAG_PEEK
Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from th...
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
#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.
static const AVOption filtergraph_options[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static int graph_config_pointers(AVFilterGraph *graph, void *log_ctx)
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.
const AVFilterFormatsMerger * mergers
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int(* activate)(AVFilterContext *ctx)
Filter activation function.
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
union AVChannelLayout::@296 u
Details about which channels are present in this layout.
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
uint8_t nb_components
The number of components each pixel has, (1-4)
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
AVFilterContext ** filters
const char * av_default_item_name(void *ptr)
Return the context name.
char * name
name of this filter instance
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
static void heap_bubble_up(AVFilterGraph *graph, AVFilterLink *link, int index)
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
void av_opt_free(void *obj)
Free all allocated objects in obj.
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
static int graph_config_links(AVFilterGraph *graph, void *log_ctx)
Configure all the links of graphctx.
#define AV_CH_FRONT_CENTER
@ AV_CLASS_CATEGORY_FILTER
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
void ff_graph_thread_free(AVFilterGraph *graph)
An AVChannelLayout holds information about the channel layout of audio data.
struct AVFilterCommand * next
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int sample_rate
Sample rate of the audio data.
int format
agreed upon media format
int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
Queue a command for one or more filter instances.
AVChannelLayout * channel_layouts
list of channel layouts
AVFilterContext * dst
dest filter
char all_layouts
accept any known channel layout
char all_counts
accept any channel layout or count
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
avfilter_execute_func * thread_execute
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
static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2, enum AVSampleFormat src_fmt)
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
static int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg)
static void swap_sample_fmts_on_filter(AVFilterContext *filter)
int age_index
Index in the age array.
#define i(width, name, range_min, range_max)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
int w
agreed upon image width
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
static int graph_check_links(AVFilterGraph *graph, void *log_ctx)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
AVSampleFormat
Audio sample formats.
#define AV_CH_BACK_CENTER
AVFilterGraphInternal * internal
Opaque object for libavfilter internal use.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int thread_type
Type of multithreading allowed for filters in this graph.
static const int8_t filt[NUMTAPS *2]
const char * name
Pad name.
void * av_calloc(size_t nmemb, size_t size)
int ff_graph_thread_init(AVFilterGraph *graph)
enum AVChannel av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx)
Get the channel with the given index in a channel layout.
static void swap_channel_layouts(AVFilterGraph *graph)
#define AVFILTER_CMD_FLAG_FAST
Only execute command when its fast (like a video out that supports contrast adjustment in hw)
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
AVFilterLink ** sink_links
Private fields.
enum AVMediaType type
AVFilterPad type.
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 links
#define FFSWAP(type, a, b)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
unsigned conversion_opts_offset
void av_bprintf(AVBPrint *buf, const char *fmt,...)
static int formats_declared(AVFilterContext *f)
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr)
Compute what kind of losses will occur when converting from one specific pixel format to another.
int h
agreed upon image height
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
Init a global structure.
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
static int ref[MAX_W *MAX_W]
#define FF_DISABLE_DEPRECATION_WARNINGS
char * av_strdup(const char *s)
Duplicate a string.
int nb_channel_layouts
number of channel layouts
void avfilter_free(AVFilterContext *filter)
Free a filter context.
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static void swap_samplerates_on_filter(AVFilterContext *filter)
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
#define flags(name, subs,...)
int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
Send a command to one or more filter instances.
#define FF_FIELD_AT(type, off, obj)
Access a field in a structure by its offset.
const AVFilter * filter
the AVFilter of which this is an instance
unsigned refcount
number of references to this list
static int filter_check_formats(AVFilterContext *ctx)
Check the validity of the formats / etc.
@ AV_SAMPLE_FMT_S32
signed 32 bits
static const AVClass filtergraph_class
unsigned ready
Ready status of the filter.
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
double time
time expressed in seconds