36 #define FF_INTERNAL_FIELDS 1 45 #define OFFSET(x) offsetof(AVFilterGraph, x) 46 #define F AV_OPT_FLAG_FILTERING_PARAM 47 #define V AV_OPT_FLAG_VIDEO_PARAM 48 #define A AV_OPT_FLAG_AUDIO_PARAM 53 {
"threads",
"Maximum number of threads",
OFFSET(nb_threads),
55 {
"scale_sws_opts" ,
"default scale filter options" ,
OFFSET(scale_sws_opts) ,
57 {
"aresample_swr_opts" ,
"default aresample filter options" ,
OFFSET(aresample_swr_opts) ,
106 if (graph->
filters[i] == filter) {
125 while ((*graph)->nb_filters)
132 av_freep(&(*graph)->scale_sws_opts);
133 av_freep(&(*graph)->aresample_swr_opts);
135 av_freep(&(*graph)->resample_lavr_opts);
143 const char *
name,
const char *args,
void *opaque,
227 "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
237 "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
320 switch (link->
type) {
438 int scaler_count = 0, resampler_count = 0;
439 int count_queried = 0;
440 int count_merged = 0;
441 int count_already_merged = 0;
442 int count_delayed = 0;
452 if (ret < 0 && ret !=
AVERROR(EAGAIN))
455 count_queried += ret >= 0;
462 for (j = 0; j < filter->
nb_inputs; j++) {
464 int convert_needed = 0;
482 #define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0) 483 #define MERGE_DISPATCH(field, ...) \ 484 if (!(link->incfg.field && link->outcfg.field)) { \ 486 } else if (link->incfg.field == link->outcfg.field) { \ 487 count_already_merged++; \ 488 } else if (!convert_needed) { \ 490 if (CHECKED_MERGE(field, __VA_ARGS__)) { \ 493 convert_needed = 1; \ 505 #undef MERGE_DISPATCH 507 if (convert_needed) {
515 "The filters '%s' and '%s' do not have a common format " 516 "and automatic conversion is disabled.\n",
522 switch (link->
type) {
526 "not present, cannot convert pixel formats.\n");
530 snprintf(inst_name,
sizeof(inst_name),
"auto_scaler_%d",
541 "not present, cannot convert audio formats.\n");
545 snprintf(inst_name,
sizeof(inst_name),
"auto_resampler_%d",
562 inlink = convert->
inputs[0];
569 av_assert0( inlink-> incfg.samplerates->refcount > 0);
571 av_assert0(outlink-> incfg.samplerates->refcount > 0);
573 av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
575 av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
595 "Impossible to convert between the formats supported by the filter " 604 "%d queried, %d merged, %d already done, %d delayed\n",
605 count_queried, count_merged, count_already_merged, count_delayed);
614 if (count_queried || count_merged)
622 "The following filters could not choose their formats: %s\n" 623 "Consider inserting the (a)format filter near their input or " 624 "output.\n", bp.str);
661 return score1 < score2 ? dst_fmt1 : dst_fmt2;
705 " the link between filters %s and %s.\n", link->
src->
name,
714 " the link between filters %s and %s.\n", link->
src->
name,
718 "supported, try specifying a channel layout using " 719 "'aformat=channel_layouts=something'.\n");
740 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \ 742 for (i = 0; i < filter->nb_inputs; i++) { \ 743 AVFilterLink *link = filter->inputs[i]; \ 746 if (!link->outcfg.list || link->outcfg.list->nb != 1) \ 748 fmt = link->outcfg.list->var[0]; \ 750 for (j = 0; j < filter->nb_outputs; j++) { \ 751 AVFilterLink *out_link = filter->outputs[j]; \ 754 if (link->type != out_link->type || \ 755 out_link->incfg.list->nb == 1) \ 757 fmts = out_link->incfg.list; \ 759 if (!out_link->incfg.list->nb) { \ 760 if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\ 766 for (k = 0; k < out_link->incfg.list->nb; k++) \ 767 if (fmts->var[k] == fmt) { \ 768 fmts->var[0] = fmt; \ 779 int i, j, k,
ret = 0;
787 for (i = 0; i < filter->
nb_inputs; i++) {
850 for (i = 0; i < filter->
nb_inputs; i++) {
864 int best_idx, best_diff = INT_MAX;
875 if (diff < best_diff) {
893 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER) 894 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT) 895 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT) 896 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT) 897 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT) 898 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT) 899 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT) 932 for (i = 0; i < filter->
nb_inputs; i++) {
944 int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
955 int count_diff = out_channels - in_channels;
956 int matched_channels, extra_channels;
968 score -= 10000 +
FFABS(out_channels - in_channels) +
969 (in_channels > out_channels ? 10000 : 0);
970 in_chlayout = out_chlayout = 0;
979 if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
980 (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
981 in_chlayout &= ~cmp0;
982 out_chlayout &= ~cmp1;
991 (out_chlayout & AV_CH_LOW_FREQUENCY))
993 in_chlayout &= ~AV_CH_LOW_FREQUENCY;
994 out_chlayout &= ~AV_CH_LOW_FREQUENCY;
1000 score += 10 * matched_channels - 5 * extra_channels;
1002 if (score > best_score ||
1003 (count_diff < best_count_diff && score == best_score)) {
1006 best_count_diff = count_diff;
1030 for (i = 0; i < filter->
nb_inputs; i++) {
1045 int best_idx = -1, best_score = INT_MIN;
1063 if (bps == 4 && out_bps == 8) {
1069 score = -
abs(out_bps - bps);
1073 if (score > best_score) {
1103 for (j = 0; j < filter->
nb_inputs; j++){
1180 int sink_links_count = 0, n = 0;
1195 if (f->
nb_inputs > INT_MAX - sink_links_count)
1200 sinks =
av_calloc(sink_links_count,
sizeof(*sinks));
1254 if (!strcmp(target,
"all") || (filter->
name && !strcmp(target, filter->
name)) || !strcmp(target, filter->
filter->
name)) {
1257 if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1275 if(filter && (!strcmp(target,
"all") || !strcmp(target, filter->
name) || !strcmp(target, filter->
filter->
name))){
1277 while (*queue && (*queue)->
time <= ts)
1278 queue = &(*queue)->
next;
1286 (*queue)->time = ts;
1287 (*queue)->flags =
flags;
1288 (*queue)->next =
next;
1305 int parent = (index - 1) >> 1;
1308 links[
index] = links[parent];
1324 int child = 2 * index + 1;
1332 links[
index] = links[child];
1349 int64_t frame_count;
AVFilterContext ** filters
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
int frame_wanted_out
True if a frame is currently wanted on the output of this filter.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
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.
int thread_type
Type of multithreading allowed for filters in this graph.
static void swap_samplerates(AVFilterGraph *graph)
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
static void swap_sample_fmts(AVFilterGraph *graph)
void avfilter_free(AVFilterContext *filter)
Free a filter context.
static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
Main libavfilter public API header.
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
int h
agreed upon image height
static int reduce_formats(AVFilterGraph *graph)
static int filter_check_formats(AVFilterContext *ctx)
Check the validity of the formats / etc.
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]
const char * av_default_item_name(void *ptr)
Return the context name.
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
enum AVMediaType type
AVFilterPad type.
#define FF_ARRAY_ELEMS(a)
static int reduce_formats_on_filter(AVFilterContext *filter)
int(* activate)(AVFilterContext *ctx)
Filter activation function.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
AVFilterPad * dstpad
input pad on the dest filter
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
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
struct AVFilterGraph * graph
filtergraph this filter belongs to
memory buffer sink API for audio and video
const char * name
Pad name.
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format)
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
AVFilterLink ** inputs
array of pointers to input links
char * name
name of this filter instance
#define av_assert0(cond)
assert() equivalent, that is always enabled.
avfilter_execute_func * execute
This callback may be set by the caller immediately after allocating the graph and before adding any f...
AVFilterPad * output_pads
array of output pads
unsigned ready
Ready status of the filter.
#define AV_CH_LOW_FREQUENCY
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.
static int pick_formats(AVFilterGraph *graph)
int nb_threads
Maximum number of threads used by filters in this graph.
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
#define AVERROR_EOF
End of file.
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
A filter pad used for either input or output.
A link between two filters.
AVFilterPad * input_pads
array of input pads
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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 sample_rate
samples per second
unsigned nb_outputs
number of output pads
int64_t current_pts_us
Current timestamp of the link, as defined by the most recent frame(s), in AV_TIME_BASE units...
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
uint64_t * channel_layouts
list of channel layouts
simple assert() macros that are a bit more flexible than ISO C assert().
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.
static void heap_bubble_down(AVFilterGraph *graph, AVFilterLink *link, int index)
AVFilterLink ** sink_links
Private fields.
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.
char all_counts
accept any channel layout or count
int w
agreed upon image width
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
common internal API header
static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
Configure the formats of all the links in the graph.
uint8_t nb_components
The number of components each pixel has, (1-4)
audio channel layout utility functions
static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
unsigned nb_inputs
number of input pads
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static void swap_sample_fmts_on_filter(AVFilterContext *filter)
struct AVFilterCommand * next
static const AVOption filtergraph_options[]
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
Check for the validity of graph.
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 FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
AVFilterContext * src
source filter
#define AVFILTER_CMD_FLAG_ONE
Stop once a filter understood the command (for target=all for example), fast filters are favored auto...
#define AV_CH_FRONT_CENTER
static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2, enum AVSampleFormat src_fmt)
int age_index
Index in the age array.
int format
agreed upon media format
A list of supported channel layouts.
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
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.
void ff_graph_thread_free(AVFilterGraph *graph)
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
AVSampleFormat
Audio sample formats.
static void heap_bubble_up(AVFilterGraph *graph, AVFilterLink *link, int index)
static int formats_declared(AVFilterContext *f)
AVFilterGraphInternal * internal
Opaque object for libavfilter internal use.
char all_layouts
accept any known channel layout
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
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.
static const uint16_t channel_layouts[7]
Describe the class of an AVClass context structure.
int(* query_formats)(AVFilterContext *)
Query formats supported by the filter on its inputs and outputs.
#define AVFILTER_CMD_FLAG_FAST
Only execute command when its fast (like a video out that supports contrast adjustment in hw) ...
static int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg)
const char * name
Filter 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 link
AVFilterLink ** outputs
array of pointers to output links
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
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.
#define flags(name, subs,...)
enum AVMediaType type
filter media type
#define AV_CH_BACK_CENTER
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
Perform one round of query_formats() and merging formats lists on the filter graph.
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
struct AVFilterGraph * graph
Graph the filter belongs to.
int ff_graph_thread_init(AVFilterGraph *graph)
static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
Configure all the links of graphctx.
static void swap_channel_layouts(AVFilterGraph *graph)
static const int8_t filt[NUMTAPS *2]
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]
int nb_channel_layouts
number of channel layouts
struct AVFilterCommand * command_queue
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
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.
static int convert(AVFilterContext *ctx, void *data, int job_nr, int n_jobs)
int channels
Number of channels.
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...
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
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...
static void swap_samplerates_on_filter(AVFilterContext *filter)
char * aresample_swr_opts
swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions ...
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
#define AV_BUFFERSINK_FLAG_PEEK
Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from th...
static av_always_inline int diff(const uint32_t a, const uint32_t b)
avfilter_execute_func * thread_execute
#define MERGE_DISPATCH(field,...)
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
AVFilterContext * dst
dest filter
static const struct PPFilter filters[]
unsigned refcount
number of references to this list
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
Init a global structure.
static int graph_check_links(AVFilterGraph *graph, AVClass *log_ctx)
static const AVClass filtergraph_class
FFFrameQueueGlobal frame_queues
double time
time expressed in seconds
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
#define FFSWAP(type, a, b)
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.
static int filter_query_formats(AVFilterContext *ctx)
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 ff_filter_activate(AVFilterContext *filter)
AVPixelFormat
Pixel format.
#define CHECKED_MERGE(field,...)
const AVFilter * filter
the AVFilter of which this is an instance
unsigned disable_auto_convert
static int graph_config_pointers(AVFilterGraph *graph, AVClass *log_ctx)