Go to the documentation of this file.
49 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
93 const char *opt_name,
int flag)
112 char *codec_name =
NULL;
121 if (codec_name && strcmp(codec_name,
"copy")) {
124 "Encoder '%s' specified, but only '-codec copy' supported "
125 "for %s streams\n", codec_name, type_str);
136 "Default encoder for format %s (codec %s) is "
137 "probably disabled. Please choose an encoder manually.\n",
141 }
else if (strcmp(codec_name,
"copy")) {
143 ost->par_in->codec_id = (*enc)->
id;
165 char *env_avconv_datadir =
getenv_utf8(
"AVCONV_DATADIR");
167 const char *
base[3] = { env_avconv_datadir,
176 snprintf(filename,
sizeof(filename),
"%s%s/%s-%s.avpreset",
base[
i],
177 i != 1 ?
"" :
"/.avconv", codec_name, preset_name);
181 snprintf(filename,
sizeof(filename),
"%s%s/%s.avpreset",
base[
i],
182 i != 1 ?
"" :
"/.avconv", preset_name);
241 const char **pstr,
char delim)
243 const char *str = *pstr;
257 for (idx = 0; *str; idx++, str++) {
258 if (str[0] ==
'\\' && str[1])
260 else if (*str == delim)
280 const char *path,
const char *fmt_spec)
282 static const struct {
287 int need_input_data:1;
307 const char *next = fmt_spec;
327 c->str_len = val_len;
341 "Empty formatting directive in: %s\n", fmt_spec);
347 "Missing closing brace in: %s\n", fmt_spec);
357 if (!strcmp(
val, fmt_specs[
i].str)) {
358 if ((pre && fmt_specs[
i].post_only) || (!pre && fmt_specs[
i].pre_only)) {
360 "Format directive '%s' may only be used %s-encoding\n",
361 val, pre ?
"post" :
"pre");
366 c->type = fmt_specs[
i].type;
368 if (fmt_specs[
i].need_input_data) {
370 ost->ist->want_frame_data = 1;
373 "Format directive '%s' is unavailable, because "
374 "this output stream has no associated input stream\n",
443 if (filters_script ||
filters) {
445 "%s '%s' was specified, but codec copy was selected. "
446 "Filtering and streamcopy cannot be used together.\n",
447 filters ?
"Filtergraph" :
"Filtergraph script",
455 if (filters_script ||
filters) {
457 "%s '%s' was specified for a stream fed from a complex "
458 "filtergraph. Simple and complex filtering cannot be used "
459 "together for the same stream.\n",
460 filters ?
"Filtergraph" :
"Filtergraph script",
467 if (filters_script &&
filters) {
492 "Syntax error in matrix \"%s\" at coeff %d\n", str,
i);
504 char *frame_rate =
NULL, *max_frame_rate =
NULL, *frame_aspect_ratio =
NULL;
520 if (frame_rate && max_frame_rate) {
526 if (frame_aspect_ratio) {
529 q.
num <= 0 || q.
den <= 0) {
533 ost->frame_aspect_ratio = q;
538 const char *p =
NULL, *fps_mode =
NULL;
540 char *frame_pix_fmt =
NULL;
541 char *intra_matrix =
NULL, *inter_matrix =
NULL;
542 char *chroma_intra_matrix =
NULL;
553 if (frame_pix_fmt && *frame_pix_fmt ==
'+') {
554 ost->keep_pix_fmt = 1;
555 if (!*++frame_pix_fmt)
556 frame_pix_fmt =
NULL;
571 if (chroma_intra_matrix) {
586 for (
i = 0; p;
i++) {
588 int e = sscanf(p,
"%d,%d,%d", &start, &end, &q);
636 if (
ost->logfile_prefix &&
642 char logfilename[1024];
646 for (
int i = 0;
i <=
ost->file_index;
i++)
649 snprintf(logfilename,
sizeof(logfilename),
"%s-%d.log",
650 ost->logfile_prefix ?
ost->logfile_prefix :
653 if (!strcmp(
ost->enc_ctx->codec->name,
"libx264")) {
657 char *logbuffer =
file_read(logfilename);
670 "Cannot write log file '%s' for pass-1 encoding: %s\n",
671 logfilename, strerror(errno));
681 ost->top_field_first = -1;
689 if ((
ost->frame_rate.num ||
ost->max_frame_rate.num) &&
693 "together a non-CFR -vsync/-fps_mode. This is contradictory.\n");
698 if (
ost->frame_rate.num ||
ost->max_frame_rate.num) {
736 char *sample_fmt =
NULL;
747 #if FF_API_OLD_CHANNEL_LAYOUT
756 #if FF_API_OLD_CHANNEL_LAYOUT
777 #if FFMPEG_OPT_MAP_CHANNEL
781 if ((
map->ofile_idx == -1 ||
ost->file_index ==
map->ofile_idx) &&
785 if (
map->channel_idx == -1) {
787 }
else if (!
ost->ist) {
797 ost->audio_channels_mapped + 1,
798 sizeof(*
ost->audio_channels_map)
802 ost->audio_channels_map[
ost->audio_channels_mapped++] =
map->channel_idx;
830 int input_props = 0, output_props = 0;
839 if (input_descriptor)
841 if (output_descriptor)
843 if (input_props && output_props && input_props != output_props) {
845 "Subtitle encoding currently only possible from text to text "
846 "or bitmap to bitmap\n");
875 "Error setting up codec context options.\n");
882 "Error getting reference codec parameters.\n");
888 unsigned int codec_tag_tmp;
896 if (!
ost->frame_rate.num)
899 if (
ost->frame_rate.num)
911 if (
ost->frame_rate.num)
939 memcpy(dst_data, sd_src->
data, sd_src->
size);
942 #if FFMPEG_ROTATION_METADATA
943 if (
ost->rotate_overridden) {
961 if (
ost->frame_aspect_ratio.num) {
966 "with stream copy may produce invalid files\n");
996 const char *bsfs =
NULL, *time_base =
NULL;
997 char *next, *codec_tag =
NULL;
1022 ost->par_in->codec_type =
type;
1054 const char *enc_stats_pre =
NULL, *enc_stats_post =
NULL, *mux_stats =
NULL;
1057 oc, st, enc->
codec);
1068 if (!buf[0] || buf[0] ==
'#')
1070 if (!(
arg = strchr(buf,
'='))) {
1076 }
while (!
s->eof_reached);
1082 "Preset %s specified, but could not be opened.\n",
preset);
1087 if (enc_stats_pre &&
1089 const char *
format =
"{fidx} {sidx} {n} {t}";
1099 if (enc_stats_post &&
1101 const char *
format =
"{fidx} {sidx} {n} {t}";
1113 const char *
format =
"{fidx} {sidx} {n} {t}";
1128 }
else if (
ost->enc_ctx) {
1137 q.
num <= 0 || q.
den <= 0) {
1152 ost->enc_timebase = q;
1160 av_log(
ost,
AV_LOG_WARNING,
"Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1169 if (bsfs && *bsfs) {
1179 uint32_t
tag = strtol(codec_tag, &next, 0);
1181 uint8_t buf[4] = { 0 };
1182 memcpy(buf, codec_tag,
FFMIN(
sizeof(buf), strlen(codec_tag)));
1186 ost->par_in->codec_tag =
tag;
1188 ost->enc_ctx->codec_tag =
tag;
1192 if (
ost->enc_ctx && qscale >= 0) {
1242 "Error initializing a simple filtergraph\n");
1249 "Error binding an input stream\n");
1255 if (
ost->ist && !
ost->enc) {
1270 ost->filter = ofilter;
1274 if (!
ost->enc_ctx) {
1276 "from a complex filtergraph. Filtering and streamcopy "
1277 "cannot be used together.\n");
1299 int file_best_score = 0;
1314 if (score > file_best_score) {
1317 file_best_score = score;
1318 file_best_ist = ist;
1321 if (file_best_ist) {
1322 if((qcr ==
MKTAG(
'A',
'P',
'I',
'C')) ||
1325 if (file_best_score > best_score) {
1326 best_score = file_best_score;
1327 best_ist = file_best_ist;
1348 int file_best_score = 0;
1360 if (score > file_best_score) {
1361 file_best_score = score;
1362 file_best_ist = ist;
1365 if (file_best_ist) {
1367 if (file_best_score > best_score) {
1368 best_score = file_best_score;
1369 best_ist = file_best_ist;
1394 int input_props = 0, output_props = 0;
1399 if (input_descriptor)
1401 if (output_descriptor)
1404 input_props & output_props ||
1406 input_descriptor && output_descriptor &&
1407 (!input_descriptor->
props ||
1408 !output_descriptor->
props)) {
1428 ist->st->codecpar->codec_id ==
codec_id )
1440 if (
map->linklabel) {
1449 if (
out && !strcmp(
out->name,
map->linklabel)) {
1458 "in any defined filter graph, or was already used elsewhere.\n",
map->linklabel);
1466 map->file_index,
map->stream_index);
1481 "Cannot map stream #%d:%d - unsupported type.\n",
1482 map->file_index,
map->stream_index);
1485 "If you want unsupported types ignored instead "
1486 "of failing, please use the -ignore_unknown option\n"
1487 "If you want them copied, please use -copy_unknown\n");
1504 uint8_t *attachment;
1529 ost->par_in->extradata = attachment;
1530 ost->par_in->extradata_size =
len;
1555 switch (ofilter->
type) {
1566 if (!auto_disable_v)
1568 if (!auto_disable_a)
1570 if (!auto_disable_s)
1572 if (!auto_disable_d)
1591 int nb_av_enc = 0, nb_audio_fs = 0, nb_interleaved = 0;
1592 int limit_frames = 0, limit_frames_av_enc = 0;
1594 #define IS_AV_ENC(ost, type) \
1595 (ost->enc_ctx && (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO))
1596 #define IS_INTERLEAVED(type) (type != AVMEDIA_TYPE_ATTACHMENT)
1603 ost->sq_idx_encode = -1;
1604 ost->sq_idx_mux = -1;
1615 if (!((nb_interleaved > 1 && of->
shortest) ||
1616 (nb_interleaved > 0 && limit_frames) ||
1627 if ((of->
shortest && nb_av_enc > 1) || limit_frames_av_enc || nb_audio_fs) {
1642 if (
ost->sq_idx_encode < 0)
1643 return ost->sq_idx_encode;
1652 if (nb_interleaved > nb_av_enc) {
1671 if (
ost->sq_idx_mux < 0)
1672 return ost->sq_idx_mux;
1680 #undef IS_INTERLEAVED
1696 const char *to_dealloc = p2;
1711 if (!strcmp(
key,
"program_num"))
1712 progid = strtol(p2,
NULL, 0);
1724 const char *to_dealloc = p2;
1733 "No '=' character in program string %s.\n",
1741 if (!strcmp(
key,
"title")) {
1743 }
else if (!strcmp(
key,
"program_num")) {
1744 }
else if (!strcmp(
key,
"st")) {
1745 int st_num = strtol(p2,
NULL, 0);
1765 char *
type,
int *
index,
const char **stream_spec)
1773 if (*(++
arg) && *
arg !=
':') {
1777 *stream_spec = *
arg ==
':' ?
arg + 1 :
"";
1781 if (*(++
arg) ==
':')
1798 const char *stream_spec;
1814 #if FFMPEG_ROTATION_METADATA
1819 ost->rotate_overridden = 1;
1820 ost->rotate_override_value = theta;
1824 "Conversion of a 'rotate' metadata key to a "
1825 "proper display matrix rotation is deprecated. "
1826 "See -display_rotation for setting rotation "
1831 #if FFMPEG_ROTATION_METADATA
1879 if (!
c->ch_layouts) {
1887 for (
i = 0;
c->ch_layouts[
i].nb_channels;
i++) {
1888 if (
c->ch_layouts[
i].nb_channels ==
ost->enc_ctx->ch_layout.nb_channels)
1891 if (
c->ch_layouts[
i].nb_channels) {
1915 for (
i = 0;
i <
is->nb_chapters;
i++) {
1924 if (in_ch->
end < ts_off)
1926 if (rt != INT64_MAX && in_ch->
start > rt + ts_off)
1933 out_ch->id = in_ch->
id;
1935 out_ch->start =
FFMAX(0, in_ch->
start - ts_off);
1936 out_ch->end =
FFMIN(rt, in_ch->
end - ts_off);
1947 const char *outspec,
const char *inspec,
1948 int *metadata_global_manual,
int *metadata_streams_manual,
1949 int *metadata_chapters_manual)
1955 char type_in, type_out;
1956 const char *istream_spec =
NULL, *ostream_spec =
NULL;
1957 int idx_in = 0, idx_out = 0;
1962 if (type_in ==
'g' || type_out ==
'g' || !*outspec)
1963 *metadata_global_manual = 1;
1964 if (type_in ==
's' || type_out ==
's' || !*outspec)
1965 *metadata_streams_manual = 1;
1966 if (type_in ==
'c' || type_out ==
'c' || !*outspec)
1967 *metadata_chapters_manual = 1;
1973 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
1974 if ((index) < 0 || (index) >= (nb_elems)) {\
1975 av_log(mux, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
1980 #define SET_DICT(type, meta, context, index)\
1983 meta = &context->metadata;\
1986 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
1987 meta = &context->chapters[index]->metadata;\
1990 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
1991 meta = &context->programs[index]->metadata;\
1995 default: av_assert0(0);\
1998 SET_DICT(type_in, meta_in, ic, idx_in);
1999 SET_DICT(type_out, meta_out, oc, idx_out);
2002 if (type_in ==
's') {
2011 av_log(mux,
AV_LOG_FATAL,
"Stream specifier %s does not match any streams.\n", istream_spec);
2016 if (type_out ==
's') {
2035 int metadata_global_manual = 0;
2036 int metadata_streams_manual = 0;
2037 int metadata_chapters_manual = 0;
2046 "processing metadata maps\n", in_file_index);
2052 &metadata_global_manual, &metadata_streams_manual,
2053 &metadata_chapters_manual);
2058 if (chapters_input_file == INT_MAX) {
2060 chapters_input_file = -1;
2063 chapters_input_file =
i;
2068 chapters_input_file);
2072 if (chapters_input_file >= 0)
2074 !metadata_chapters_manual);
2087 if (!metadata_streams_manual)
2107 int have_manual = 0;
2110 const char **dispositions;
2124 have_manual |= !!dispositions[
i];
2130 have_default[
ost->type] = 1;
2138 const char *disp = dispositions[
i];
2160 have_default[
type] = 1;
2181 return FFDIFFSIGN(*(
const int64_t *)
a, *(
const int64_t *)
b);
2191 for (p = spec; *p; p++)
2200 for (
i = 0;
i < n;
i++) {
2201 char *next = strchr(p,
',');
2206 if (strstr(p,
"chapters") == p) {
2211 if (nb_ch > INT_MAX -
size ||
2217 for (j = 0; j < nb_ch; j++) {
2242 const char *forced_keyframes =
NULL;
2247 ost->enc_ctx && forced_keyframes))
2250 if (!strncmp(forced_keyframes,
"expr:", 5)) {
2255 "Invalid force_key_frames expression '%s'\n", forced_keyframes + 5);
2258 ost->kf.expr_const_values[
FKF_N] = 0;
2265 }
else if (!strcmp(forced_keyframes,
"source")) {
2267 }
else if (!strcmp(forced_keyframes,
"source_no_drop")) {
2309 if (!strcmp(e->
key,
"gop_timecode"))
2313 "for any stream. The most likely reason is either wrong type "
2314 "(e.g. a video option with no video streams) or that it is a "
2315 "private option of some encoder which was not actually used for "
2340 const Muxer *mux = obj;
2377 if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
2378 stop_time = INT64_MAX;
2382 if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
2400 if (!strcmp(filename,
"-"))
2418 if (recording_time != INT64_MAX)
2444 switch (
ost->enc_ctx->codec_type) {
2446 f->frame_rate =
ost->frame_rate;
2447 f->width =
ost->enc_ctx->width;
2448 f->height =
ost->enc_ctx->height;
2450 f->format =
ost->enc_ctx->pix_fmt;
2452 f->formats =
c->pix_fmts;
2457 f->format =
ost->enc_ctx->sample_fmt;
2459 f->formats =
c->sample_fmts;
2461 if (
ost->enc_ctx->sample_rate) {
2462 f->sample_rate =
ost->enc_ctx->sample_rate;
2464 f->sample_rates =
c->supported_samplerates;
2466 if (
ost->enc_ctx->ch_layout.nb_channels) {
2468 }
else if (
c->ch_layouts) {
2469 f->ch_layouts =
c->ch_layouts;
2479 "Output filename '%s' does not contain a numeric pattern like "
2480 "'%%d', which is required by output format '%s'.\n",
static int choose_encoder(const OptionsContext *o, AVFormatContext *s, OutputStream *ost, const AVCodec **enc)
static void parse_forced_key_frames(KeyframeForceCtx *kf, const Muxer *mux, const char *spec)
static FILE * fopen_utf8(const char *path, const char *mode)
static int streamcopy_init(const Muxer *mux, OutputStream *ost)
static const char *const opt_name_filters[]
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
int copy_initial_nonkeyframes
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_BPRINT_SIZE_UNLIMITED
static const char *const opt_name_max_muxing_queue_size[]
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
static MuxStream * ms_from_ost(OutputStream *ost)
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
enum AVMediaType codec_type
General type of the encoded data.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
static const char *const opt_name_muxing_queue_data_threshold[]
int sample_rate
samples per second
@ KF_FORCE_SOURCE_NO_DROP
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
The official guide to swscale for confused that is
unsigned int nb_chapters
Number of chapters in AVChapter array.
This struct describes the properties of an encoded stream.
static const char *const opt_name_enc_stats_pre[]
static enum AVSampleFormat sample_fmts[]
static void parse_matrix_coeffs(void *logctx, uint16_t *dest, const char *str)
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)
void sq_limit_frames(SyncQueue *sq, unsigned int stream_idx, uint64_t frames)
Limit the number of output frames for stream with index stream_idx to max_frames.
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
#define IS_INTERLEAVED(type)
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
InputStream * ist_iter(InputStream *prev)
int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
int max_muxing_queue_size
int64_t start_time
start time in microseconds == AV_TIME_BASE units
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
AVStream ** streams
A list of all streams in the file.
static void map_auto_video(Muxer *mux, const OptionsContext *o)
size_t muxing_queue_data_threshold
static const char * subtitle_codec_name
static const char *const opt_name_disposition[]
static const char *const opt_name_sample_fmts[]
static int fix_sub_duration_heartbeat(InputStream *ist, int64_t signal_pts)
static OutputStream * ost_add(Muxer *mux, const OptionsContext *o, enum AVMediaType type, InputStream *ist)
AVRational avg_frame_rate
Average framerate.
static const char *const opt_name_max_frames[]
static const char *const opt_name_mux_stats[]
#define AV_DICT_APPEND
If the entry already exists, append to it.
static const char *const opt_name_fix_sub_duration_heartbeat[]
static void freeenv_utf8(char *var)
#define AV_NOWARN_DEPRECATED(code)
Disable warnings about deprecated features This is useful for sections of code kept for backward comp...
#define IS_AV_ENC(ost, type)
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
static const char *const opt_name_qscale[]
static void set_channel_layout(OutputFilter *f, OutputStream *ost)
enum AVChannelOrder order
Channel order used in this layout.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
int nb_channels
Number of channels in this layout.
static int enc_stats_init(OutputStream *ost, EncStats *es, int pre, const char *path, const char *fmt_spec)
int64_t avio_size(AVIOContext *s)
Get the filesize.
static const char *const opt_name_apad[]
static int set_dispositions(Muxer *mux, const OptionsContext *o)
static void new_stream_audio(Muxer *mux, const OptionsContext *o, OutputStream *ost)
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
static void of_add_programs(Muxer *mux, const OptionsContext *o)
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
#define SET_DICT(type, meta, context, index)
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
static void of_add_metadata(OutputFile *of, AVFormatContext *oc, const OptionsContext *o)
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
void assert_file_overwrite(const char *filename)
const struct AVCodec * codec
static const Preset presets[]
static const char *const opt_name_audio_channels[]
static void ost_add_from_filter(OutputFilter *ofilter, const OptionsContext *o, Muxer *mux)
AVChannelLayout ch_layout
Audio channel layout.
void report_and_exit(int ret)
Reports an error corresponding to the provided AVERROR code and calls exit_program() with the corresp...
static Muxer * mux_alloc(void)
static const char *const opt_name_audio_ch_layouts[]
static const char *const opt_name_audio_sample_rate[]
int flags
AV_CODEC_FLAG_*.
static double val(void *priv, double ch)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
static int setup_sync_queues(Muxer *mux, AVFormatContext *oc, int64_t buf_size_us)
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
AVProgram * av_new_program(AVFormatContext *ac, int id)
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
int64_t duration
Decoding: duration of the stream, in stream time base.
int av_codec_get_tag2(const struct AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Get the codec tag for the given codec id.
static EncStatsFile * enc_stats_files
int nb_audio_channel_maps
#define FFDIFFSIGN(x, y)
Comparator.
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
#define FF_ARRAY_ELEMS(a)
AVDictionary * codec_opts
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate,...
static const uint16_t mask[17]
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
static const AVClass output_stream_class
EncStatsComponent * components
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
int64_t end
chapter start/end time in time_base units
char * specifier
stream/chapter/program/...
This struct describes the properties of a single codec described by an AVCodecID.
static MuxStream * mux_stream_alloc(Muxer *mux, enum AVMediaType type)
static const char *const opt_name_enc_stats_post_fmt[]
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
int mux_check_init(Muxer *mux)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
static int enc_stats_get_file(AVIOContext **io, const char *path)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
int flags
Flags modifying the (de)muxer behaviour.
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
AVRational sample_aspect_ratio
Video only.
static const AVClass output_file_class
static void of_add_attachments(Muxer *mux, const OptionsContext *o)
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
static char * get_line(AVIOContext *s, AVBPrint *bprint)
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const char * output_stream_item_name(void *obj)
#define AVIO_FLAG_WRITE
write-only
struct OutputStream * ost
int ignore_unknown_streams
static const char *const opt_name_enc_stats_pre_fmt[]
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static const char *const opt_name_intra_matrices[]
static void create_streams(Muxer *mux, const OptionsContext *o)
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
int sq_add_stream(SyncQueue *sq, int limiting)
Add a new stream to the sync queue.
AVDictionary * encoder_opts
@ AVDISCARD_ALL
discard all
#define av_realloc_f(p, o, n)
AVDictionary * format_opts
AVCodecParameters * codecpar
Codec parameters associated with this stream.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
static const char *const opt_name_inter_matrices[]
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
#define DEFAULT_PASS_LOGFILENAME_PREFIX
static void map_manual(Muxer *mux, const OptionsContext *o, const StreamMap *map)
static int nb_enc_stats_files
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Rational number (pair of numerator and denominator).
enum AVPacketSideDataType type
static const char *const opt_name_forced_key_frames[]
AVIOContext * pb
I/O context.
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
static char * getenv_utf8(const char *varname)
static const char *const opt_name_time_bases[]
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
static void validate_enc_avopt(Muxer *mux, const AVDictionary *codec_avopt)
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
SpecifierOpt * max_frames
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
static int ost_get_filters(const OptionsContext *o, AVFormatContext *oc, OutputStream *ost)
AVChannelLayout ch_layout
Audio only.
static int copy_metadata(Muxer *mux, AVFormatContext *ic, const char *outspec, const char *inspec, int *metadata_global_manual, int *metadata_streams_manual, int *metadata_chapters_manual)
int of_open(const OptionsContext *o, const char *filename)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static const char *const opt_name_chroma_intra_matrices[]
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poin...
AVCodecID
Identify the syntax and semantics of the bitstream.
static const char *const opt_name_frame_pix_fmts[]
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static void new_stream_attachment(Muxer *mux, const OptionsContext *o, OutputStream *ost)
AVDictionary * codec_opts
static const char *const opt_name_filter_scripts[]
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
static const uint8_t frame_sizes[]
static const char *const opt_name_mux_stats_fmt[]
static const char *const opt_name_bits_per_raw_sample[]
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
OutputFile ** output_files
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
static const char *const opt_name_frame_sizes[]
static int64_t start_time
char * url
input or output URL.
enum AVSampleFormat sample_fmt
audio sample format
static int init_output_stream_nofilter(OutputStream *ost)
#define AV_NOPTS_VALUE
Undefined timestamp value.
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
static const char *const opt_name_pass[]
uint16_t * chroma_intra_matrix
custom intra quantization matrix
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
void * allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
Atomically add a new element to an array of pointers, i.e.
void of_enc_stats_close(void)
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int avio_r8(AVIOContext *s)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
int enc_alloc(Encoder **penc, const AVCodec *codec)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
AVDictionary * strip_specifiers(const AVDictionary *dict)
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
static const char *const opt_name_enc_stats_post[]
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
static const char *const opt_name_autoscale[]
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
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 layout
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
#define i(width, name, range_min, range_max)
SpecifierOpt * metadata_map
int64_t id
unique ID to identify the chapter
static void new_stream_subtitle(Muxer *mux, const OptionsContext *o, OutputStream *ost)
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
#define AV_TIME_BASE
Internal time base represented as integer.
int block_align
Audio only.
const AVCodec * find_codec_or_die(void *logctx, const char *name, enum AVMediaType type, int encoder)
float shortest_buf_duration
#define av_malloc_array(a, b)
static void map_auto_audio(Muxer *mux, const OptionsContext *o)
static const char *const opt_name_frame_aspect_ratios[]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static const char *const opt_name_enc_time_bases[]
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec)
Filter out options for given codec.
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
New fields can be added to the end with minor version bumps.
const char * name
Name of the codec implementation.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
FilterGraph ** filtergraphs
const AVIOInterruptCB int_cb
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
int id
Format-specific stream ID.
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
const struct AVOutputFormat * oformat
The output container format.
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
static const char * output_file_item_name(void *obj)
int nb_side_data
The number of elements in the AVStream.side_data array.
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
AudioChannelMap * audio_channel_maps
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
#define AV_INPUT_BUFFER_PADDING_SIZE
enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
Guess the codec ID based upon muxer and filename.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
main external API structure.
int index
stream index in AVFormatContext
@ AV_CLASS_CATEGORY_MUXER
int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt, AVStream *ost, const AVStream *ist, enum AVTimebaseSource copy_tb)
Transfer internal timing information from one stream to another.
static void map_auto_subtitle(Muxer *mux, const OptionsContext *o)
static void map_auto_data(Muxer *mux, const OptionsContext *o)
int ist_output_add(InputStream *ist, OutputStream *ost)
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
AVRational r_frame_rate
Real base framerate of the stream.
static void new_stream_video(Muxer *mux, const OptionsContext *o, OutputStream *ost)
static const char *const opt_name_passlogfiles[]
static const char *const opt_name_rc_overrides[]
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
enum VideoSyncMethod video_sync_method
#define GROW_ARRAY(array, nb_elems)
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
#define AVIO_FLAG_READ
read-only
char * av_strdup(const char *s)
Duplicate a string.
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
static int unescape(char **pdst, size_t *dst_len, const char **pstr, char delim)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
const VDPAUPixFmtMap * map
static int compare_int64(const void *a, const void *b)
static void copy_meta(Muxer *mux, const OptionsContext *o)
const char ** attachments
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
This structure stores compressed data.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions,...
int rc_override_count
ratecontrol override, see RcOverride
char * file_read(const char *filename)
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, size_t size)
Allocate new information from stream.
char * name
unique name for this input/output in the list
int width
picture width / height.
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds.
static int check_opt_bitexact(void *ctx, const AVDictionary *opts, const char *opt_name, int flag)
const char *const forced_keyframes_const_names[]
#define MKTAG(a, b, c, d)
static int process_forced_keyframes(Muxer *mux, const OptionsContext *o)
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
const AVOutputFormat * format
SyncQueue * sq_alloc(enum SyncQueueType type, int64_t buf_size_us, void *logctx)
Allocate a sync queue of the given type.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
static const char *const opt_name_copy_initial_nonkeyframes[]
AVRational time_base
time base in which the start/end timestamps are specified
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
int of_stream_init(OutputFile *of, OutputStream *ost)
A linked-list of the inputs/outputs of the filter chain.
static const char *const opt_name_fps_mode[]
int enc_open(OutputStream *ost, AVFrame *frame)
static const char *const opt_name_bitstream_filters[]
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
static void parse_meta_type(void *logctx, const char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
static const char *const opt_name_presets[]
static int copy_chapters(InputFile *ifile, OutputFile *ofile, AVFormatContext *os, int copy_metadata)
static const char *const opt_name_max_frame_rates[]
static const char *const opt_name_copy_prior_start[]
static const char *const opt_name_force_fps[]
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.