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")) {
145 ost->par_in->codec_id = (*enc)->
id;
168 char *env_avconv_datadir =
getenv_utf8(
"AVCONV_DATADIR");
170 const char *
base[3] = { env_avconv_datadir,
179 snprintf(filename,
sizeof(filename),
"%s%s/%s-%s.avpreset",
base[
i],
180 i != 1 ?
"" :
"/.avconv", codec_name, preset_name);
184 snprintf(filename,
sizeof(filename),
"%s%s/%s.avpreset",
base[
i],
185 i != 1 ?
"" :
"/.avconv", preset_name);
246 const char **pstr,
char delim)
248 const char *str = *pstr;
262 for (idx = 0; *str; idx++, str++) {
263 if (str[0] ==
'\\' && str[1])
265 else if (*str == delim)
285 const char *path,
const char *fmt_spec)
287 static const struct {
292 int need_input_data:1;
312 const char *next = fmt_spec;
336 c->str_len = val_len;
350 "Empty formatting directive in: %s\n", fmt_spec);
356 "Missing closing brace in: %s\n", fmt_spec);
369 if (!strcmp(
val, fmt_specs[
i].str)) {
370 if ((pre && fmt_specs[
i].post_only) || (!pre && fmt_specs[
i].pre_only)) {
372 "Format directive '%s' may only be used %s-encoding\n",
373 val, pre ?
"post" :
"pre");
378 c->type = fmt_specs[
i].type;
380 if (fmt_specs[
i].need_input_data && !
ost->ist) {
382 "Format directive '%s' is unavailable, because "
383 "this output stream has no associated input stream\n",
454 if (filters_script ||
filters) {
456 "%s '%s' was specified, but codec copy was selected. "
457 "Filtering and streamcopy cannot be used together.\n",
458 filters ?
"Filtergraph" :
"Filtergraph script",
466 if (filters_script ||
filters) {
468 "%s '%s' was specified for a stream fed from a complex "
469 "filtergraph. Simple and complex filtering cannot be used "
470 "together for the same stream.\n",
471 filters ?
"Filtergraph" :
"Filtergraph script",
478 if (filters_script &&
filters) {
489 return *dst ? 0 :
AVERROR(ENOMEM);
503 "Syntax error in matrix \"%s\" at coeff %d\n", str,
i);
526 int has_alpha =
desc ?
desc->nb_components % 2 == 0 : 0;
537 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
564 int len = strlen(name_canonical);
566 if (strcmp(
name, name_canonical) &&
567 (!strcmp(name_canonical +
len - 2,
"le") ||
568 !strcmp(name_canonical +
len - 2,
"be"))) {
572 snprintf(name_other,
sizeof(name_other),
"%s%ce",
573 name, name_canonical[
len - 2] ==
'l' ?
'b' :
'l');
594 char *frame_rate =
NULL, *max_frame_rate =
NULL, *frame_aspect_ratio =
NULL;
611 if (frame_rate && max_frame_rate) {
617 if (frame_aspect_ratio) {
620 q.
num <= 0 || q.
den <= 0) {
624 ost->frame_aspect_ratio = q;
629 const char *p =
NULL, *fps_mode =
NULL;
631 char *frame_pix_fmt =
NULL;
632 char *intra_matrix =
NULL, *inter_matrix =
NULL;
633 char *chroma_intra_matrix =
NULL;
647 if (frame_pix_fmt && *frame_pix_fmt ==
'+') {
648 ost->keep_pix_fmt = 1;
649 if (!*++frame_pix_fmt)
650 frame_pix_fmt =
NULL;
668 if (chroma_intra_matrix) {
687 for (
i = 0; p;
i++) {
689 int e = sscanf(p,
"%d,%d,%d", &start, &end, &q);
737 if (
ost->logfile_prefix &&
743 char logfilename[1024];
747 for (
int i = 0;
i <=
ost->file_index;
i++)
750 snprintf(logfilename,
sizeof(logfilename),
"%s-%d.log",
751 ost->logfile_prefix ?
ost->logfile_prefix :
754 if (!strcmp(
ost->enc_ctx->codec->name,
"libx264")) {
758 char *logbuffer =
file_read(logfilename);
771 "Cannot write log file '%s' for pass-1 encoding: %s\n",
772 logfilename, strerror(errno));
783 ost->top_field_first = -1;
785 if (
ost->top_field_first >= 0)
797 if ((
ost->frame_rate.num ||
ost->max_frame_rate.num) &&
801 "together a non-CFR -vsync/-fps_mode. This is contradictory.\n");
806 if (
ost->frame_rate.num ||
ost->max_frame_rate.num) {
847 char *sample_fmt =
NULL;
858 #if FF_API_OLD_CHANNEL_LAYOUT
867 #if FF_API_OLD_CHANNEL_LAYOUT
888 #if FFMPEG_OPT_MAP_CHANNEL
892 if ((
map->ofile_idx == -1 ||
ost->file_index ==
map->ofile_idx) &&
896 if (
map->channel_idx == -1) {
898 }
else if (!
ost->ist) {
908 ost->audio_channels_mapped + 1,
909 sizeof(*
ost->audio_channels_map));
913 ost->audio_channels_map[
ost->audio_channels_mapped++] =
map->channel_idx;
944 int input_props = 0, output_props = 0;
956 if (input_descriptor)
958 if (output_descriptor)
960 if (input_props && output_props && input_props != output_props) {
962 "Subtitle encoding currently only possible from text to text "
963 "or bitmap to bitmap\n");
997 "Error setting up codec context options.\n");
1004 "Error getting reference codec parameters.\n");
1010 unsigned int codec_tag_tmp;
1057 memcpy(dst_data, sd_src->
data, sd_src->
size);
1060 #if FFMPEG_ROTATION_METADATA
1061 if (
ost->rotate_overridden) {
1079 if (
ost->frame_aspect_ratio.num) {
1084 "with stream copy may produce invalid files\n");
1113 const char *bsfs =
NULL, *time_base =
NULL;
1135 st->
id = strtol(e->
value, &p, 0);
1136 if (!e->
value[0] || *p) {
1155 ost->par_in->codec_type =
type;
1178 "Streamcopy requested for output stream fed "
1179 "from a complex filtergraph. Filtering and streamcopy "
1180 "cannot be used together.\n");
1208 const char *enc_stats_pre =
NULL, *enc_stats_post =
NULL, *mux_stats =
NULL;
1209 const char *enc_time_base =
NULL;
1212 oc, st, enc->
codec, &
ost->encoder_opts);
1230 if (!buf[0] || buf[0] ==
'#')
1232 if (!(
arg = strchr(buf,
'='))) {
1239 }
while (!
s->eof_reached);
1245 "Preset %s specified, but could not be opened.\n",
preset);
1250 if (enc_stats_pre &&
1252 const char *
format =
"{fidx} {sidx} {n} {t}";
1262 if (enc_stats_post &&
1264 const char *
format =
"{fidx} {sidx} {n} {t}";
1276 const char *
format =
"{fidx} {sidx} {n} {t}";
1286 if (enc_time_base) {
1288 if (!strcmp(enc_time_base,
"demux")) {
1290 }
else if (!strcmp(enc_time_base,
"filter")) {
1294 if (
ret < 0 || q.
den <= 0
1302 #if FFMPEG_OPT_ENC_TIME_BASE_NUM
1305 " use -enc_timebase demux\n");
1309 ost->enc_timebase = q;
1321 }
else if (
ost->enc_ctx) {
1330 q.
num <= 0 || q.
den <= 0) {
1342 av_log(
ost,
AV_LOG_WARNING,
"Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1351 if (bsfs && *bsfs) {
1361 uint32_t
tag = strtol(codec_tag, &next, 0);
1363 uint8_t buf[4] = { 0 };
1364 memcpy(buf, codec_tag,
FFMIN(
sizeof(buf), strlen(codec_tag)));
1368 ost->par_in->codec_tag =
tag;
1370 ost->enc_ctx->codec_tag =
tag;
1374 if (
ost->enc_ctx && qscale >= 0) {
1423 ost->filter = ofilter;
1431 "Error initializing a simple filtergraph\n");
1435 }
else if (
ost->ist) {
1439 "Error binding an input stream\n");
1444 if (
ost->ist && !
ost->enc) {
1477 int file_best_score = 0;
1492 if (score > file_best_score) {
1495 file_best_score = score;
1496 file_best_ist = ist;
1499 if (file_best_ist) {
1500 if((qcr ==
MKTAG(
'A',
'P',
'I',
'C')) ||
1503 if (file_best_score > best_score) {
1504 best_score = file_best_score;
1505 best_ist = file_best_ist;
1528 int file_best_score = 0;
1540 if (score > file_best_score) {
1541 file_best_score = score;
1542 file_best_ist = ist;
1545 if (file_best_ist) {
1547 if (file_best_score > best_score) {
1548 best_score = file_best_score;
1549 best_ist = file_best_ist;
1576 int input_props = 0, output_props = 0;
1581 if (input_descriptor)
1583 if (output_descriptor)
1586 input_props & output_props ||
1588 input_descriptor && output_descriptor &&
1589 (!input_descriptor->
props ||
1590 !output_descriptor->
props)) {
1611 ist->st->codecpar->codec_id ==
codec_id) {
1629 if (
map->linklabel) {
1638 if (linklabel && !strcmp(linklabel,
map->linklabel)) {
1647 "in any defined filter graph, or was already used elsewhere.\n",
map->linklabel);
1652 "mapped complex filtergraph %d, output [%s]\n", fg->
index,
map->linklabel);
1661 map->file_index,
map->stream_index);
1676 "Cannot map stream #%d:%d - unsupported type.\n",
1677 map->file_index,
map->stream_index);
1680 "If you want unsupported types ignored instead "
1681 "of failing, please use the -ignore_unknown option\n"
1682 "If you want them copied, please use -copy_unknown\n");
1703 uint8_t *attachment;
1735 else if (err !=
len) {
1758 ost->par_in->extradata = attachment;
1759 ost->par_in->extradata_size =
len;
1796 auto_disable |= 1 << ofilter->
type;
1799 "output of complex filtergraph %d.", fg->
index);
1816 if (!map_func[
i] || auto_disable & (1 <<
i))
1818 ret = map_func[
i](mux, o);
1848 int nb_av_enc = 0, nb_audio_fs = 0, nb_interleaved = 0;
1849 int limit_frames = 0, limit_frames_av_enc = 0;
1851 #define IS_AV_ENC(ost, type) \
1852 (ost->enc_ctx && (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO))
1853 #define IS_INTERLEAVED(type) (type != AVMEDIA_TYPE_ATTACHMENT)
1860 ost->sq_idx_encode = -1;
1861 ost->sq_idx_mux = -1;
1872 if (!((nb_interleaved > 1 && of->
shortest) ||
1873 (nb_interleaved > 0 && limit_frames) ||
1884 if ((of->
shortest && nb_av_enc > 1) || limit_frames_av_enc || nb_audio_fs) {
1899 if (
ost->sq_idx_encode < 0)
1900 return ost->sq_idx_encode;
1909 if (nb_interleaved > nb_av_enc) {
1928 if (
ost->sq_idx_mux < 0)
1929 return ost->sq_idx_mux;
1937 #undef IS_INTERLEAVED
1950 int ret, progid =
i + 1;
1987 if (!strcmp(e->
key,
"st"))
2012 char *
type,
int *
index,
const char **stream_spec)
2020 if (*(++
arg) && *
arg !=
':') {
2024 *stream_spec = *
arg ==
':' ?
arg + 1 :
"";
2028 if (*(++
arg) ==
':')
2047 const char *stream_spec;
2066 #if FFMPEG_ROTATION_METADATA
2071 ost->rotate_overridden = 1;
2072 ost->rotate_override_value = theta;
2076 "Conversion of a 'rotate' metadata key to a "
2077 "proper display matrix rotation is deprecated. "
2078 "See -display_rotation for setting rotation "
2083 #if FFMPEG_ROTATION_METADATA
2131 for (
i = 0;
i <
is->nb_chapters;
i++) {
2140 if (in_ch->
end < ts_off)
2142 if (rt != INT64_MAX && in_ch->
start > rt + ts_off)
2149 out_ch->id = in_ch->
id;
2151 out_ch->start =
FFMAX(0, in_ch->
start - ts_off);
2152 out_ch->end =
FFMIN(rt, in_ch->
end - ts_off);
2163 const char *outspec,
const char *inspec,
2164 int *metadata_global_manual,
int *metadata_streams_manual,
2165 int *metadata_chapters_manual)
2171 char type_in, type_out;
2172 const char *istream_spec =
NULL, *ostream_spec =
NULL;
2173 int idx_in = 0, idx_out = 0;
2181 if (type_in ==
'g' || type_out ==
'g' || !*outspec)
2182 *metadata_global_manual = 1;
2183 if (type_in ==
's' || type_out ==
's' || !*outspec)
2184 *metadata_streams_manual = 1;
2185 if (type_in ==
'c' || type_out ==
'c' || !*outspec)
2186 *metadata_chapters_manual = 1;
2192 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2193 if ((index) < 0 || (index) >= (nb_elems)) {\
2194 av_log(mux, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
2196 return AVERROR(EINVAL);\
2199 #define SET_DICT(type, meta, context, index)\
2202 meta = &context->metadata;\
2205 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
2206 meta = &context->chapters[index]->metadata;\
2209 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
2210 meta = &context->programs[index]->metadata;\
2214 default: av_assert0(0);\
2217 SET_DICT(type_in, meta_in, ic, idx_in);
2218 SET_DICT(type_out, meta_out, oc, idx_out);
2221 if (type_in ==
's') {
2230 av_log(mux,
AV_LOG_FATAL,
"Stream specifier %s does not match any streams.\n", istream_spec);
2235 if (type_out ==
's') {
2254 int metadata_global_manual = 0;
2255 int metadata_streams_manual = 0;
2256 int metadata_chapters_manual = 0;
2266 "processing metadata maps\n", in_file_index);
2272 &metadata_global_manual, &metadata_streams_manual,
2273 &metadata_chapters_manual);
2280 if (chapters_input_file == INT_MAX) {
2282 chapters_input_file = -1;
2285 chapters_input_file =
i;
2290 chapters_input_file);
2294 if (chapters_input_file >= 0)
2296 !metadata_chapters_manual);
2309 if (!metadata_streams_manual)
2332 int have_manual = 0;
2335 const char **dispositions;
2349 have_manual |= !!dispositions[
i];
2355 have_default[
ost->type + 1] = 1;
2363 const char *disp = dispositions[
i];
2385 have_default[
type + 1] = 1;
2406 return FFDIFFSIGN(*(
const int64_t *)
a, *(
const int64_t *)
b);
2410 const Muxer *mux,
const char *spec)
2416 for (p = spec; *p; p++)
2425 for (
i = 0;
i < n;
i++) {
2426 char *next = strchr(p,
',');
2431 if (strstr(p,
"chapters") == p) {
2436 if (nb_ch > INT_MAX -
size ||
2445 "Invalid chapter time offset: %s\n", p + 8);
2451 for (j = 0; j < nb_ch; j++) {
2487 const char *forced_keyframes =
NULL;
2492 ost->enc_ctx && forced_keyframes))
2495 if (!strncmp(forced_keyframes,
"expr:", 5)) {
2500 "Invalid force_key_frames expression '%s'\n", forced_keyframes + 5);
2503 ost->kf.expr_const_values[
FKF_N] = 0;
2510 }
else if (!strcmp(forced_keyframes,
"source")) {
2512 }
else if (!strcmp(forced_keyframes,
"source_no_drop")) {
2556 if (!strcmp(e->
key,
"gop_timecode"))
2560 "for any stream. The most likely reason is either wrong type "
2561 "(e.g. a video option with no video streams) or that it is a "
2562 "private option of some encoder which was not actually used for "
2589 const Muxer *mux = obj;
2632 if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
2633 stop_time = INT64_MAX;
2637 if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
2655 if (!strcmp(filename,
"-"))
2673 if (recording_time != INT64_MAX)
2699 "Output filename '%s' does not contain a numeric pattern like "
2700 "'%%d', which is required by output format '%s'.\n",
static int choose_encoder(const OptionsContext *o, AVFormatContext *s, OutputStream *ost, const AVCodec **enc)
static FILE * fopen_utf8(const char *path, const char *mode)
static int streamcopy_init(const Muxer *mux, OutputStream *ost)
static int map_manual(Muxer *mux, const OptionsContext *o, const StreamMap *map)
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
AVPixelFormat
Pixel format.
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 default minimum maximum flags name is the option name
static int ost_get_filters(const OptionsContext *o, AVFormatContext *oc, OutputStream *ost, char **dst)
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
struct FilterGraph * graph
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
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[]
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
static enum AVSampleFormat sample_fmts[]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#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.
#define FFMPEG_OPT_ENC_TIME_BASE_NUM
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
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
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.
size_t muxing_queue_data_threshold
static const char * subtitle_codec_name
static int new_stream_video(Muxer *mux, const OptionsContext *o, OutputStream *ost)
static const char *const opt_name_disposition[]
static const char *const opt_name_sample_fmts[]
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.
#define AV_LOG_VERBOSE
Detailed information.
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...
static int ost_add(Muxer *mux, const OptionsContext *o, enum AVMediaType type, InputStream *ist, OutputFilter *ofilter, OutputStream **post)
#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[]
enum AVChannelOrder order
Channel order used in this layout.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
static int parse_forced_key_frames(void *log, KeyframeForceCtx *kf, const Muxer *mux, const char *spec)
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 int parse_matrix_coeffs(void *logctx, uint16_t *dest, const char *str)
static const char *const opt_name_apad[]
static int set_dispositions(Muxer *mux, const OptionsContext *o)
AVRational stream_duration_tb
#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 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.
#define SET_DICT(type, meta, context, index)
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
static int map_auto_subtitle(Muxer *mux, 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.
const struct AVCodec * codec
static const Preset presets[]
static const char *const opt_name_audio_channels[]
AVChannelLayout ch_layout
Audio channel layout.
static Muxer * mux_alloc(void)
static const char *const opt_name_audio_ch_layouts[]
static int copy_meta(Muxer *mux, const OptionsContext *o)
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.
#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.
int assert_file_overwrite(const char *filename)
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 int new_stream_attachment(Muxer *mux, const OptionsContext *o, OutputStream *ost)
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
@ 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)
static int of_add_metadata(OutputFile *of, AVFormatContext *oc, const OptionsContext *o)
#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 enum AVPixelFormat choose_pixel_fmt(const AVCodec *codec, enum AVPixelFormat target)
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst)
Filter out options for given codec.
@ 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
static int new_stream_subtitle(Muxer *mux, const OptionsContext *o, OutputStream *ost)
static int validate_enc_avopt(Muxer *mux, const AVDictionary *codec_avopt)
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 int parse_meta_type(void *logctx, const char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
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
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
static int map_auto_video(Muxer *mux, const OptionsContext *o)
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.
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
#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.
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
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **codec)
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 int of_add_programs(Muxer *mux, const OptionsContext *o)
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.
int fix_sub_duration_heartbeat(InputStream *ist, int64_t signal_pts)
#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.
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.
static int map_auto_data(Muxer *mux, const OptionsContext *o)
#define i(width, name, range_min, range_max)
SpecifierOpt * metadata_map
int64_t id
unique ID to identify the chapter
static enum AVPixelFormat pix_fmt_parse(OutputStream *ost, const char *name)
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.
float shortest_buf_duration
#define av_malloc_array(a, b)
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[]
@ 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
static int fmt_in_list(const int *formats, int format)
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.
static int of_add_attachments(Muxer *mux, const OptionsContext *o)
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.
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.
int init_simple_filtergraph(InputStream *ist, OutputStream *ost, char *graph_desc)
int ist_output_add(InputStream *ist, OutputStream *ost)
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
AVRational r_frame_rate
Real base framerate of the stream.
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)
static int map_auto_audio(Muxer *mux, const OptionsContext *o)
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).
static int new_stream_audio(Muxer *mux, const OptionsContext *o, OutputStream *ost)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
const VDPAUPixFmtMap * map
static int compare_int64(const void *a, const void *b)
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.
int width
picture width / height.
static int check_opt_bitexact(void *ctx, const AVDictionary *opts, const char *opt_name, int flag)
const char *const forced_keyframes_const_names[]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#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)
static const char *const opt_name_fps_mode[]
int enc_open(OutputStream *ost, AVFrame *frame)
static const char *const opt_name_bitstream_filters[]
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 int create_streams(Muxer *mux, const OptionsContext *o)
static const char *const opt_name_copy_prior_start[]
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.
static const char *const opt_name_force_fps[]
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.