59 return default_formats;
84 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
98 for (; *p != -1; p++) {
108 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
134 }
else if (ost->
enc && ost->
enc->pix_fmts) {
143 p = ost->
enc->pix_fmts;
161 #define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name) \ 162 static char *choose_ ## suffix (OutputFilter *ofilter) \ 164 if (ofilter->var != none) { \ 165 get_name(ofilter->var); \ 166 return av_strdup(name); \ 167 } else if (ofilter->supported_list) { \ 169 AVIOContext *s = NULL; \ 173 if (avio_open_dyn_buf(&s) < 0) \ 176 for (p = ofilter->supported_list; *p != none; p++) { \ 178 avio_printf(s, "%s|", name); \ 180 len = avio_close_dyn_buf(s, &ret); \ 228 ist->filters[ist->nb_filters - 1] = fg->
inputs[0];
272 int file_idx = strtol(in->
name, &p, 0);
283 if (stream_type != type &&
300 "matches a disabled input stream.\n", p, fg->
graph_desc);
312 if (i == nb_input_streams) {
314 "unlabeled input pad %d on filter %s\n", in->
pad_idx,
359 for (cur = inputs; cur; cur = cur->
next)
362 for (cur = outputs; cur;) {
385 const char *filter_name)
400 "recording time.\n", name);
408 if (duration != INT64_MAX) {
435 const char *filter_name,
const char *args)
443 filter_name, args,
NULL, graph);
479 snprintf(args,
sizeof(args),
"%d:%d",
487 snprintf(name,
sizeof(name),
"scaler_out_%d_%d",
492 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
501 snprintf(name,
sizeof(name),
"format_out_%d_%d",
509 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
522 snprintf(name,
sizeof(name),
"fps_out_%d_%d",
536 snprintf(name,
sizeof(name),
"trim_out_%d_%d",
539 &last_filter, &pad_idx, name);
570 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \ 571 AVFilterContext *filt_ctx; \ 573 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 574 "similarly to -af " filter_name "=%s.\n", arg); \ 576 ret = avfilter_graph_create_filter(&filt_ctx, \ 577 avfilter_get_by_name(filter_name), \ 578 filter_name, arg, NULL, fg->graph); \ 582 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \ 586 last_filter = filt_ctx; \ 606 sample_fmts = choose_sample_fmts(ofilter);
607 sample_rates = choose_sample_rates(ofilter);
608 channel_layouts = choose_channel_layouts(ofilter);
609 if (sample_fmts || sample_rates || channel_layouts) {
618 av_strlcatf(args,
sizeof(args),
"sample_rates=%s:",
621 av_strlcatf(args,
sizeof(args),
"channel_layouts=%s:",
628 snprintf(name,
sizeof(name),
"format_out_%d_%d",
665 snprintf(name,
sizeof(name),
"trim for output stream %d:%d",
668 &last_filter, &pad_idx, name);
767 int ret, pad_idx = 0;
768 int64_t tsoffset = 0;
773 memset(par, 0,
sizeof(*par));
796 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:" 797 "pixel_aspect=%d/%d",
802 snprintf(name,
sizeof(name),
"graph %d input from stream %d:%d", fg->
index,
814 last_filter = ifilter->
filter;
819 if (
fabs(theta - 90) < 1.0) {
820 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"clock");
821 }
else if (
fabs(theta - 180) < 1.0) {
826 }
else if (
fabs(theta - 270) < 1.0) {
827 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"cclock");
828 }
else if (
fabs(theta) > 1.0) {
830 snprintf(rotate_buf,
sizeof(rotate_buf),
"%f*PI/180", theta);
831 ret =
insert_filter(&last_filter, &pad_idx,
"rotate", rotate_buf);
840 snprintf(name,
sizeof(name),
"deinterlace_in_%d_%d",
854 snprintf(name,
sizeof(name),
"trim_in_%d_%d",
863 &last_filter, &pad_idx, name);
885 int ret, pad_idx = 0;
886 int64_t tsoffset = 0;
894 av_bprintf(&args,
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
899 av_bprintf(&args,
":channel_layout=0x%"PRIx64,
907 name, args.str,
NULL,
910 last_filter = ifilter->
filter;
912 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \ 913 AVFilterContext *filt_ctx; \ 915 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 916 "similarly to -af " filter_name "=%s.\n", arg); \ 918 snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d", \ 919 fg->index, filter_name, ist->file_index, ist->st->index); \ 920 ret = avfilter_graph_create_filter(&filt_ctx, \ 921 avfilter_get_by_name(filter_name), \ 922 name, arg, NULL, fg->graph); \ 926 ret = avfilter_link(last_filter, 0, filt_ctx, 0); \ 930 last_filter = filt_ctx; \ 934 char args[256] = {0};
961 "audio filter instead.\n");
967 snprintf(name,
sizeof(name),
"trim for input stream %d:%d",
976 &last_filter, &pad_idx, name);
991 "No decoder for stream #%d:%d, filtering impossible\n",
1036 args[strlen(args)-1] = 0;
1045 args[strlen(args)-1] = 0;
1054 args[strlen(args) - 1] =
'\0';
1070 if (simple && (!inputs || inputs->
next || !outputs || outputs->
next)) {
1071 const char *num_inputs;
1072 const char *num_outputs;
1075 }
else if (outputs->
next) {
1082 }
else if (inputs->
next) {
1088 "to have exactly 1 input and 1 output." 1089 " However, it had %s input(s) and %s output(s)." 1090 " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
1091 graph_desc, num_inputs, num_outputs);
1096 for (cur = inputs, i = 0; cur; cur = cur->
next, i++)
1104 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,...)
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.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_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 format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
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
void choose_sample_fmt(AVStream *st, const AVCodec *codec)
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *enc_ctx, const AVCodec *codec, enum AVPixelFormat target)
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
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 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.
int auto_conversion_filters
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.
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
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)
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
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
static __device__ float fabs(float a)
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().
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.
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
int audio_channels_mapped
packed RGB 8:8:8, 24bpp, BGRBGR...
#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)
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
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)\n", 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...
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 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.