59 return default_formats;
70 int has_alpha =
desc ?
desc->nb_components % 2 == 0 : 0;
84 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
102 if (
ost->keep_pix_fmt) {
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];
217 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);
291 "unlabeled input pad %d on filter %s\n",
in->pad_idx,
292 in->filter_ctx->name);
362 const char *filter_name)
377 "recording time.\n",
name);
412 const char *filter_name,
const char *args)
420 filter_name, args,
NULL, graph);
439 int pad_idx =
out->pad_idx;
456 snprintf(args,
sizeof(args),
"%d:%d",
493 if (
ost->frame_rate.num && 0) {
497 snprintf(args,
sizeof(args),
"fps=%d/%d",
ost->frame_rate.num,
498 ost->frame_rate.den);
516 &last_filter, &pad_idx,
name);
533 int pad_idx =
out->pad_idx;
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; \
566 if (
ost->audio_channels_mapped) {
572 for (
i = 0;
i <
ost->audio_channels_mapped;
i++)
573 if (
ost->audio_channels_map[
i] != -1)
595 av_strlcatf(args,
sizeof(args),
"sample_rates=%s:",
598 av_strlcatf(args,
sizeof(args),
"channel_layouts=%s:",
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",
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);
830 tsoffset +=
f->ctx->start_time;
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,
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");
943 tsoffset +=
f->ctx->start_time;
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';
1042 const char *num_inputs;
1043 const char *num_outputs;
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);
1114 ost->enc_ctx->frame_size);
static enum AVSampleFormat sample_fmts[]
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static const char *const format[]
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
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Main libavfilter public API header.
void avio_w8(AVIOContext *s, int b)
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
#define AV_BPRINT_SIZE_AUTOMATIC
memory buffer sink API for audio and video
Memory buffer source API.
static av_always_inline void filter(int16_t *output, ptrdiff_t out_stride, const int16_t *low, ptrdiff_t low_stride, const int16_t *high, ptrdiff_t high_stride, int len, int clip)
audio channel layout utility functions
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
double get_rotation(AVStream *st)
#define GET_SAMPLE_RATE_NAME(rate)
#define GET_CH_LAYOUT_NAME(ch_layout)
#define GROW_ARRAY(array, nb_elems)
#define GET_SAMPLE_FMT_NAME(sample_fmt)
static __device__ float fabs(float a)
static const uint16_t channel_layouts[7]
FilterGraph ** filtergraphs
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
InputStream ** input_streams
OutputFile ** output_files
int filter_complex_nbthreads
#define DECODING_FOR_FILTER
int hw_device_setup_for_filter(FilterGraph *fg)
int auto_conversion_filters
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
float audio_drift_threshold
static void cleanup_filtergraph(FilterGraph *fg)
static enum AVPixelFormat * get_compliance_unofficial_pix_fmts(enum AVCodecID codec_id, const enum AVPixelFormat default_formats[])
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)
static enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *enc_ctx, const AVCodec *codec, enum AVPixelFormat target)
static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
#define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name)
static char * choose_pix_fmts(OutputFilter *ofilter)
static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
static char * describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
static int insert_trim(int64_t start_time, int64_t duration, AVFilterContext **last_filter, int *pad_idx, const char *filter_name)
#define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg)
static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
#define AUTO_INSERT_FILTER(opt_name, filter_name, arg)
static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
int filtergraph_is_simple(FilterGraph *fg)
void check_filter_outputs(void)
static int insert_filter(AVFilterContext **last_filter, int *pad_idx, const char *filter_name, const char *args)
int configure_filtergraph(FilterGraph *fg)
int init_complex_filtergraph(FilterGraph *fg)
static int64_t start_time
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
AVCodecID
Identify the syntax and semantics of the bitstream.
@ AVDISCARD_ALL
discard all
@ AVDISCARD_NONE
discard nothing
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
int av_buffersink_get_format(const AVFilterContext *ctx)
uint64_t av_buffersink_get_channel_layout(const AVFilterContext *ctx)
int av_buffersink_get_h(const AVFilterContext *ctx)
int av_buffersink_get_w(const AVFilterContext *ctx)
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.
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
AVBufferSrcParameters * av_buffersrc_parameters_alloc(void)
Allocate a new AVBufferSrcParameters instance.
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
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.
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs)
Add a graph described by a string to a graph.
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
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.
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
@ AVFILTER_AUTO_CONVERT_NONE
all automatic conversions disabled
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
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.
AVSampleFormat
Audio sample formats.
#define AV_NOPTS_VALUE
Undefined timestamp value.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
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 ...
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.
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
static enum AVPixelFormat pix_fmts[]
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.
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.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
This structure contains the parameters describing the frames that will be passed to this filter.
int format
video: the pixel format, value corresponds to enum AVPixelFormat audio: the sample format,...
AVBufferRef * hw_frames_ctx
Video with a hwaccel pixel format only.
main external API structure.
int width
picture width / height.
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
enum AVMediaType codec_type
int channels
number of audio channels
uint64_t channel_layout
Audio channel layout.
enum AVMediaType codec_type
General type of the encoded data.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
const char * name
Name of the codec implementation.
AVFilterPad * output_pads
array of output pads
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
int nb_threads
Maximum number of threads used by filters in this graph.
A linked-list of the inputs/outputs of the filter chain.
AVFilterContext * filter_ctx
filter context associated to this input/output
int pad_idx
index of the filt_ctx pad to use for linking
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
A filter pad used for either input or output.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
AVStream ** streams
A list of all streams in the file.
This structure describes decoded (raw) audio or video data.
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
int channels
number of audio channels, only used for audio.
uint64_t channel_layout
Channel layout of the audio data.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
int sample_rate
Sample rate of the audio data.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Rational number (pair of numerator and denominator).
AVCodecParameters * codecpar
Codec parameters associated with this stream.
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
int index
stream index in AVFormatContext
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int64_t start_time
start time in microseconds == AV_TIME_BASE units
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
struct OutputStream * ost
struct FilterGraph * graph
AVDictionary * resample_opts