Go to the documentation of this file.
48 if (!strcmp(codec->
name,
"mjpeg")) {
51 return default_formats;
57 int strict_std_compliance)
63 int has_alpha =
desc ?
desc->nb_components % 2 == 0 : 0;
77 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
99 if (
ost->keep_pix_fmt) {
108 ost->enc_ctx->strict_std_compliance));
130 #define DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name) \
131 static void choose_ ## name (OutputFilter *ofilter, AVBPrint *bprint) \
133 if (ofilter->var == none && !ofilter->supported_list) \
135 av_bprintf(bprint, #name "="); \
136 if (ofilter->var != none) { \
137 av_bprintf(bprint, printf_format, get_name(ofilter->var)); \
141 for (p = ofilter->supported_list; *p != none; p++) { \
142 av_bprintf(bprint, printf_format "|", get_name(*p)); \
144 if (bprint->len > 0) \
145 bprint->str[--bprint->len] = '\0'; \
147 av_bprint_chars(bprint, ':', 1); \
164 }
else if (ofilter->ch_layouts) {
168 for (p = ofilter->ch_layouts; p->
nb_channels; p++) {
173 bprint->str[--bprint->len] =
'\0';
194 ost->filter = ofilter;
218 int nb_pads = in ?
ctx->nb_inputs :
ctx->nb_outputs;
249 int file_idx = strtol(in->
name, &p, 0);
258 for (
i = 0;
i <
s->nb_streams;
i++) {
259 enum AVMediaType stream_type =
s->streams[
i]->codecpar->codec_type;
260 if (stream_type !=
type &&
277 "matches a disabled input stream.\n", p, fg->
graph_desc);
290 "unlabeled input pad %d on filter %s\n", in->
pad_idx,
334 if (fsize < 0 || fsize > INT_MAX) {
408 "Error applying option '%s' to filter '%s': %s\n",
413 "Error loading value for option '%s' from file '%s'\n",
507 const char *filter_name)
522 "recording time.\n",
name);
557 const char *filter_name,
const char *args)
565 filter_name, args,
NULL, graph);
584 int pad_idx =
out->pad_idx;
602 snprintf(args,
sizeof(args),
"%d:%d",
638 if (
ost->frame_rate.num && 0) {
642 snprintf(args,
sizeof(args),
"fps=%d/%d",
ost->frame_rate.num,
643 ost->frame_rate.den);
661 &last_filter, &pad_idx,
name);
678 int pad_idx =
out->pad_idx;
692 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
693 AVFilterContext *filt_ctx; \
695 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
696 "similarly to -af " filter_name "=%s.\n", arg); \
698 ret = avfilter_graph_create_filter(&filt_ctx, \
699 avfilter_get_by_name(filter_name), \
700 filter_name, arg, NULL, fg->graph); \
704 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \
708 last_filter = filt_ctx; \
712 #if FFMPEG_OPT_MAP_CHANNEL
713 if (
ost->audio_channels_mapped) {
718 for (
i = 0;
i <
ost->audio_channels_mapped;
i++)
719 if (
ost->audio_channels_map[
i] != -1)
730 choose_sample_fmts(ofilter, &args);
731 choose_sample_rates(ofilter, &args);
771 &last_filter, &pad_idx,
name);
874 int ret, pad_idx = 0;
875 int64_t tsoffset = 0;
880 memset(par, 0,
sizeof(*par));
903 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:"
904 "pixel_aspect=%d/%d",
921 last_filter = ifilter->
filter;
935 if (
fabs(theta - 90) < 1.0) {
937 displaymatrix[3] > 0 ?
"cclock_flip" :
"clock");
938 }
else if (
fabs(theta - 180) < 1.0) {
939 if (displaymatrix[0] < 0) {
944 if (displaymatrix[4] < 0) {
947 }
else if (
fabs(theta - 270) < 1.0) {
949 displaymatrix[3] < 0 ?
"clock_flip" :
"cclock");
950 }
else if (
fabs(theta) > 1.0) {
952 snprintf(rotate_buf,
sizeof(rotate_buf),
"%f*PI/180", theta);
954 }
else if (
fabs(theta) < 1.0) {
955 if (displaymatrix && displaymatrix[4] < 0) {
968 tsoffset +=
f->ctx->start_time;
972 &last_filter, &pad_idx,
name);
994 int ret, pad_idx = 0;
995 int64_t tsoffset = 0;
1003 av_bprintf(&args,
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
1020 last_filter = ifilter->
filter;
1022 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \
1023 AVFilterContext *filt_ctx; \
1025 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
1026 "similarly to -af " filter_name "=%s.\n", arg); \
1028 snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d", \
1029 fg->index, filter_name, ist->file_index, ist->st->index); \
1030 ret = avfilter_graph_create_filter(&filt_ctx, \
1031 avfilter_get_by_name(filter_name), \
1032 name, arg, NULL, fg->graph); \
1036 ret = avfilter_link(last_filter, 0, filt_ctx, 0); \
1040 last_filter = filt_ctx; \
1048 tsoffset +=
f->ctx->start_time;
1052 &last_filter, &pad_idx,
name);
1065 if (!ifilter->
ist->
dec) {
1067 "No decoder for stream #%d:%d, filtering impossible\n",
1090 return f->nb_inputs == 0 &&
1091 (!strcmp(
f->filter->name,
"buffer") ||
1092 !strcmp(
f->filter->name,
"abuffer"));
1105 f->nb_outputs == 0 ||
1165 const char *num_inputs;
1166 const char *num_outputs;
1176 }
else if (
inputs->next) {
1182 "to have exactly 1 input and 1 output."
1183 " However, it had %s input(s) and %s output(s)."
1184 " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
1185 graph_desc, num_inputs, num_outputs);
1234 ost->enc_ctx->frame_size);
1298 if (
frame->hw_frames_ctx) {
int init_complex_filtergraph(FilterGraph *fg)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_BPRINT_SIZE_UNLIMITED
int av_buffersink_get_ch_layout(const AVFilterContext *ctx, AVChannelLayout *out)
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
struct FilterGraph * graph
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
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
enum AVMediaType codec_type
General type of the encoded data.
int nb_threads
Maximum number of threads used by filters in this graph.
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
int avfilter_graph_segment_create_filters(AVFilterGraphSegment *seg, int flags)
Create filters specified in a graph segment.
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
#define ALLOC_ARRAY_ELEM(array, nb_elems)
static enum AVSampleFormat sample_fmts[]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
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 output
char * av_asprintf(const char *fmt,...)
InputStream * ist_iter(InputStream *prev)
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int64_t start_time
start time in microseconds == AV_TIME_BASE units
This structure describes decoded (raw) audio or video data.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
AVStream ** streams
A list of all streams in the file.
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
void check_filter_outputs(void)
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
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
enum AVChannelOrder order
Channel order used in this layout.
AVFilterPad * output_pads
array of output pads
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
int nb_channels
Number of channels in this layout.
int64_t avio_size(AVIOContext *s)
Get the filesize.
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
int configure_filtergraph(FilterGraph *fg)
#define AUTO_INSERT_FILTER(opt_name, filter_name, arg)
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
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.
void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
Set the frame size for an audio buffer sink.
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
const struct AVCodec * codec
AVChannelLayout ch_layout
Audio channel layout.
void report_and_exit(int ret)
Reports an error corresponding to the provided AVERROR code and calls exit_program() with the corresp...
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
#define AVERROR_OPTION_NOT_FOUND
Option not found.
void avfilter_graph_segment_free(AVFilterGraphSegment **seg)
Free the provided AVFilterGraphSegment and everything associated with it.
@ AVDISCARD_NONE
discard nothing
#define AV_BPRINT_SIZE_AUTOMATIC
static double val(void *priv, double ch)
static int graph_parse(AVFilterGraph *graph, const char *desc, AVFilterInOut **inputs, AVFilterInOut **outputs)
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
int avfilter_graph_segment_parse(AVFilterGraph *graph, const char *graph_str, int flags, AVFilterGraphSegment **seg)
Parse a textual filtergraph description into an intermediate form.
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
static int graph_is_meta(AVFilterGraph *graph)
A filter pad used for either input or output.
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
AVFilterPad * input_pads
array of input pads
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
AVFilterParams ** filters
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
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
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
int av_buffersink_get_format(const AVFilterContext *ctx)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const AVFilterPad outputs[]
static enum AVPixelFormat pix_fmts[]
struct OutputStream * ost
static int graph_opts_apply(AVFilterGraphSegment *seg)
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 int64_t fsize(FILE *f)
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
@ AVDISCARD_ALL
discard all
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
static __device__ float fabs(float a)
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int avfilter_graph_segment_apply(AVFilterGraphSegment *seg, int flags, AVFilterInOut **inputs, AVFilterInOut **outputs)
Apply all filter/link descriptions from a graph segment to the associated filtergraph.
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
Parameters describing a filter to be created in a filtergraph.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
AVFilterContext * filter
The filter context.
Rational number (pair of numerator and denominator).
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
AVFilterContext ** filters
static int filter_opt_apply(AVFilterContext *f, const char *key, const char *val)
char * name
name of this filter instance
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
AVFilterChain ** chains
A list of filter chain contained in this segment.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
A parsed representation of a filtergraph segment.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int pad_idx
index of the filt_ctx pad to use for linking
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
An AVChannelLayout holds information about the channel layout of audio data.
AVBufferSrcParameters * av_buffersrc_parameters_alloc(void)
Allocate a new AVBufferSrcParameters instance.
AVFilterContext * filter_ctx
filter context associated to this input/output
OutputFile ** output_files
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
AVBufferRef * hw_frames_ctx
Video with a hwaccel pixel format only.
static int64_t start_time
static int insert_trim(int64_t start_time, int64_t duration, AVFilterContext **last_filter, int *pad_idx, const char *filter_name)
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int read_binary(const char *path, uint8_t **data, int *len)
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
static int filter_is_buffersrc(const AVFilterContext *f)
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
#define AV_LOG_INFO
Standard information.
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
int av_buffersink_get_w(const AVFilterContext *ctx)
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
Initialize the buffersrc or abuffersrc filter with the provided parameters.
#define DECODING_FOR_FILTER
static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
static void choose_channel_layouts(OutputFilter *ofilter, AVBPrint *bprint)
#define i(width, name, range_min, range_max)
static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
AVSampleFormat
Audio sample formats.
static enum AVPixelFormat choose_pixel_fmt(const AVCodec *codec, enum AVPixelFormat target, int strict_std_compliance)
int hw_device_setup_for_filter(FilterGraph *fg)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
FilterGraph ** filtergraphs
const AVIOInterruptCB int_cb
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int av_buffersink_get_h(const AVFilterContext *ctx)
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
AVChannelLayout ch_layout
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
static int insert_filter(AVFilterContext **last_filter, int *pad_idx, const char *filter_name, const char *args)
AVDictionary * opts
Options to be apllied to the filter.
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
static enum AVPixelFormat * get_compliance_normal_pix_fmts(const AVCodec *codec, const enum AVPixelFormat default_formats[])
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
main external API structure.
int index
stream index in AVFormatContext
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.
#define DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name)
This structure contains the parameters describing the frames that will be passed to this filter.
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
int format
video: the pixel format, value corresponds to enum AVPixelFormat audio: the sample format,...
static char * describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
A filterchain is a list of filter specifications.
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
#define GROW_ARRAY(array, nb_elems)
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
static void cleanup_filtergraph(FilterGraph *fg)
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
#define AVIO_FLAG_READ
read-only
enum AVMediaType codec_type
char * av_strdup(const char *s)
Duplicate a string.
int auto_conversion_filters
Structure to hold side data for an AVFrame.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const char * choose_pix_fmts(OutputFilter *ofilter, AVBPrint *bprint)
int av_dict_get_string(const AVDictionary *m, char **buffer, const char key_val_sep, const char pairs_sep)
Get dictionary entries as a string.
int filtergraph_is_simple(FilterGraph *fg)
char * file_read(const char *filename)
char * name
unique name for this input/output in the list
int width
picture width / height.
static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
@ AVFILTER_AUTO_CONVERT_NONE
all automatic conversions disabled
double get_rotation(int32_t *displaymatrix)
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
A linked-list of the inputs/outputs of the filter chain.
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
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.
int filter_complex_nbthreads
static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)