#include <stdint.h>
#include "ffmpeg.h"
#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"
#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/bprint.h"
#include "libavutil/channel_layout.h"
#include "libavutil/display.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/pixfmt.h"
#include "libavutil/imgutils.h"
#include "libavutil/samplefmt.h"

Macros
#define	DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name)

#define	AUTO_INSERT_FILTER(opt_name, filter_name, arg)

#define	AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg)

Functions
static enum AVPixelFormat *	get_compliance_normal_pix_fmts (const AVCodec *codec, const enum AVPixelFormat default_formats[])

static enum AVPixelFormat	choose_pixel_fmt (AVStream st, AVCodecContext enc_ctx, const AVCodec *codec, enum AVPixelFormat target)

static const char *	choose_pix_fmts (OutputFilter ofilter, AVBPrint bprint)

	DEF_CHOOSE_FORMAT (sample_fmts, enum AVSampleFormat, format, formats, AV_SAMPLE_FMT_NONE, "%s", av_get_sample_fmt_name) DEF_CHOOSE_FORMAT(sample_rates

	DEF_CHOOSE_FORMAT (channel_layouts, uint64_t, channel_layout, channel_layouts, 0, "0x%"PRIx64,) int init_simple_filtergraph(InputStream *ist

	if (!fg) exit_program(1)

	if (!ifilter->frame_queue) exit_program(1)

	GROW_ARRAY (ist->filters, ist->nb_filters)

	GROW_ARRAY (filtergraphs, nb_filtergraphs)

static char *	describe_filter_link (FilterGraph fg, AVFilterInOut inout, int in)

static void	init_input_filter (FilterGraph fg, AVFilterInOut in)

int	init_complex_filtergraph (FilterGraph *fg)

static int	insert_trim (int64_t start_time, int64_t duration, AVFilterContext *last_filter, int pad_idx, const char *filter_name)

static int	insert_filter (AVFilterContext *last_filter, int pad_idx, const char filter_name, const char args)

static int	configure_output_video_filter (FilterGraph fg, OutputFilter ofilter, AVFilterInOut *out)

static int	configure_output_audio_filter (FilterGraph fg, OutputFilter ofilter, AVFilterInOut *out)

static int	configure_output_filter (FilterGraph fg, OutputFilter ofilter, AVFilterInOut *out)

void	check_filter_outputs (void)

static int	sub2video_prepare (InputStream ist, InputFilter ifilter)

static int	configure_input_video_filter (FilterGraph fg, InputFilter ifilter, AVFilterInOut *in)

static int	configure_input_audio_filter (FilterGraph fg, InputFilter ifilter, AVFilterInOut *in)

static int	configure_input_filter (FilterGraph fg, InputFilter ifilter, AVFilterInOut *in)

static void	cleanup_filtergraph (FilterGraph *fg)

static int	filter_is_buffersrc (const AVFilterContext *f)

static int	graph_is_meta (AVFilterGraph *graph)

int	configure_filtergraph (FilterGraph *fg)

int	ifilter_parameters_from_frame (InputFilter ifilter, const AVFrame frame)

int	filtergraph_is_simple (FilterGraph *fg)

Variables
	int

	sample_rate

	sample_rates

	d

OutputStream *	ost

OutputFilter *	ofilter = ALLOC_ARRAY_ELEM(fg->outputs, fg->nb_outputs)

InputFilter *	ifilter = ALLOC_ARRAY_ELEM(fg->inputs, fg->nb_inputs)

fg	index = nb_filtergraphs

ofilter	graph = fg

ofilter	format = -1

ost	filter = ofilter

ifilter	ist = ist

ifilter	frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*))

ist	filters [ist->nb_filters - 1] = ifilter

	filtergraphs [nb_filtergraphs - 1] = fg

	return

Macro Definition Documentation

◆ DEF_CHOOSE_FORMAT

#define DEF_CHOOSE_FORMAT	(	name,
		type,
		var,
		supported_list,
		none,
		printf_format,
		get_name
	)

Value:

static void choose_ ## name (OutputFilter *ofilter, AVBPrint *bprint)          \
{                                                                              \
    if (ofilter->var == none && !ofilter->supported_list)                      \
        return;                                                                \
    av_bprintf(bprint, #name "=");                                             \
    if (ofilter->var != none) {                                                \
        av_bprintf(bprint, printf_format, get_name(ofilter->var));             \
    } else {                                                                   \
        const type *p;                                                         \
                                                                               \
        for (p = ofilter->supported_list; *p != none; p++) {                   \
            av_bprintf(bprint, printf_format "|", get_name(*p));               \
        }                                                                      \
        if (bprint->len > 0)                                                   \
            bprint->str[--bprint->len] = '\0';                                 \
    }                                                                          \
    av_bprint_chars(bprint, ':', 1);                                           \
}

Definition at line 127 of file ffmpeg_filter.c.

◆ AUTO_INSERT_FILTER

#define AUTO_INSERT_FILTER	(	opt_name,
		filter_name,
		arg
	)

Value:

    do {                 \
    AVFilterContext *filt_ctx;                                              \
                                                                            \
    av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
           "similarly to -af " filter_name "=%s.\n", arg);                  \
                                                                            \
    ret = avfilter_graph_create_filter(&filt_ctx,                           \
                                       avfilter_get_by_name(filter_name),   \
                                       filter_name, arg, NULL, fg->graph);  \
    if (ret < 0)                                                            \
        goto fail;                                                          \
                                                                            \
    ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0);                 \
    if (ret < 0)                                                            \
        goto fail;                                                          \
                                                                            \
    last_filter = filt_ctx;                                                 \
    pad_idx = 0;                                                            \
} while (0)

◆ AUTO_INSERT_FILTER_INPUT

#define AUTO_INSERT_FILTER_INPUT	(	opt_name,
		filter_name,
		arg
	)

Value:

    do {                 \
    AVFilterContext *filt_ctx;                                              \
                                                                            \
    av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
           "similarly to -af " filter_name "=%s.\n", arg);                  \
                                                                            \
    snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d",      \
                fg->index, filter_name, ist->file_index, ist->st->index);   \
    ret = avfilter_graph_create_filter(&filt_ctx,                           \
                                       avfilter_get_by_name(filter_name),   \
                                       name, arg, NULL, fg->graph);         \
    if (ret < 0)                                                            \
        return ret;                                                         \
                                                                            \
    ret = avfilter_link(last_filter, 0, filt_ctx, 0);                       \
    if (ret < 0)                                                            \
        return ret;                                                         \
                                                                            \
    last_filter = filt_ctx;                                                 \
} while (0)