59 return default_formats;
83 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
97 for (; *p != -1; p++) {
107 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
133 }
else if (ost->
enc && ost->
enc->pix_fmts) {
142 p = ost->
enc->pix_fmts;
160 #define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name) \ 161 static char *choose_ ## suffix (OutputFilter *ofilter) \ 163 if (ofilter->var != none) { \ 164 get_name(ofilter->var); \ 165 return av_strdup(name); \ 166 } else if (ofilter->supported_list) { \ 168 AVIOContext *s = NULL; \ 172 if (avio_open_dyn_buf(&s) < 0) \ 175 for (p = ofilter->supported_list; *p != none; p++) { \ 177 avio_printf(s, "%s|", name); \ 179 len = avio_close_dyn_buf(s, &ret); \ 227 ist->filters[ist->nb_filters - 1] = fg->
inputs[0];
271 int file_idx = strtol(in->
name, &p, 0);
282 if (stream_type != type &&
299 "matches a disabled input stream.\n", p, fg->
graph_desc);
311 if (i == nb_input_streams) {
313 "unlabeled input pad %d on filter %s\n", in->
pad_idx,
358 for (cur = inputs; cur; cur = cur->
next)
361 for (cur = outputs; cur;) {
384 const char *filter_name)
399 "recording time.\n", name);
407 if (duration != INT64_MAX) {
434 const char *filter_name,
const char *args)
442 filter_name, args,
NULL, graph);
478 snprintf(args,
sizeof(args),
"%d:%d",
486 snprintf(name,
sizeof(name),
"scaler_out_%d_%d",
491 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
500 snprintf(name,
sizeof(name),
"format_out_%d_%d",
508 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
521 snprintf(name,
sizeof(name),
"fps_out_%d_%d",
535 snprintf(name,
sizeof(name),
"trim_out_%d_%d",
538 &last_filter, &pad_idx, name);
569 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \ 570 AVFilterContext *filt_ctx; \ 572 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 573 "similarly to -af " filter_name "=%s.\n", arg); \ 575 ret = avfilter_graph_create_filter(&filt_ctx, \ 576 avfilter_get_by_name(filter_name), \ 577 filter_name, arg, NULL, fg->graph); \ 581 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \ 585 last_filter = filt_ctx; \ 605 sample_fmts = choose_sample_fmts(ofilter);
606 sample_rates = choose_sample_rates(ofilter);
607 channel_layouts = choose_channel_layouts(ofilter);
608 if (sample_fmts || sample_rates || channel_layouts) {
617 av_strlcatf(args,
sizeof(args),
"sample_rates=%s:",
620 av_strlcatf(args,
sizeof(args),
"channel_layouts=%s:",
627 snprintf(name,
sizeof(name),
"format_out_%d_%d",
664 snprintf(name,
sizeof(name),
"trim for output stream %d:%d",
667 &last_filter, &pad_idx, name);
766 int ret, pad_idx = 0;
772 memset(par, 0,
sizeof(*par));
795 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:" 796 "pixel_aspect=%d/%d",
801 snprintf(name,
sizeof(name),
"graph %d input from stream %d:%d", fg->
index,
813 last_filter = ifilter->
filter;
818 if (fabs(theta - 90) < 1.0) {
819 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"clock");
820 }
else if (fabs(theta - 180) < 1.0) {
825 }
else if (fabs(theta - 270) < 1.0) {
826 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"cclock");
827 }
else if (fabs(theta) > 1.0) {
829 snprintf(rotate_buf,
sizeof(rotate_buf),
"%f*PI/180", theta);
830 ret =
insert_filter(&last_filter, &pad_idx,
"rotate", rotate_buf);
839 snprintf(name,
sizeof(name),
"deinterlace_in_%d_%d",
853 snprintf(name,
sizeof(name),
"trim_in_%d_%d",
862 &last_filter, &pad_idx, name);
884 int ret, pad_idx = 0;
893 av_bprintf(&args,
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
898 av_bprintf(&args,
":channel_layout=0x%"PRIx64,
906 name, args.str,
NULL,
909 last_filter = ifilter->
filter;
911 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \ 912 AVFilterContext *filt_ctx; \ 914 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 915 "similarly to -af " filter_name "=%s.\n", arg); \ 917 snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d", \ 918 fg->index, filter_name, ist->file_index, ist->st->index); \ 919 ret = avfilter_graph_create_filter(&filt_ctx, \ 920 avfilter_get_by_name(filter_name), \ 921 name, arg, NULL, fg->graph); \ 925 ret = avfilter_link(last_filter, 0, filt_ctx, 0); \ 929 last_filter = filt_ctx; \ 933 char args[256] = {0};
960 "audio filter instead.\n");
966 snprintf(name,
sizeof(name),
"trim for input stream %d:%d",
975 &last_filter, &pad_idx, name);
990 "No decoder for stream #%d:%d, filtering impossible\n",
1035 args[strlen(args)-1] = 0;
1044 args[strlen(args)-1] = 0;
1053 args[strlen(args) - 1] =
'\0';
1069 if (simple && (!inputs || inputs->
next || !outputs || outputs->
next)) {
1070 const char *num_inputs;
1071 const char *num_outputs;
1074 }
else if (outputs->
next) {
1081 }
else if (inputs->
next) {
1087 "to have exactly 1 input and 1 output." 1088 " However, it had %s input(s) and %s output(s)." 1089 " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
1090 graph_desc, num_inputs, num_outputs);
1095 for (cur = inputs, i = 0; cur; cur = cur->
next, i++)
1103 for (cur = outputs, i = 0; cur; cur = cur->
next, i++)
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
void av_bprintf(AVBPrint *buf, const char *fmt,...)
static const char * format[]
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
#define DECODING_FOR_FILTER
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
double get_rotation(AVStream *st)
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
#define AV_LOG_WARNING
Something somehow does not look correct.
Main libavfilter public API header.
Memory buffer source API.
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
static int insert_trim(int64_t start_time, int64_t duration, AVFilterContext **last_filter, int *pad_idx, const char *filter_name)
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
int index
stream index in AVFormatContext
int init_complex_filtergraph(FilterGraph *fg)
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name)
static enum AVPixelFormat * get_compliance_unofficial_pix_fmts(enum AVCodecID codec_id, const enum AVPixelFormat default_formats[])
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
int64_t start_time
start time in microseconds == AV_TIME_BASE units
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
int configure_filtergraph(FilterGraph *fg)
memory buffer sink API for audio and video
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *enc_ctx, AVCodec *codec, enum AVPixelFormat target)
char * name
name of this filter instance
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
AVFilterPad * output_pads
array of output pads
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
static int64_t start_time
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
void check_filter_outputs(void)
static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
#define AV_CODEC_PROP_LOSSLESS
Codec supports lossless compression.
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
AVStream ** streams
A list of all streams in the file.
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.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int nb_threads
Maximum number of threads used by filters in this graph.
AVDictionary * resample_opts
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs)
Add a graph described by a string to a graph.
int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
int av_buffersink_get_h(const AVFilterContext *ctx)
int av_buffersink_get_format(const AVFilterContext *ctx)
int filter_complex_nbthreads
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
A filter pad used for either input or output.
static int insert_filter(AVFilterContext **last_filter, int *pad_idx, const char *filter_name, const char *args)
AVFilterPad * input_pads
array of input pads
int hw_device_setup_for_filter(FilterGraph *fg)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define GET_CH_LAYOUT_NAME(ch_layout)
FilterGraph ** filtergraphs
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
unsigned nb_outputs
number of output pads
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
enum AVMediaType codec_type
General type of the encoded data.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
simple assert() macros that are a bit more flexible than ISO C assert().
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.
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.
int format
video: the pixel format, value corresponds to enum AVPixelFormat audio: the sample format...
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
uint64_t channel_layout
Audio channel layout.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
uint64_t channel_layout
Channel layout of the audio data.
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
uint8_t nb_components
The number of components each pixel has, (1-4)
int channels
number of audio channels, only used for audio.
audio channel layout utility functions
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
This structure contains the parameters describing the frames that will be passed to this filter...
unsigned nb_inputs
number of input pads
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
struct OutputStream * ost
int width
picture width / height.
int audio_channels_mapped
packed RGB 8:8:8, 24bpp, BGRBGR...
static const AVFilterPad inputs[]
#define GET_SAMPLE_FMT_NAME(sample_fmt)
AVFilterContext * filter_ctx
filter context associated to this input/output
static const AVFilterPad outputs[]
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
static char * describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
A linked-list of the inputs/outputs of the filter chain.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
enum AVPixelFormat avcodec_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)
#define GET_SAMPLE_RATE_NAME(rate)
int frame_size
Number of samples per channel in an audio frame.
AVBufferRef * hw_frames_ctx
Video with a hwaccel pixel format only.
#define AV_LOG_INFO
Standard information.
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
enum AVMediaType codec_type
AVSampleFormat
Audio sample formats.
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
uint64_t av_buffersink_get_channel_layout(const AVFilterContext *ctx)
void avio_w8(AVIOContext *s, int b)
main external API structure.
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
#define AUTO_INSERT_FILTER(opt_name, filter_name, arg)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static const uint16_t channel_layouts[7]
int sample_rate
Sample rate of the audio data.
int pad_idx
index of the filt_ctx pad to use for linking
Rational number (pair of numerator and denominator).
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
const char * name
Filter name.
int av_buffersink_get_w(const AVFilterContext *ctx)
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
static enum AVPixelFormat pix_fmts[]
This struct describes the properties of a single codec described by an AVCodecID. ...
float audio_drift_threshold
char * name
unique name for this input/output in the list
all automatic conversions disabled
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)
struct FilterGraph * graph
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
Set the frame size for an audio buffer sink.
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
Initialize the buffersrc or abuffersrc filter with the provided parameters.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
#define GROW_ARRAY(array, nb_elems)
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
int channels
number of audio channels
AVBufferSrcParameters * av_buffersrc_parameters_alloc(void)
Allocate a new AVBufferSrcParameters instance.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
int filtergraph_is_simple(FilterGraph *fg)
static char * choose_pix_fmts(OutputFilter *ofilter)
static void cleanup_filtergraph(FilterGraph *fg)
AVDictionary * encoder_opts
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static enum AVSampleFormat sample_fmts[]
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
OutputFile ** output_files
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
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.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void choose_sample_fmt(AVStream *st, AVCodec *codec)
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
AVPixelFormat
Pixel format.
#define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg)
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
const AVFilter * filter
the AVFilter of which this is an instance
#define AV_NOPTS_VALUE
Undefined timestamp value.
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
InputStream ** input_streams
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.