Go to the documentation of this file.
51 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
54 const char *opt_name,
int flag)
73 const char *codec_name =
NULL;
82 if (codec_name && strcmp(codec_name,
"copy")) {
85 "Encoder '%s' specified, but only '-codec copy' supported "
86 "for %s streams\n", codec_name, type_str);
97 "Default encoder for format %s (codec %s) is "
98 "probably disabled. Please choose an encoder manually.\n",
102 }
else if (strcmp(codec_name,
"copy")) {
106 ost->par_in->codec_id = (*enc)->
id;
129 char *env_avconv_datadir =
getenv_utf8(
"AVCONV_DATADIR");
131 const char *
base[3] = { env_avconv_datadir,
140 snprintf(filename,
sizeof(filename),
"%s%s/%s-%s.avpreset",
base[
i],
141 i != 1 ?
"" :
"/.avconv", codec_name, preset_name);
145 snprintf(filename,
sizeof(filename),
"%s%s/%s.avpreset",
base[
i],
146 i != 1 ?
"" :
"/.avconv", preset_name);
207 const char **pstr,
char delim)
209 const char *str = *pstr;
223 for (idx = 0; *str; idx++, str++) {
224 if (str[0] ==
'\\' && str[1])
226 else if (*str == delim)
246 const char *path,
const char *fmt_spec)
248 static const struct {
252 unsigned post_only:1;
253 unsigned need_input_data:1;
274 const char *next = fmt_spec;
298 c->str_len = val_len;
312 "Empty formatting directive in: %s\n", fmt_spec);
318 "Missing closing brace in: %s\n", fmt_spec);
331 if (!strcmp(
val, fmt_specs[
i].str)) {
332 if ((pre && fmt_specs[
i].post_only) || (!pre && fmt_specs[
i].pre_only)) {
334 "Format directive '%s' may only be used %s-encoding\n",
335 val, pre ?
"post" :
"pre");
340 c->type = fmt_specs[
i].type;
342 if (fmt_specs[
i].need_input_data && !
ost->ist) {
344 "Format directive '%s' is unavailable, because "
345 "this output stream has no associated input stream\n",
419 #if FFMPEG_OPT_FILTER_SCRIPT
420 const char *filters_script =
NULL;
433 "%s '%s' was specified, but codec copy was selected. "
434 "Filtering and streamcopy cannot be used together.\n",
436 filters ?
"Filtergraph" :
"Filtergraph script",
454 "%s '%s' was specified for a stream fed from a complex "
455 "filtergraph. Simple and complex filtering cannot be used "
456 "together for the same stream.\n",
458 filters ?
"Filtergraph" :
"Filtergraph script",
469 #if FFMPEG_OPT_FILTER_SCRIPT
470 if (filters_script &&
filters) {
489 for (
int i = 0;;
i++) {
496 "Syntax error in matrix \"%s\" at coeff %d\n", str,
i);
519 int has_alpha =
desc ?
desc->nb_components % 2 == 0 : 0;
524 0, (
const void **) &p,
NULL);
536 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
558 0, (
const void **) &fmts,
NULL);
569 int len = strlen(name_canonical);
571 if (strcmp(
name, name_canonical) &&
572 (!strcmp(name_canonical +
len - 2,
"le") ||
573 !strcmp(name_canonical +
len - 2,
"be"))) {
577 snprintf(name_other,
sizeof(name_other),
"%s%ce",
578 name, name_canonical[
len - 2] ==
'l' ?
'b' :
'l');
601 const char *frame_rate =
NULL, *max_frame_rate =
NULL, *frame_aspect_ratio =
NULL;
618 if (frame_rate && max_frame_rate) {
624 if (frame_aspect_ratio) {
627 q.
num <= 0 || q.
den <= 0) {
631 ost->frame_aspect_ratio = q;
636 const char *p =
NULL, *fps_mode =
NULL;
638 const char *frame_pix_fmt =
NULL;
639 const char *intra_matrix =
NULL, *inter_matrix =
NULL;
640 const char *chroma_intra_matrix =
NULL;
654 if (frame_pix_fmt && *frame_pix_fmt ==
'+') {
656 if (!*++frame_pix_fmt)
657 frame_pix_fmt =
NULL;
675 if (chroma_intra_matrix) {
692 for (
i = 0; p;
i++) {
694 int e = sscanf(p,
"%d,%d,%d", &start, &end, &q);
731 if (
ost->logfile_prefix &&
737 char logfilename[1024];
741 for (
int idx = 0; idx <=
ost->file->
index; idx++)
744 snprintf(logfilename,
sizeof(logfilename),
"%s-%d.log",
745 ost->logfile_prefix ?
ost->logfile_prefix :
746 DEFAULT_PASS_LOGFILENAME_PREFIX,
748 if (!strcmp(
ost->enc_ctx->codec->name,
"libx264") || !strcmp(
ost->enc_ctx->codec->name,
"libvvenc")) {
755 char *logbuffer =
file_read(logfilename);
768 "Cannot write log file '%s' for pass-1 encoding: %s\n",
769 logfilename, strerror(errno));
780 ost->top_field_first = -1;
782 if (
ost->top_field_first >= 0)
798 if ((
ost->frame_rate.num ||
ost->max_frame_rate.num) &&
802 "together a non-CFR -vsync/-fps_mode. This is contradictory.\n");
807 if (
ost->frame_rate.num ||
ost->max_frame_rate.num) {
828 #if FFMPEG_OPT_VSYNC_DROP
848 const char *sample_fmt =
NULL;
890 int input_props = 0, output_props = 0;
902 if (input_descriptor)
904 if (output_descriptor)
906 if (input_props && output_props && input_props != output_props) {
908 "Subtitle encoding currently only possible from text to text "
909 "or bitmap to bitmap\n");
921 int keep_pix_fmt,
int autoscale,
int threads_manual)
929 .enc = enc_ctx->
codec,
933 .width = enc_ctx->
width,
934 .height = enc_ctx->
height,
937 .vsync_method = vsync_method,
959 (
const void **) &
opts.formats,
NULL);
963 if (!
ost->force_fps) {
966 (
const void **) &
opts.frame_rates,
NULL);
972 (
const void **) &
opts.color_spaces,
NULL);
977 (
const void **) &
opts.color_ranges,
NULL);
983 (
const void **) &
opts.formats,
NULL);
988 (
const void **) &
opts.sample_rates,
NULL);
993 (
const void **) &
opts.ch_layouts,
NULL);
998 if (threads_manual) {
1005 ost->filter = ofilter;
1048 "Error setting up codec context options.\n");
1055 "Error getting reference codec parameters.\n");
1061 unsigned int codec_tag_tmp;
1118 if (
ost->frame_aspect_ratio.num) {
1123 "with stream copy may produce invalid files\n");
1150 int ret = 0, keep_pix_fmt = 0, autoscale = 1;
1151 int threads_manual = 0;
1154 const char *bsfs =
NULL, *time_base =
NULL, *codec_tag =
NULL;
1168 if (ist || ofilter) {
1191 st->
id = strtol(e->
value, &p, 0);
1192 if (!e->
value[0] || *p) {
1208 ost->par_in->codec_type =
type;
1237 "Streamcopy requested for output stream fed "
1238 "from a complex filtergraph. Filtering and streamcopy "
1239 "cannot be used together.\n");
1266 const char *enc_stats_pre =
NULL, *enc_stats_post =
NULL, *mux_stats =
NULL;
1270 oc, st,
ost->enc_ctx->codec, &encoder_opts,
1288 if (!buf[0] || buf[0] ==
'#')
1290 if (!(
arg = strchr(buf,
'='))) {
1297 }
while (!
s->eof_reached);
1303 "Preset %s specified, but could not be opened.\n",
preset);
1308 if (enc_stats_pre &&
1310 const char *
format =
"{fidx} {sidx} {n} {t}";
1320 if (enc_stats_post &&
1322 const char *
format =
"{fidx} {sidx} {n} {t}";
1334 const char *
format =
"{fidx} {sidx} {n} {t}";
1346 "-enc_time_base not supported for subtitles, ignoring\n");
1347 else if (enc_time_base) {
1350 if (!strcmp(enc_time_base,
"demux")) {
1352 }
else if (!strcmp(enc_time_base,
"filter")) {
1356 if (
ret < 0 || q.
den <= 0
1365 #if FFMPEG_OPT_ENC_TIME_BASE_NUM
1368 " use -enc_timebase demux\n");
1389 if (!threads_manual)
1390 ost->enc_ctx->thread_count = 0;
1393 NULL, &encoder_opts,
1402 }
else if (
ost->enc_ctx) {
1410 q.
num <= 0 || q.
den <= 0) {
1423 av_log(
ost,
AV_LOG_WARNING,
"Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1431 if (bsfs && *bsfs) {
1441 uint32_t
tag = strtol(codec_tag, &next, 0);
1443 uint8_t buf[4] = { 0 };
1444 memcpy(buf, codec_tag,
FFMIN(
sizeof(buf), strlen(codec_tag)));
1448 ost->par_in->codec_tag =
tag;
1450 ost->enc_ctx->codec_tag =
tag;
1454 if (
ost->enc_ctx && qscale >= 0) {
1460 int max_muxing_queue_size = 128;
1461 int muxing_queue_data_threshold = 50 * 1024 * 1024;
1464 &max_muxing_queue_size);
1466 oc, st, &muxing_queue_data_threshold);
1469 max_muxing_queue_size, muxing_queue_data_threshold);
1473 &
ost->bits_per_raw_sample);
1476 oc, st, &
ost->fix_sub_duration_heartbeat);
1500 keep_pix_fmt, autoscale, threads_manual);
1503 }
else if (
ost->ist) {
1505 if (sched_idx < 0) {
1507 "Error binding an input stream\n");
1531 if (
ost->ist && !
ost->enc) {
1569 int file_best_score = 0;
1584 if (score > file_best_score) {
1587 file_best_score = score;
1588 file_best_ist = ist;
1591 if (file_best_ist) {
1592 if((qcr ==
MKTAG(
'A',
'P',
'I',
'C')) ||
1595 if (file_best_score > best_score) {
1596 best_score = file_best_score;
1597 best_ist = file_best_ist;
1620 int file_best_score = 0;
1632 if (score > file_best_score) {
1633 file_best_score = score;
1634 file_best_ist = ist;
1637 if (file_best_ist) {
1639 if (file_best_score > best_score) {
1640 best_score = file_best_score;
1641 best_ist = file_best_ist;
1668 int input_props = 0, output_props = 0;
1673 if (input_descriptor)
1675 if (output_descriptor)
1678 input_props & output_props ||
1680 input_descriptor && output_descriptor &&
1681 (!input_descriptor->
props ||
1682 !output_descriptor->
props)) {
1703 ist->st->codecpar->codec_id ==
codec_id) {
1721 if (
map->linklabel) {
1730 if (linklabel && !strcmp(linklabel,
map->linklabel)) {
1739 "in any defined filter graph, or was already used elsewhere.\n",
map->linklabel);
1744 "mapped complex filtergraph %d, output [%s]\n", fg->
index,
map->linklabel);
1753 map->file_index,
map->stream_index);
1768 "Cannot map stream #%d:%d - unsupported type.\n",
1769 map->file_index,
map->stream_index);
1772 "If you want unsupported types ignored instead "
1773 "of failing, please use the -ignore_unknown option\n"
1774 "If you want them copied, please use -copy_unknown\n");
1795 uint8_t *attachment;
1796 char *attachment_filename;
1828 else if (err !=
len) {
1845 if (!attachment_filename) {
1857 ost->attachment_filename = attachment_filename;
1858 ost->par_in->extradata = attachment;
1859 ost->par_in->extradata_size =
len;
1896 auto_disable |= 1 << ofilter->
type;
1899 "output of complex filtergraph %d.", fg->
index);
1916 if (!map_func[
i] || auto_disable & (1 <<
i))
1918 ret = map_func[
i](mux, o);
1940 if (!
src->ost.fix_sub_duration_heartbeat)
1943 for (
unsigned j = 0; j < oc->
nb_streams; j++) {
1947 !
dst->ost.enc || !
dst->ost.ist || !
dst->ost.ist->fix_sub_duration)
1993 int64_t buf_size_us,
int shortest)
1996 int nb_av_enc = 0, nb_audio_fs = 0, nb_interleaved = 0;
1997 int limit_frames = 0, limit_frames_av_enc = 0;
1999 #define IS_AV_ENC(ost, type) \
2000 (ost->enc_ctx && (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO))
2001 #define IS_INTERLEAVED(type) (type != AVMEDIA_TYPE_ATTACHMENT)
2010 nb_interleaved += IS_INTERLEAVED(
type);
2011 nb_av_enc += IS_AV_ENC(
ost,
type);
2019 if (!((nb_interleaved > 1 && shortest) ||
2020 (nb_interleaved > 0 && limit_frames) ||
2035 if ((shortest && nb_av_enc > 1) || limit_frames_av_enc || nb_audio_fs) {
2060 if (nb_interleaved > nb_av_enc) {
2074 if (!IS_INTERLEAVED(
type))
2088 #undef IS_INTERLEAVED
2113 int demixing = 0, recon_gain = 0;
2117 ptr += strspn(ptr,
" \n\t\r");
2122 else if (
av_strstart(token,
"recon_gain=", &token))
2140 }
else if (demixing || recon_gain) {
2175 char *submix_str =
NULL;
2182 const char *subtoken;
2183 char *subptr =
NULL;
2186 ptr += strspn(ptr,
" \n\t\r");
2188 av_log(mux,
AV_LOG_ERROR,
"No submix in mix presentation specification \"%s\"\n", token);
2210 subtoken =
av_strtok(submix_str,
"|", &subptr);
2213 int element = 0,
layout = 0;
2216 subptr += strspn(subptr,
" \n\t\r");
2219 else if (
av_strstart(subtoken,
"layout=", &subtoken))
2231 char *endptr =
NULL;
2235 idx = strtoll(e->
value, &endptr, 0);
2239 "submix element specification \"%s\"\n", subtoken);
2244 if (!submix_element) {
2260 if (!submix_layout) {
2285 av_log(mux,
AV_LOG_ERROR,
"No audio elements in submix specification \"%s\"\n", token);
2317 #define SERIALIZE(parent, child) do { \
2318 ret = of_serialize_options(mux, parent->child, bp); \
2323 #define SERIALIZE_LOOP_SUBBLOCK(obj) do { \
2324 for (int k = 0; k < obj->nb_subblocks; k++) { \
2325 ret = of_serialize_options(mux, \
2326 av_iamf_param_definition_get_subblock(obj, k), bp); \
2332 #define SERIALIZE_LOOP(parent, child, suffix, separator) do { \
2333 for (int j = 0; j < parent->nb_## child ## suffix; j++) { \
2334 av_bprintf(bp, separator#child "="); \
2335 SERIALIZE(parent, child ## suffix[j]); \
2353 int ret, file_idx, stream_idx;
2356 file_idx = strtol(
map, &ptr, 0);
2362 stream_idx = strtol(*ptr ==
'=' ? ptr + 1 : ptr, &ptr, 0);
2386 SERIALIZE(audio_element, demixing_info);
2389 SERIALIZE_LOOP_SUBBLOCK(demixing_info);
2394 SERIALIZE(audio_element, recon_gain_info);
2397 SERIALIZE_LOOP_SUBBLOCK(recon_gain_info);
2399 SERIALIZE_LOOP(audio_element, layer,
s,
",");
2405 for (
int i = 0;
i <
mix->nb_submixes;
i++) {
2410 SERIALIZE(
mix, submixes[
i]);
2413 SERIALIZE_LOOP_SUBBLOCK(output_mix_config);
2429 SERIALIZE_LOOP_SUBBLOCK(element_mix_config);
2434 SERIALIZE_LOOP(submix,
layout,
s,
"|");
2451 char *mapped_string =
NULL;
2468 const AVClass *pclass = &
class;
2497 ptr = mapped_string;
2526 if (*endptr || idx < 0 || idx >= oc->
nb_streams) {
2571 if (!strcmp(e->
key,
"st") || !strcmp(e->
key,
"stg"))
2593 char *str, *ptr =
NULL;
2603 ptr += strspn(ptr,
" \n\t\r");
2623 int ret, progid =
i + 1;
2660 if (!strcmp(e->
key,
"st"))
2685 char *
type,
int *
index,
const char **stream_spec)
2693 if (*(++
arg) && *
arg !=
':') {
2697 *stream_spec = *
arg ==
':' ?
arg + 1 :
"";
2701 if (*(++
arg) ==
':')
2720 const char *stream_spec;
2783 for (
int i = 0;
i <
is->nb_chapters;
i++) {
2792 if (in_ch->
end < ts_off)
2794 if (rt != INT64_MAX && in_ch->
start > rt + ts_off)
2801 out_ch->id = in_ch->
id;
2803 out_ch->start =
FFMAX(0, in_ch->
start - ts_off);
2804 out_ch->end =
FFMIN(rt, in_ch->
end - ts_off);
2815 const char *outspec,
const char *inspec,
2816 int *metadata_global_manual,
int *metadata_streams_manual,
2817 int *metadata_chapters_manual)
2823 char type_in, type_out;
2824 const char *istream_spec =
NULL, *ostream_spec =
NULL;
2825 int idx_in = 0, idx_out = 0;
2833 if (type_in ==
'g' || type_out ==
'g' || (!*outspec && !ic))
2834 *metadata_global_manual = 1;
2835 if (type_in ==
's' || type_out ==
's' || (!*outspec && !ic))
2836 *metadata_streams_manual = 1;
2837 if (type_in ==
'c' || type_out ==
'c' || (!*outspec && !ic))
2838 *metadata_chapters_manual = 1;
2844 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2845 if ((index) < 0 || (index) >= (nb_elems)) {\
2846 av_log(mux, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
2848 return AVERROR(EINVAL);\
2851 #define SET_DICT(type, meta, context, index)\
2854 meta = &context->metadata;\
2857 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
2858 meta = &context->chapters[index]->metadata;\
2861 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
2862 meta = &context->programs[index]->metadata;\
2866 default: av_assert0(0);\
2869 SET_DICT(type_in, meta_in, ic, idx_in);
2870 SET_DICT(type_out, meta_out, oc, idx_out);
2873 if (type_in ==
's') {
2882 av_log(mux,
AV_LOG_FATAL,
"Stream specifier %s does not match any streams.\n", istream_spec);
2887 if (type_out ==
's') {
2906 int metadata_global_manual = 0;
2907 int metadata_streams_manual = 0;
2908 int metadata_chapters_manual = 0;
2918 "processing metadata maps\n", in_file_index);
2924 &metadata_global_manual, &metadata_streams_manual,
2925 &metadata_chapters_manual);
2932 if (chapters_input_file == INT_MAX) {
2934 chapters_input_file = -1;
2937 chapters_input_file =
i;
2942 chapters_input_file);
2946 if (chapters_input_file >= 0)
2948 !metadata_chapters_manual);
2961 if (!metadata_streams_manual)
2984 int have_manual = 0;
2987 const char **dispositions;
3001 have_manual |= !!dispositions[
i];
3007 have_default[
ost->type + 1] = 1;
3015 const char *disp = dispositions[
i];
3037 have_default[
type + 1] = 1;
3062 const Muxer *mux,
const char *spec)
3068 for (p = spec; *p; p++)
3077 for (
i = 0;
i < n;
i++) {
3078 char *next = strchr(p,
',');
3083 if (strstr(p,
"chapters") == p) {
3088 if (nb_ch > INT_MAX -
size) {
3101 "Invalid chapter time offset: %s\n", p + 8);
3107 for (j = 0; j < nb_ch; j++) {
3143 const char *forced_keyframes =
NULL;
3146 mux->
fc,
ost->st, &forced_keyframes);
3149 ost->enc_ctx && forced_keyframes))
3152 if (!strncmp(forced_keyframes,
"expr:", 5)) {
3157 "Invalid force_key_frames expression '%s'\n", forced_keyframes + 5);
3160 ost->kf.expr_const_values[
FKF_N] = 0;
3167 }
else if (!strcmp(forced_keyframes,
"source")) {
3169 #if FFMPEG_OPT_FORCE_KF_SOURCE_NO_DROP
3170 }
else if (!strcmp(forced_keyframes,
"source_no_drop")) {
3172 "-force_key_frames is deprecated, use just 'source'\n");
3187 const Muxer *mux = obj;
3230 if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
3231 stop_time = INT64_MAX;
3235 if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
3251 if (!strcmp(filename,
"-"))
3266 if (recording_time != INT64_MAX)
3300 "Output filename '%s' does not contain a numeric pattern like "
3301 "'%%d', which is required by output format '%s'.\n",
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
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 map_manual(Muxer *mux, const OptionsContext *o, const StreamMap *map)
AVIAMFSubmixElement ** elements
Array of submix elements.
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.
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
#define AV_BPRINT_SIZE_UNLIMITED
AVPixelFormat
Pixel format.
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
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)
int64_t id
Group type-specific group ID.
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
SpecifierOptList force_fps
SpecifierOptList forced_key_frames
static int mix(int c0, int c1)
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
static int of_serialize_options(Muxer *mux, void *obj, AVBPrint *bp)
enum AVMediaType codec_type
General type of the encoded data.
enum AVColorSpace colorspace
YUV colorspace type.
int check_avoptions(AVDictionary *m)
static const ElemCat * elements[ELEMENT_COUNT]
int sample_rate
samples per second
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.
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
int enc_open(void *opaque, const AVFrame *frame)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
AVIAMFParamDefinition * av_iamf_param_definition_alloc(enum AVIAMFParamDefinitionType type, unsigned int nb_subblocks, size_t *out_size)
Allocates memory for AVIAMFParamDefinition, plus an array of.
union AVStreamGroup::@358 params
Group type-specific parameters.
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.
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
@ AV_CODEC_CONFIG_SAMPLE_RATE
int, terminated by 0
static int of_parse_iamf_audio_element_layers(Muxer *mux, AVStreamGroup *stg, char *ptr)
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
#define SCH_DSTREAM(file, stream)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define FFMPEG_OPT_ENC_TIME_BASE_NUM
SpecifierOptList bits_per_raw_sample
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
SpecifierOptList audio_ch_layouts
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)
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.
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
static const char * subtitle_codec_name
@ AV_CODEC_CONFIG_COLOR_RANGE
AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.
SpecifierOptList passlogfiles
static enum AVPixelFormat choose_pixel_fmt(const AVCodecContext *avctx, enum AVPixelFormat target)
AVRational avg_frame_rate
Average framerate.
#define AV_LOG_VERBOSE
Detailed information.
static void freeenv_utf8(char *var)
static int ost_add(Muxer *mux, const OptionsContext *o, enum AVMediaType type, InputStream *ist, OutputFilter *ofilter, OutputStream **post)
Parameters as defined in section 3.6.1 of IAMF.
static int64_t get_stream_group_index_from_id(Muxer *mux, int64_t id)
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
enum AVChannelOrder order
Channel order used in this layout.
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
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)
SpecifierOptList frame_pix_fmts
static int set_dispositions(Muxer *mux, const OptionsContext *o)
int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer, const char key_val_sep, const char pairs_sep)
Serialize object's options.
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.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
static int map_auto_subtitle(Muxer *mux, const OptionsContext *o)
SpecifierOptList max_frame_rates
#define AV_OPT_SERIALIZE_SEARCH_CHILDREN
Serialize options in possible children of the given object.
AVIAMFSubmix * av_iamf_mix_presentation_add_submix(AVIAMFMixPresentation *mix_presentation)
Allocate a submix and add it to a given AVIAMFMixPresentation.
const struct AVCodec * codec
static int of_parse_group_token(Muxer *mux, const char *token, char *ptr)
AVChannelLayout ch_layout
Audio channel layout.
static Muxer * mux_alloc(void)
void opt_match_per_stream_int(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, int *out)
SpecifierOptList enc_stats_pre_fmt
SpecifierOptList mux_stats_fmt
Submix layout as defined in section 3.7.6 of IAMF.
int sch_add_mux_stream(Scheduler *sch, unsigned mux_idx)
Add a muxed stream for a previously added muxer.
static int copy_meta(Muxer *mux, const OptionsContext *o)
#define AV_BPRINT_SIZE_AUTOMATIC
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
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.
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS
Serialize options that are not set to default values only.
static EncStatsFile * enc_stats_files
static int new_stream_video(Muxer *mux, const OptionsContext *o, OutputStream *ost, int *keep_pix_fmt, enum VideoSyncMethod *vsync_method)
#define FFDIFFSIGN(x, y)
Comparator.
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
void opt_match_per_stream_int64(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, int64_t *out)
#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,...
SpecifierOptList metadata
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
int init_simple_filtergraph(InputStream *ist, OutputStream *ost, char *graph_desc, Scheduler *sch, unsigned sch_idx_enc, const OutputFilterOptions *opts)
AVIAMFSubmixLayout * av_iamf_submix_add_layout(AVIAMFSubmix *submix)
Allocate a submix layout and add it to a given AVIAMFSubmix.
static const AVClass output_stream_class
EncStatsComponent * components
static int of_parse_iamf_submixes(Muxer *mux, AVStreamGroup *stg, char *ptr)
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
This struct describes the properties of a single codec described by an AVCodecID.
static MuxStream * mux_stream_alloc(Muxer *mux, enum AVMediaType type)
@ AV_CODEC_CONFIG_SAMPLE_FORMAT
AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE.
int sch_add_mux(Scheduler *sch, SchThreadFunc func, int(*init)(void *), void *arg, int sdp_auto, unsigned thread_queue_size)
Add a muxer to the scheduler.
SpecifierOptList intra_matrices
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
SpecifierOptList stream_groups
static int enc_stats_get_file(AVIOContext **io, const char *path)
static int of_add_groups(Muxer *mux, const OptionsContext *o)
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 av_always_inline void * av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx)
Get the subblock at the specified.
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
SpecifierOptList autoscale
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
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
SpecifierOptList sample_fmts
unsigned int index
Group index in AVFormatContext.
int ignore_unknown_streams
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int encoder_thread(void *arg)
int nb_coded_side_data
Amount of entries in coded_side_data.
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
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.
@ 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)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
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.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
@ AV_CODEC_CONFIG_FRAME_RATE
AVRational, terminated by {0, 0}.
SpecifierOptList audio_channels
static int map_auto_video(Muxer *mux, const OptionsContext *o)
static int nb_enc_stats_files
int sch_add_enc(Scheduler *sch, SchThreadFunc func, void *ctx, int(*open_cb)(void *opaque, const AVFrame *frame))
SpecifierOptList fix_sub_duration_heartbeat
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).
@ OFILTER_FLAG_AUDIO_24BIT
SpecifierOptList copy_prior_start
enum AVPacketSideDataType type
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst, AVDictionary **opts_used)
Filter out options for given codec.
const char * av_default_item_name(void *ptr)
Return the context name.
static int streamcopy_init(const Muxer *mux, OutputStream *ost, AVDictionary **encoder_opts)
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...
A layer defining a Channel Layout in the Audio Element.
static char * getenv_utf8(const char *varname)
SpecifierOptList frame_aspect_ratios
#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.
SpecifierOptList max_frames
AVChannelLayout ch_layout
Audio only.
#define FFMPEG_OPT_FILTER_SCRIPT
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)
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
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)
AVCodecID
Identify the syntax and semantics of the bitstream.
unsigned int audio_element_id
The id of the Audio Element this submix element references.
int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
Add an already allocated stream to a stream group.
Submix layout as defined in section 3.7 of IAMF.
char * file_read(const char *filename)
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static int of_add_programs(Muxer *mux, const OptionsContext *o)
int avcodec_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out, int *out_num)
Retrieve a list of all supported values for a given configuration type.
@ AV_CODEC_CONFIG_CHANNEL_LAYOUT
AVChannelLayout, terminated by {0}.
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
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.
SpecifierOptList enc_stats_post_fmt
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
SpecifierOptList enc_stats_pre
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
OutputFile ** output_files
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
static int64_t start_time
char * url
input or output URL.
enum AVSampleFormat sample_fmt
audio sample format
#define AV_NOPTS_VALUE
Undefined timestamp value.
struct AVIAMFAudioElement * iamf_audio_element
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
static int setup_sync_queues(Muxer *mux, AVFormatContext *oc, int64_t buf_size_us, int shortest)
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)
SpecifierOptList disposition
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_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
AVIAMFSubmixElement * av_iamf_submix_add_element(AVIAMFSubmix *submix)
Allocate a submix element and add it to a given AVIAMFSubmix.
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
void opt_match_per_stream_dbl(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, double *out)
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.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
AVStream ** streams
A list of streams in the group.
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.
struct AVIAMFMixPresentation * iamf_mix_presentation
SpecifierOptList chroma_intra_matrices
int mux_check_init(void *arg)
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 of_open(const OptionsContext *o, const char *filename, Scheduler *sch)
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)
SpecifierOptList frame_rates
int64_t id
unique ID to identify the chapter
SpecifierOptList codec_names
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost, unsigned sched_idx_enc, const OutputFilterOptions *opts)
static enum AVPixelFormat pix_fmt_parse(OutputStream *ost, const char *name)
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.
SpecifierOptList fps_mode
int block_align
Audio only.
float shortest_buf_duration
#define av_malloc_array(a, b)
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
SpecifierOptList mux_stats
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
SpecifierOptList muxing_queue_data_threshold
@ 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.
SpecifierOptList enc_stats_post
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)
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
unsigned int nb_subblocks
Number of subblocks in the array.
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
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.
SpecifierOptList metadata_map
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...
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 av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
int check_avoptions_used(const AVDictionary *opts, const AVDictionary *opts_used, void *logctx, int decode)
#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.
#define SCH_MSTREAM(file, stream)
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.
SpecifierOptList max_muxing_queue_size
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.
SpecifierOptList inter_matrices
int index
stream index in AVFormatContext
@ AV_CLASS_CATEGORY_MUXER
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.
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
SpecifierOptList audio_sample_rate
int ist_output_add(InputStream *ist, OutputStream *ost)
@ AV_OPT_TYPE_INT
Underlying C type is int.
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.
SpecifierOptList frame_sizes
AVRational r_frame_rate
Real base framerate of the stream.
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
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)
AVIAMFLayer * av_iamf_audio_element_add_layer(AVIAMFAudioElement *audio_element)
Allocate a layer and add it to a given AVIAMFAudioElement.
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.
SpecifierOptList codec_tags
unsigned int nb_elements
Number of elements in the submix.
SpecifierOptList filter_scripts
#define AVIO_FLAG_READ
read-only
char * av_strdup(const char *s)
Duplicate a string.
SpecifierOptList time_bases
#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)
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
int sch_sq_add_enc(Scheduler *sch, unsigned sq_idx, unsigned enc_idx, int limiting, uint64_t max_frames)
AVIAMFParamDefinition * output_mix_config
Information required for post-processing the mixed audio signal to generate the audio signal for play...
enum AVStreamGroupParamsType type
Group type.
int avio_open2(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
SpecifierOptList rc_overrides
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
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...
int sch_mux_sub_heartbeat_add(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, unsigned dec_idx)
const VDPAUPixFmtMap * map
AVStreamGroup * avformat_stream_group_create(AVFormatContext *s, enum AVStreamGroupParamsType type, AVDictionary **options)
Add a new empty stream group to a media file.
static int of_map_group(Muxer *mux, AVDictionary **dict, AVBPrint *bp, const char *map)
unsigned int nb_stream_groups
Number of elements in AVFormatContext.stream_groups.
static int compare_int64(const void *a, const void *b)
SpecifierOptList copy_initial_nonkeyframes
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).
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_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
@ OFILTER_FLAG_DISABLE_CONVERT
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,...
AVDictionary * enc_opts_used
int rc_override_count
ratecontrol override, see RcOverride
AVIAMFParamDefinition * element_mix_config
Information required required for applying any processing to the referenced and rendered Audio Elemen...
int width
picture width / height.
int muxer_thread(void *arg)
int enc_alloc(Encoder **penc, const AVCodec *codec, Scheduler *sch, unsigned sch_idx)
Submix element as defined in section 3.7 of IAMF.
static int check_opt_bitexact(void *ctx, const AVDictionary *opts, const char *opt_name, int flag)
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
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)
AVIAMFParamDefinition * recon_gain_info
Recon gain information used to reconstruct a scalable channel audio representation.
SyncQueue * sq_alloc(enum SyncQueueType type, int64_t buf_size_us, void *logctx)
Allocate a sync queue of the given type.
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
const char * opt_match_per_type_str(const SpecifierOptList *sol, char mediatype)
void opt_match_per_stream_str(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, const char **out)
void sch_mux_stream_buffering(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, size_t data_threshold, int max_packets)
Configure limits on packet buffering performed before the muxer task is started.
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)
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.