59 return default_formats;
84 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
111 }
else if (ost->
enc && ost->
enc->pix_fmts) {
120 p = ost->
enc->pix_fmts;
138 #define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name) \ 139 static char *choose_ ## suffix (OutputFilter *ofilter) \ 141 if (ofilter->var != none) { \ 142 get_name(ofilter->var); \ 143 return av_strdup(name); \ 144 } else if (ofilter->supported_list) { \ 146 AVIOContext *s = NULL; \ 150 if (avio_open_dyn_buf(&s) < 0) \ 153 for (p = ofilter->supported_list; *p != none; p++) { \ 155 avio_printf(s, "%s|", name); \ 157 len = avio_close_dyn_buf(s, &ret); \ 205 ist->filters[ist->nb_filters - 1] = fg->
inputs[0];
249 int file_idx = strtol(in->
name, &p, 0);
260 if (stream_type != type &&
277 "matches a disabled input stream.\n", p, fg->
graph_desc);
289 if (i == nb_input_streams) {
291 "unlabeled input pad %d on filter %s\n", in->
pad_idx,
336 for (cur = inputs; cur; cur = cur->
next)
339 for (cur = outputs; cur;) {
362 const char *filter_name)
377 "recording time.\n", name);
385 if (duration != INT64_MAX) {
412 const char *filter_name,
const char *args)
420 filter_name, args,
NULL, graph);
456 snprintf(args,
sizeof(args),
"%d:%d",
464 snprintf(name,
sizeof(name),
"scaler_out_%d_%d",
469 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
478 snprintf(name,
sizeof(name),
"format_out_%d_%d",
486 if ((ret =
avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
499 snprintf(name,
sizeof(name),
"fps_out_%d_%d",
513 snprintf(name,
sizeof(name),
"trim_out_%d_%d",
516 &last_filter, &pad_idx, name);
547 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \ 548 AVFilterContext *filt_ctx; \ 550 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 551 "similarly to -af " filter_name "=%s.\n", arg); \ 553 ret = avfilter_graph_create_filter(&filt_ctx, \ 554 avfilter_get_by_name(filter_name), \ 555 filter_name, arg, NULL, fg->graph); \ 559 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \ 563 last_filter = filt_ctx; \ 583 sample_fmts = choose_sample_fmts(ofilter);
584 sample_rates = choose_sample_rates(ofilter);
585 channel_layouts = choose_channel_layouts(ofilter);
586 if (sample_fmts || sample_rates || channel_layouts) {
595 av_strlcatf(args,
sizeof(args),
"sample_rates=%s:",
598 av_strlcatf(args,
sizeof(args),
"channel_layouts=%s:",
605 snprintf(name,
sizeof(name),
"format_out_%d_%d",
635 snprintf(name,
sizeof(name),
"trim for output stream %d:%d",
638 &last_filter, &pad_idx, name);
738 int ret, pad_idx = 0;
739 int64_t tsoffset = 0;
744 memset(par, 0,
sizeof(*par));
767 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:" 768 "pixel_aspect=%d/%d",
773 snprintf(name,
sizeof(name),
"graph %d input from stream %d:%d", fg->
index,
785 last_filter = ifilter->
filter;
790 if (
fabs(theta - 90) < 1.0) {
791 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"clock");
792 }
else if (
fabs(theta - 180) < 1.0) {
797 }
else if (
fabs(theta - 270) < 1.0) {
798 ret =
insert_filter(&last_filter, &pad_idx,
"transpose",
"cclock");
799 }
else if (
fabs(theta) > 1.0) {
801 snprintf(rotate_buf,
sizeof(rotate_buf),
"%f*PI/180", theta);
802 ret =
insert_filter(&last_filter, &pad_idx,
"rotate", rotate_buf);
811 snprintf(name,
sizeof(name),
"deinterlace_in_%d_%d",
825 snprintf(name,
sizeof(name),
"trim_in_%d_%d",
834 &last_filter, &pad_idx, name);
856 int ret, pad_idx = 0;
857 int64_t tsoffset = 0;
865 av_bprintf(&args,
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
870 av_bprintf(&args,
":channel_layout=0x%"PRIx64,
878 name, args.str,
NULL,
881 last_filter = ifilter->
filter;
883 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \ 884 AVFilterContext *filt_ctx; \ 886 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ 887 "similarly to -af " filter_name "=%s.\n", arg); \ 889 snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d", \ 890 fg->index, filter_name, ist->file_index, ist->st->index); \ 891 ret = avfilter_graph_create_filter(&filt_ctx, \ 892 avfilter_get_by_name(filter_name), \ 893 name, arg, NULL, fg->graph); \ 897 ret = avfilter_link(last_filter, 0, filt_ctx, 0); \ 901 last_filter = filt_ctx; \ 905 char args[256] = {0};
932 "audio filter instead.\n");
938 snprintf(name,
sizeof(name),
"trim for input stream %d:%d",
947 &last_filter, &pad_idx, name);
962 "No decoder for stream #%d:%d, filtering impossible\n",
1007 args[strlen(args)-1] = 0;
1016 args[strlen(args)-1] = 0;
1025 args[strlen(args) - 1] =
'\0';
1041 if (simple && (!inputs || inputs->
next || !outputs || outputs->
next)) {
1042 const char *num_inputs;
1043 const char *num_outputs;
1046 }
else if (outputs->
next) {
1053 }
else if (inputs->
next) {
1059 "to have exactly 1 input and 1 output." 1060 " However, it had %s input(s) and %s output(s)." 1061 " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
1062 graph_desc, num_inputs, num_outputs);
1067 for (cur = inputs, i = 0; cur; cur = cur->
next, i++)
1075 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.
static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
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
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
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
static enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *enc_ctx, const AVCodec *codec, enum AVPixelFormat target)
void check_filter_outputs(void)
static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
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
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 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.
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...
#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[]
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.
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 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.
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.
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.