FFmpeg
ffmpeg_mux_init.c
Go to the documentation of this file.
1 /*
2  * Muxer/output file setup.
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <string.h>
22 
23 #include "cmdutils.h"
24 #include "ffmpeg.h"
25 #include "ffmpeg_mux.h"
26 #include "ffmpeg_sched.h"
27 #include "fopen_utf8.h"
28 
29 #include "libavformat/avformat.h"
30 #include "libavformat/avio.h"
31 
32 #include "libavcodec/avcodec.h"
33 
34 #include "libavfilter/avfilter.h"
35 
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/avutil.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/dict.h"
41 #include "libavutil/display.h"
42 #include "libavutil/getenv_utf8.h"
43 #include "libavutil/iamf.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/log.h"
46 #include "libavutil/mem.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/pixdesc.h"
50 
51 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
52 
53 static int check_opt_bitexact(void *ctx, const AVDictionary *opts,
54  const char *opt_name, int flag)
55 {
56  const AVDictionaryEntry *e = av_dict_get(opts, opt_name, NULL, 0);
57 
58  if (e) {
59  const AVOption *o = av_opt_find(ctx, opt_name, NULL, 0, 0);
60  int val = 0;
61  if (!o)
62  return 0;
63  av_opt_eval_flags(ctx, o, e->value, &val);
64  return !!(val & flag);
65  }
66  return 0;
67 }
68 
69 static int choose_encoder(const OptionsContext *o, AVFormatContext *s,
70  MuxStream *ms, const AVCodec **enc)
71 {
72  OutputStream *ost = &ms->ost;
73  enum AVMediaType type = ost->type;
74  const char *codec_name = NULL;
75 
76  *enc = NULL;
77 
78  opt_match_per_stream_str(ost, &o->codec_names, s, ost->st, &codec_name);
79 
80  if (type != AVMEDIA_TYPE_VIDEO &&
81  type != AVMEDIA_TYPE_AUDIO &&
82  type != AVMEDIA_TYPE_SUBTITLE) {
83  if (codec_name && strcmp(codec_name, "copy")) {
84  const char *type_str = av_get_media_type_string(type);
85  av_log(ost, AV_LOG_FATAL,
86  "Encoder '%s' specified, but only '-codec copy' supported "
87  "for %s streams\n", codec_name, type_str);
88  return AVERROR(ENOSYS);
89  }
90  return 0;
91  }
92 
93  if (!codec_name) {
94  ms->par_in->codec_id = av_guess_codec(s->oformat, NULL, s->url, NULL, ost->type);
95  *enc = avcodec_find_encoder(ms->par_in->codec_id);
96  if (!*enc) {
97  av_log(ost, AV_LOG_FATAL, "Automatic encoder selection failed "
98  "Default encoder for format %s (codec %s) is "
99  "probably disabled. Please choose an encoder manually.\n",
100  s->oformat->name, avcodec_get_name(ms->par_in->codec_id));
101  return AVERROR_ENCODER_NOT_FOUND;
102  }
103  } else if (strcmp(codec_name, "copy")) {
104  int ret = find_codec(ost, codec_name, ost->type, 1, enc);
105  if (ret < 0)
106  return ret;
107  ms->par_in->codec_id = (*enc)->id;
108  }
109 
110  return 0;
111 }
112 
113 static char *get_line(AVIOContext *s, AVBPrint *bprint)
114 {
115  char c;
116 
117  while ((c = avio_r8(s)) && c != '\n')
118  av_bprint_chars(bprint, c, 1);
119 
120  if (!av_bprint_is_complete(bprint))
121  return NULL;
122 
123  return bprint->str;
124 }
125 
126 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
127 {
128  int i, ret = -1;
129  char filename[1000];
130  char *env_avconv_datadir = getenv_utf8("AVCONV_DATADIR");
131  char *env_home = getenv_utf8("HOME");
132  const char *base[3] = { env_avconv_datadir,
133  env_home,
134  AVCONV_DATADIR,
135  };
136 
137  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
138  if (!base[i])
139  continue;
140  if (codec_name) {
141  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
142  i != 1 ? "" : "/.avconv", codec_name, preset_name);
143  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
144  }
145  if (ret < 0) {
146  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
147  i != 1 ? "" : "/.avconv", preset_name);
148  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
149  }
150  }
151  freeenv_utf8(env_home);
152  freeenv_utf8(env_avconv_datadir);
153  return ret;
154 }
155 
156 typedef struct EncStatsFile {
157  char *path;
158  AVIOContext *io;
159 } EncStatsFile;
160 
161 static EncStatsFile *enc_stats_files;
162 static int nb_enc_stats_files;
163 
164 static int enc_stats_get_file(AVIOContext **io, const char *path)
165 {
166  EncStatsFile *esf;
167  int ret;
168 
169  for (int i = 0; i < nb_enc_stats_files; i++)
170  if (!strcmp(path, enc_stats_files[i].path)) {
171  *io = enc_stats_files[i].io;
172  return 0;
173  }
174 
175  ret = GROW_ARRAY(enc_stats_files, nb_enc_stats_files);
176  if (ret < 0)
177  return ret;
178 
179  esf = &enc_stats_files[nb_enc_stats_files - 1];
180 
181  ret = avio_open2(&esf->io, path, AVIO_FLAG_WRITE, &int_cb, NULL);
182  if (ret < 0) {
183  av_log(NULL, AV_LOG_ERROR, "Error opening stats file '%s': %s\n",
184  path, av_err2str(ret));
185  return ret;
186  }
187 
188  esf->path = av_strdup(path);
189  if (!esf->path)
190  return AVERROR(ENOMEM);
191 
192  *io = esf->io;
193 
194  return 0;
195 }
196 
197 void of_enc_stats_close(void)
198 {
199  for (int i = 0; i < nb_enc_stats_files; i++) {
200  av_freep(&enc_stats_files[i].path);
201  avio_closep(&enc_stats_files[i].io);
202  }
203  av_freep(&enc_stats_files);
204  nb_enc_stats_files = 0;
205 }
206 
207 static int unescape(char **pdst, size_t *dst_len,
208  const char **pstr, char delim)
209 {
210  const char *str = *pstr;
211  char *dst;
212  size_t len, idx;
213 
214  *pdst = NULL;
215 
216  len = strlen(str);
217  if (!len)
218  return 0;
219 
220  dst = av_malloc(len + 1);
221  if (!dst)
222  return AVERROR(ENOMEM);
223 
224  for (idx = 0; *str; idx++, str++) {
225  if (str[0] == '\\' && str[1])
226  str++;
227  else if (*str == delim)
228  break;
229 
230  dst[idx] = *str;
231  }
232  if (!idx) {
233  av_freep(&dst);
234  return 0;
235  }
236 
237  dst[idx] = 0;
238 
239  *pdst = dst;
240  *dst_len = idx;
241  *pstr = str;
242 
243  return 0;
244 }
245 
246 static int enc_stats_init(OutputStream *ost, EncStats *es, int pre,
247  const char *path, const char *fmt_spec)
248 {
249  static const struct {
250  enum EncStatsType type;
251  const char *str;
252  unsigned pre_only:1;
253  unsigned post_only:1;
254  unsigned need_input_data:1;
255  } fmt_specs[] = {
256  { ENC_STATS_FILE_IDX, "fidx" },
257  { ENC_STATS_STREAM_IDX, "sidx" },
258  { ENC_STATS_FRAME_NUM, "n" },
259  { ENC_STATS_FRAME_NUM_IN, "ni", 0, 0, 1 },
260  { ENC_STATS_TIMEBASE, "tb" },
261  { ENC_STATS_TIMEBASE_IN, "tbi", 0, 0, 1 },
262  { ENC_STATS_PTS, "pts" },
263  { ENC_STATS_PTS_TIME, "t" },
264  { ENC_STATS_PTS_IN, "ptsi", 0, 0, 1 },
265  { ENC_STATS_PTS_TIME_IN, "ti", 0, 0, 1 },
266  { ENC_STATS_DTS, "dts", 0, 1 },
267  { ENC_STATS_DTS_TIME, "dt", 0, 1 },
268  { ENC_STATS_SAMPLE_NUM, "sn", 1 },
269  { ENC_STATS_NB_SAMPLES, "samp", 1 },
270  { ENC_STATS_PKT_SIZE, "size", 0, 1 },
271  { ENC_STATS_BITRATE, "br", 0, 1 },
272  { ENC_STATS_AVG_BITRATE, "abr", 0, 1 },
273  { ENC_STATS_KEYFRAME, "key", 0, 1 },
274  };
275  const char *next = fmt_spec;
276 
277  int ret;
278 
279  while (*next) {
280  EncStatsComponent *c;
281  char *val;
282  size_t val_len;
283 
284  // get the sequence up until next opening brace
285  ret = unescape(&val, &val_len, &next, '{');
286  if (ret < 0)
287  return ret;
288 
289  if (val) {
290  ret = GROW_ARRAY(es->components, es->nb_components);
291  if (ret < 0) {
292  av_freep(&val);
293  return ret;
294  }
295 
296  c = &es->components[es->nb_components - 1];
297  c->type = ENC_STATS_LITERAL;
298  c->str = val;
299  c->str_len = val_len;
300  }
301 
302  if (!*next)
303  break;
304  next++;
305 
306  // get the part inside braces
307  ret = unescape(&val, &val_len, &next, '}');
308  if (ret < 0)
309  return ret;
310 
311  if (!val) {
312  av_log(NULL, AV_LOG_ERROR,
313  "Empty formatting directive in: %s\n", fmt_spec);
314  return AVERROR(EINVAL);
315  }
316 
317  if (!*next) {
318  av_log(NULL, AV_LOG_ERROR,
319  "Missing closing brace in: %s\n", fmt_spec);
320  ret = AVERROR(EINVAL);
321  goto fail;
322  }
323  next++;
324 
325  ret = GROW_ARRAY(es->components, es->nb_components);
326  if (ret < 0)
327  goto fail;
328 
329  c = &es->components[es->nb_components - 1];
330 
331  for (size_t i = 0; i < FF_ARRAY_ELEMS(fmt_specs); i++) {
332  if (!strcmp(val, fmt_specs[i].str)) {
333  if ((pre && fmt_specs[i].post_only) || (!pre && fmt_specs[i].pre_only)) {
334  av_log(NULL, AV_LOG_ERROR,
335  "Format directive '%s' may only be used %s-encoding\n",
336  val, pre ? "post" : "pre");
337  ret = AVERROR(EINVAL);
338  goto fail;
339  }
340 
341  c->type = fmt_specs[i].type;
342 
343  if (fmt_specs[i].need_input_data && !ost->ist) {
344  av_log(ost, AV_LOG_WARNING,
345  "Format directive '%s' is unavailable, because "
346  "this output stream has no associated input stream\n",
347  val);
348  }
349 
350  break;
351  }
352  }
353 
354  if (!c->type) {
355  av_log(NULL, AV_LOG_ERROR, "Invalid format directive: %s\n", val);
356  ret = AVERROR(EINVAL);
357  goto fail;
358  }
359 
360 fail:
361  av_freep(&val);
362  if (ret < 0)
363  return ret;
364  }
365 
366  ret = pthread_mutex_init(&es->lock, NULL);
367  if (ret)
368  return AVERROR(ret);
369  es->lock_initialized = 1;
370 
371  ret = enc_stats_get_file(&es->io, path);
372  if (ret < 0)
373  return ret;
374 
375  return 0;
376 }
377 
378 static const char *output_stream_item_name(void *obj)
379 {
380  const MuxStream *ms = obj;
381 
382  return ms->log_name;
383 }
384 
385 static const AVClass output_stream_class = {
386  .class_name = "OutputStream",
387  .version = LIBAVUTIL_VERSION_INT,
388  .item_name = output_stream_item_name,
389  .category = AV_CLASS_CATEGORY_MUXER,
390 };
391 
392 static MuxStream *mux_stream_alloc(Muxer *mux, enum AVMediaType type)
393 {
394  const char *type_str = av_get_media_type_string(type);
395  MuxStream *ms;
396 
397  ms = allocate_array_elem(&mux->of.streams, sizeof(*ms), &mux->of.nb_streams);
398  if (!ms)
399  return NULL;
400 
401  ms->ost.file = &mux->of;
402  ms->ost.index = mux->of.nb_streams - 1;
403  ms->ost.type = type;
404 
405  ms->ost.class = &output_stream_class;
406 
407  ms->sch_idx = -1;
408  ms->sch_idx_enc = -1;
409 
410  snprintf(ms->log_name, sizeof(ms->log_name), "%cost#%d:%d",
411  type_str ? *type_str : '?', mux->of.index, ms->ost.index);
412 
413  return ms;
414 }
415 
416 static int ost_get_filters(const OptionsContext *o, AVFormatContext *oc,
417  OutputStream *ost, char **dst)
418 {
419  const char *filters = NULL;
420  opt_match_per_stream_str(ost, &o->filters, oc, ost->st, &filters);
421 
422  if (!ost->ist) {
423  if (filters) {
424  av_log(ost, AV_LOG_ERROR,
425  "Filtergraph '%s' was specified for a stream fed from a complex "
426  "filtergraph. Simple and complex filtering cannot be used "
427  "together for the same stream.\n", filters);
428  return AVERROR(EINVAL);
429  }
430  return 0;
431  }
432 
433  if (filters)
434  *dst = av_strdup(filters);
435  else
436  *dst = av_strdup(ost->type == AVMEDIA_TYPE_VIDEO ? "null" : "anull");
437  return *dst ? 0 : AVERROR(ENOMEM);
438 }
439 
440 static int parse_matrix_coeffs(void *logctx, uint16_t *dest, const char *str)
441 {
442  const char *p = str;
443  for (int i = 0;; i++) {
444  dest[i] = atoi(p);
445  if (i == 63)
446  break;
447  p = strchr(p, ',');
448  if (!p) {
449  av_log(logctx, AV_LOG_FATAL,
450  "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
451  return AVERROR(EINVAL);
452  }
453  p++;
454  }
455 
456  return 0;
457 }
458 
459 static int pixfmt_in_list(const enum AVPixelFormat *formats, enum AVPixelFormat format)
460 {
461  for (; *formats != AV_PIX_FMT_NONE; formats++)
462  if (*formats == format)
463  return 1;
464  return 0;
465 }
466 
467 static enum AVPixelFormat
468 choose_pixel_fmt(const AVCodecContext *avctx, enum AVPixelFormat target)
469 {
470  const enum AVPixelFormat *p;
471  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(target);
472  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
473  int has_alpha = desc ? desc->nb_components % 2 == 0 : 0;
474  enum AVPixelFormat best= AV_PIX_FMT_NONE;
475  int ret;
476 
477  ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_PIX_FORMAT,
478  0, (const void **) &p, NULL);
479  if (ret < 0)
480  return AV_PIX_FMT_NONE;
481 
482  for (; *p != AV_PIX_FMT_NONE; p++) {
483  best = av_find_best_pix_fmt_of_2(best, *p, target, has_alpha, NULL);
484  if (*p == target)
485  break;
486  }
487  if (*p == AV_PIX_FMT_NONE) {
488  if (target != AV_PIX_FMT_NONE)
489  av_log(NULL, AV_LOG_WARNING,
490  "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
491  av_get_pix_fmt_name(target),
492  avctx->codec->name,
493  av_get_pix_fmt_name(best));
494  return best;
495  }
496  return target;
497 }
498 
499 static enum AVPixelFormat pix_fmt_parse(OutputStream *ost, const char *name)
500 {
501  const enum AVPixelFormat *fmts;
502  enum AVPixelFormat fmt;
503  int ret;
504 
505  fmt = av_get_pix_fmt(name);
506  if (fmt == AV_PIX_FMT_NONE) {
507  av_log(ost, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", name);
508  return AV_PIX_FMT_NONE;
509  }
510 
511  ret = avcodec_get_supported_config(ost->enc->enc_ctx, NULL, AV_CODEC_CONFIG_PIX_FORMAT,
512  0, (const void **) &fmts, NULL);
513  if (ret < 0)
514  return AV_PIX_FMT_NONE;
515 
516  /* when the user specified-format is an alias for an endianness-specific
517  * one (e.g. rgb48 -> rgb48be/le), it gets translated into the native
518  * endianness by av_get_pix_fmt();
519  * the following code handles the case when the native endianness is not
520  * supported by the encoder, but the other one is */
521  if (fmts && !pixfmt_in_list(fmts, fmt)) {
522  const char *name_canonical = av_get_pix_fmt_name(fmt);
523  int len = strlen(name_canonical);
524 
525  if (strcmp(name, name_canonical) &&
526  (!strcmp(name_canonical + len - 2, "le") ||
527  !strcmp(name_canonical + len - 2, "be"))) {
528  char name_other[64];
529  enum AVPixelFormat fmt_other;
530 
531  snprintf(name_other, sizeof(name_other), "%s%ce",
532  name, name_canonical[len - 2] == 'l' ? 'b' : 'l');
533  fmt_other = av_get_pix_fmt(name_other);
534  if (fmt_other != AV_PIX_FMT_NONE && pixfmt_in_list(fmts, fmt_other)) {
535  av_log(ost, AV_LOG_VERBOSE, "Mapping pixel format %s->%s\n",
536  name, name_other);
537  fmt = fmt_other;
538  }
539  }
540  }
541 
542  if (fmts && !pixfmt_in_list(fmts, fmt))
543  fmt = choose_pixel_fmt(ost->enc->enc_ctx, fmt);
544 
545  return fmt;
546 }
547 
548 static int new_stream_video(Muxer *mux, const OptionsContext *o,
549  OutputStream *ost, int *keep_pix_fmt,
550  enum VideoSyncMethod *vsync_method)
551 {
552  MuxStream *ms = ms_from_ost(ost);
553  AVFormatContext *oc = mux->fc;
554  AVStream *st;
555  const char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
556  int ret = 0;
557 
558  st = ost->st;
559 
560  opt_match_per_stream_str(ost, &o->frame_rates, oc, st, &frame_rate);
561  if (frame_rate && av_parse_video_rate(&ms->frame_rate, frame_rate) < 0) {
562  av_log(ost, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
563  return AVERROR(EINVAL);
564  }
565 
566  opt_match_per_stream_str(ost, &o->max_frame_rates, oc, st, &max_frame_rate);
567  if (max_frame_rate && av_parse_video_rate(&ms->max_frame_rate, max_frame_rate) < 0) {
568  av_log(ost, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
569  return AVERROR(EINVAL);
570  }
571 
572  if (frame_rate && max_frame_rate) {
573  av_log(ost, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
574  return AVERROR(EINVAL);
575  }
576 
577  opt_match_per_stream_str(ost, &o->frame_aspect_ratios, oc, st, &frame_aspect_ratio);
578  if (frame_aspect_ratio) {
579  AVRational q;
580  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
581  q.num <= 0 || q.den <= 0) {
582  av_log(ost, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
583  return AVERROR(EINVAL);
584  }
585  ost->frame_aspect_ratio = q;
586  }
587 
588  if (ost->enc) {
589  AVCodecContext *video_enc = ost->enc->enc_ctx;
590  const char *p = NULL, *fps_mode = NULL;
591  const char *frame_size = NULL;
592  const char *frame_pix_fmt = NULL;
593  const char *intra_matrix = NULL, *inter_matrix = NULL;
594  const char *chroma_intra_matrix = NULL;
595  int do_pass = 0;
596  int i;
597 
598  opt_match_per_stream_str(ost, &o->frame_sizes, oc, st, &frame_size);
599  if (frame_size) {
600  ret = av_parse_video_size(&video_enc->width, &video_enc->height, frame_size);
601  if (ret < 0) {
602  av_log(ost, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
603  return AVERROR(EINVAL);
604  }
605  }
606 
607  opt_match_per_stream_str(ost, &o->frame_pix_fmts, oc, st, &frame_pix_fmt);
608  if (frame_pix_fmt && *frame_pix_fmt == '+') {
609  *keep_pix_fmt = 1;
610  if (!*++frame_pix_fmt)
611  frame_pix_fmt = NULL;
612  }
613  if (frame_pix_fmt) {
614  video_enc->pix_fmt = pix_fmt_parse(ost, frame_pix_fmt);
615  if (video_enc->pix_fmt == AV_PIX_FMT_NONE)
616  return AVERROR(EINVAL);
617  }
618 
619  opt_match_per_stream_str(ost, &o->intra_matrices, oc, st, &intra_matrix);
620  if (intra_matrix) {
621  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64)))
622  return AVERROR(ENOMEM);
623 
624  ret = parse_matrix_coeffs(ost, video_enc->intra_matrix, intra_matrix);
625  if (ret < 0)
626  return ret;
627  }
628  opt_match_per_stream_str(ost, &o->chroma_intra_matrices, oc, st, &chroma_intra_matrix);
629  if (chroma_intra_matrix) {
630  if (!(video_enc->chroma_intra_matrix = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64)))
631  return AVERROR(ENOMEM);
632  ret = parse_matrix_coeffs(ost, video_enc->chroma_intra_matrix, chroma_intra_matrix);
633  if (ret < 0)
634  return ret;
635  }
636  opt_match_per_stream_str(ost, &o->inter_matrices, oc, st, &inter_matrix);
637  if (inter_matrix) {
638  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64)))
639  return AVERROR(ENOMEM);
640  ret = parse_matrix_coeffs(ost, video_enc->inter_matrix, inter_matrix);
641  if (ret < 0)
642  return ret;
643  }
644 
645  opt_match_per_stream_str(ost, &o->rc_overrides, oc, st, &p);
646  for (i = 0; p; i++) {
647  int start, end, q;
648  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
649  if (e != 3) {
650  av_log(ost, AV_LOG_FATAL, "error parsing rc_override\n");
651  return AVERROR(EINVAL);
652  }
653  video_enc->rc_override =
654  av_realloc_array(video_enc->rc_override,
655  i + 1, sizeof(RcOverride));
656  if (!video_enc->rc_override) {
657  av_log(ost, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
658  return AVERROR(ENOMEM);
659  }
660  video_enc->rc_override[i].start_frame = start;
661  video_enc->rc_override[i].end_frame = end;
662  if (q > 0) {
663  video_enc->rc_override[i].qscale = q;
664  video_enc->rc_override[i].quality_factor = 1.0;
665  }
666  else {
667  video_enc->rc_override[i].qscale = 0;
668  video_enc->rc_override[i].quality_factor = -q/100.0;
669  }
670  p = strchr(p, '/');
671  if (p) p++;
672  }
673  video_enc->rc_override_count = i;
674 
675  /* two pass mode */
676  opt_match_per_stream_int(ost, &o->pass, oc, st, &do_pass);
677  if (do_pass) {
678  if (do_pass & 1)
679  video_enc->flags |= AV_CODEC_FLAG_PASS1;
680  if (do_pass & 2)
681  video_enc->flags |= AV_CODEC_FLAG_PASS2;
682  }
683 
684  opt_match_per_stream_str(ost, &o->passlogfiles, oc, st, &ost->logfile_prefix);
685  if (ost->logfile_prefix &&
686  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
687  return AVERROR(ENOMEM);
688 
689  if (do_pass) {
690  int ost_idx = -1;
691  char logfilename[1024];
692  FILE *f;
693 
694  /* compute this stream's global index */
695  for (int idx = 0; idx <= ost->file->index; idx++)
696  ost_idx += output_files[idx]->nb_streams;
697 
698  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
699  ost->logfile_prefix ? ost->logfile_prefix :
700  DEFAULT_PASS_LOGFILENAME_PREFIX,
701  ost_idx);
702  if (!strcmp(video_enc->codec->name, "libx264") || !strcmp(video_enc->codec->name, "libvvenc")) {
703  if (av_opt_is_set_to_default_by_name(video_enc, "stats",
704  AV_OPT_SEARCH_CHILDREN) > 0)
705  av_opt_set(video_enc, "stats", logfilename,
706  AV_OPT_SEARCH_CHILDREN);
707  } else if (!strcmp(video_enc->codec->name, "libx265")) {
708  if (av_opt_is_set_to_default_by_name(video_enc, "x265-stats",
709  AV_OPT_SEARCH_CHILDREN) > 0)
710  av_opt_set(video_enc, "x265-stats", logfilename,
711  AV_OPT_SEARCH_CHILDREN);
712  } else {
713  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
714  char *logbuffer = read_file_to_string(logfilename);
715 
716  if (!logbuffer) {
717  av_log(ost, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
718  logfilename);
719  return AVERROR(EIO);
720  }
721  video_enc->stats_in = logbuffer;
722  }
723  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
724  f = fopen_utf8(logfilename, "wb");
725  if (!f) {
726  av_log(ost, AV_LOG_FATAL,
727  "Cannot write log file '%s' for pass-1 encoding: %s\n",
728  logfilename, strerror(errno));
729  return AVERROR(errno);
730  }
731  ost->logfile = f;
732  }
733  }
734  }
735 
736  opt_match_per_stream_int(ost, &o->force_fps, oc, st, &ms->force_fps);
737 
738  *vsync_method = VSYNC_AUTO;
739  opt_match_per_stream_str(ost, &o->fps_mode, oc, st, &fps_mode);
740  if (fps_mode) {
741  ret = parse_and_set_vsync(fps_mode, vsync_method, ost->file->index, ost->index);
742  if (ret < 0)
743  return ret;
744  }
745 
746  if ((ms->frame_rate.num || ms->max_frame_rate.num) &&
747  !(*vsync_method == VSYNC_AUTO ||
748  *vsync_method == VSYNC_CFR || *vsync_method == VSYNC_VSCFR)) {
749  av_log(ost, AV_LOG_FATAL, "One of -r/-fpsmax was specified "
750  "together a non-CFR -vsync/-fps_mode. This is contradictory.\n");
751  return AVERROR(EINVAL);
752  }
753 
754  if (*vsync_method == VSYNC_AUTO) {
755  if (ms->frame_rate.num || ms->max_frame_rate.num) {
756  *vsync_method = VSYNC_CFR;
757  } else if (!strcmp(oc->oformat->name, "avi")) {
758  *vsync_method = VSYNC_VFR;
759  } else {
760  *vsync_method = (oc->oformat->flags & AVFMT_VARIABLE_FPS) ?
761  ((oc->oformat->flags & AVFMT_NOTIMESTAMPS) ?
762  VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
763  }
764 
765  if (ost->ist && *vsync_method == VSYNC_CFR) {
766  const InputFile *ifile = ost->ist->file;
767 
768  if (ifile->nb_streams == 1 && ifile->input_ts_offset == 0)
769  *vsync_method = VSYNC_VSCFR;
770  }
771 
772  if (*vsync_method == VSYNC_CFR && copy_ts) {
773  *vsync_method = VSYNC_VSCFR;
774  }
775  }
776  }
777 
778  return 0;
779 }
780 
781 static int new_stream_audio(Muxer *mux, const OptionsContext *o,
782  OutputStream *ost)
783 {
784  MuxStream *ms = ms_from_ost(ost);
785  AVFormatContext *oc = mux->fc;
786  AVStream *st = ost->st;
787 
788  if (ost->enc) {
789  AVCodecContext *audio_enc = ost->enc->enc_ctx;
790  int channels = 0;
791  const char *layout = NULL;
792  const char *sample_fmt = NULL;
793 
794  opt_match_per_stream_int(ost, &o->audio_channels, oc, st, &channels);
795  if (channels) {
796  audio_enc->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
797  audio_enc->ch_layout.nb_channels = channels;
798  }
799 
800  opt_match_per_stream_str(ost, &o->audio_ch_layouts, oc, st, &layout);
801  if (layout && av_channel_layout_from_string(&audio_enc->ch_layout, layout) < 0) {
802  av_log(ost, AV_LOG_FATAL, "Unknown channel layout: %s\n", layout);
803  return AVERROR(EINVAL);
804  }
805 
806  opt_match_per_stream_str(ost, &o->sample_fmts, oc, st, &sample_fmt);
807  if (sample_fmt &&
808  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
809  av_log(ost, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
810  return AVERROR(EINVAL);
811  }
812 
813  opt_match_per_stream_int(ost, &o->audio_sample_rate, oc, st, &audio_enc->sample_rate);
814  opt_match_per_stream_str(ost, &o->apad, oc, st, &ms->apad);
815  }
816 
817  return 0;
818 }
819 
820 static int new_stream_subtitle(Muxer *mux, const OptionsContext *o,
821  OutputStream *ost)
822 {
823  AVStream *st;
824 
825  st = ost->st;
826 
827  if (ost->enc) {
828  AVCodecContext *subtitle_enc = ost->enc->enc_ctx;
829 
830  AVCodecDescriptor const *input_descriptor =
831  avcodec_descriptor_get(ost->ist->par->codec_id);
832  AVCodecDescriptor const *output_descriptor =
833  avcodec_descriptor_get(subtitle_enc->codec_id);
834  int input_props = 0, output_props = 0;
835 
836  const char *frame_size = NULL;
837 
838  opt_match_per_stream_str(ost, &o->frame_sizes, mux->fc, st, &frame_size);
839  if (frame_size) {
840  int ret = av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size);
841  if (ret < 0) {
842  av_log(ost, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
843  return ret;
844  }
845  }
846  if (input_descriptor)
847  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
848  if (output_descriptor)
849  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
850  if (input_props && output_props && input_props != output_props) {
851  av_log(ost, AV_LOG_ERROR,
852  "Subtitle encoding currently only possible from text to text "
853  "or bitmap to bitmap\n");
854  return AVERROR(EINVAL);
855  }
856  }
857 
858  return 0;
859 }
860 
861 static int
862 ost_bind_filter(const Muxer *mux, MuxStream *ms, OutputFilter *ofilter,
863  const OptionsContext *o,
864  AVRational enc_tb, enum VideoSyncMethod vsync_method,
865  int keep_pix_fmt, int autoscale, int threads_manual,
866  const ViewSpecifier *vs,
867  SchedulerNode *src)
868 {
869  OutputStream *ost = &ms->ost;
870  AVCodecContext *enc_ctx = ost->enc->enc_ctx;
871  char name[16];
872  char *filters = NULL;
873  int ret;
874 
875  OutputFilterOptions opts = {
876  .enc = enc_ctx->codec,
877  .name = name,
878  .format = (ost->type == AVMEDIA_TYPE_VIDEO) ?
879  enc_ctx->pix_fmt : enc_ctx->sample_fmt,
880  .width = enc_ctx->width,
881  .height = enc_ctx->height,
882  .color_space = enc_ctx->colorspace,
883  .color_range = enc_ctx->color_range,
884  .alpha_mode = enc_ctx->alpha_mode,
885  .vsync_method = vsync_method,
886  .frame_rate = ms->frame_rate,
887  .max_frame_rate = ms->max_frame_rate,
888  .sample_rate = enc_ctx->sample_rate,
889  .ch_layout = enc_ctx->ch_layout,
890  .sws_opts = o->g->sws_dict,
891  .swr_opts = o->g->swr_opts,
892  .output_tb = enc_tb,
893  .trim_start_us = mux->of.start_time,
894  .trim_duration_us = mux->of.recording_time,
895  .ts_offset = mux->of.start_time == AV_NOPTS_VALUE ?
896  0 : mux->of.start_time,
897  .vs = vs,
898  .nb_threads = -1,
899  .reinit_opts = ost->enc->reinit_opts,
900 
901  .flags = OFILTER_FLAG_DISABLE_CONVERT * !!keep_pix_fmt |
902  OFILTER_FLAG_AUTOSCALE * !!autoscale |
903  OFILTER_FLAG_AUDIO_24BIT * !!(av_get_exact_bits_per_sample(enc_ctx->codec_id) == 24),
904  };
905 
906  snprintf(name, sizeof(name), "#%d:%d", mux->of.index, ost->index);
907 
908  if (ost->type == AVMEDIA_TYPE_VIDEO) {
909  if (!keep_pix_fmt) {
910  ret = avcodec_get_supported_config(enc_ctx, NULL,
911  AV_CODEC_CONFIG_PIX_FORMAT, 0,
912  (const void **) &opts.pix_fmts, NULL);
913  if (ret < 0)
914  return ret;
915  }
916  if (!ms->force_fps) {
917  ret = avcodec_get_supported_config(enc_ctx, NULL,
918  AV_CODEC_CONFIG_FRAME_RATE, 0,
919  (const void **) &opts.frame_rates, NULL);
920  if (ret < 0)
921  return ret;
922  }
923  ret = avcodec_get_supported_config(enc_ctx, NULL,
924  AV_CODEC_CONFIG_COLOR_SPACE, 0,
925  (const void **) &opts.color_spaces, NULL);
926  if (ret < 0)
927  return ret;
928  ret = avcodec_get_supported_config(enc_ctx, NULL,
929  AV_CODEC_CONFIG_COLOR_RANGE, 0,
930  (const void **) &opts.color_ranges, NULL);
931  if (ret < 0)
932  return ret;
933  ret = avcodec_get_supported_config(enc_ctx, NULL,
934  AV_CODEC_CONFIG_ALPHA_MODE, 0,
935  (const void **) &opts.alpha_modes, NULL);
936  if (ret < 0)
937  return ret;
938  } else {
939  ret = avcodec_get_supported_config(enc_ctx, NULL,
940  AV_CODEC_CONFIG_SAMPLE_FORMAT, 0,
941  (const void **) &opts.sample_fmts, NULL);
942  if (ret < 0)
943  return ret;
944  ret = avcodec_get_supported_config(enc_ctx, NULL,
945  AV_CODEC_CONFIG_SAMPLE_RATE, 0,
946  (const void **) &opts.sample_rates, NULL);
947  if (ret < 0)
948  return ret;
949  ret = avcodec_get_supported_config(enc_ctx, NULL,
950  AV_CODEC_CONFIG_CHANNEL_LAYOUT, 0,
951  (const void **) &opts.ch_layouts, NULL);
952  if (ret < 0)
953  return ret;
954  }
955 
956  if (threads_manual) {
957  ret = av_opt_get_int(enc_ctx, "threads", 0, &opts.nb_threads);
958  if (ret < 0)
959  return ret;
960  }
961 
962  ret = ost_get_filters(o, mux->fc, ost, &filters);
963  if (ret < 0)
964  return ret;
965 
966  if (ofilter) {
967  av_assert0(!filters);
968  ost->filter = ofilter;
969  ret = ofilter_bind_enc(ofilter, ms->sch_idx_enc, &opts);
970  } else {
971  ret = fg_create_simple(&ost->fg_simple, ost->ist, &filters,
972  mux->sch, ms->sch_idx_enc, &opts);
973  if (ret >= 0)
974  ost->filter = ost->fg_simple->outputs[0];
975 
976  }
977  if (ret < 0)
978  return ret;
979 
980  *src = SCH_ENC(ms->sch_idx_enc);
981 
982  return 0;
983 }
984 
985 static int streamcopy_init(const OptionsContext *o, const Muxer *mux,
986  OutputStream *ost, AVDictionary **encoder_opts)
987 {
988  MuxStream *ms = ms_from_ost(ost);
989 
990  const InputStream *ist = ost->ist;
991  const InputFile *ifile = ist->file;
992 
993  AVCodecParameters *par = ms->par_in;
994  uint32_t codec_tag = par->codec_tag;
995 
996  AVCodecContext *codec_ctx = NULL;
997 
998  AVRational fr = ms->frame_rate;
999 
1000  int ret = 0;
1001 
1002  const char *filters = NULL;
1003  opt_match_per_stream_str(ost, &o->filters, mux->fc, ost->st, &filters);
1004 
1005  if (filters) {
1006  av_log(ost, AV_LOG_ERROR,
1007  "Filtergraph '%s' was specified, but codec copy was selected. "
1008  "Filtering and streamcopy cannot be used together.\n", filters);
1009  return AVERROR(EINVAL);
1010  }
1011 
1012  codec_ctx = avcodec_alloc_context3(NULL);
1013  if (!codec_ctx)
1014  return AVERROR(ENOMEM);
1015 
1016  ret = avcodec_parameters_to_context(codec_ctx, ist->par);
1017  if (ret >= 0)
1018  ret = av_opt_set_dict(codec_ctx, encoder_opts);
1019  if (ret < 0) {
1020  av_log(ost, AV_LOG_FATAL,
1021  "Error setting up codec context options.\n");
1022  goto fail;
1023  }
1024 
1025  ret = avcodec_parameters_from_context(par, codec_ctx);
1026  if (ret < 0) {
1027  av_log(ost, AV_LOG_FATAL,
1028  "Error getting reference codec parameters.\n");
1029  goto fail;
1030  }
1031 
1032  if (!codec_tag) {
1033  const struct AVCodecTag * const *ct = mux->fc->oformat->codec_tag;
1034  unsigned int codec_tag_tmp;
1035  if (!ct || av_codec_get_id (ct, par->codec_tag) == par->codec_id ||
1036  !av_codec_get_tag2(ct, par->codec_id, &codec_tag_tmp))
1037  codec_tag = par->codec_tag;
1038  }
1039 
1040  par->codec_tag = codec_tag;
1041 
1042  if (!fr.num)
1043  fr = ist->framerate;
1044 
1045  if (fr.num)
1046  ost->st->avg_frame_rate = fr;
1047  else
1048  ost->st->avg_frame_rate = ist->st->avg_frame_rate;
1049 
1050  // copy timebase while removing common factors
1051  if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0) {
1052  if (fr.num)
1053  ost->st->time_base = av_inv_q(fr);
1054  else
1055  ost->st->time_base = av_add_q(ist->st->time_base, (AVRational){0, 1});
1056  }
1057 
1058  if (!ms->copy_prior_start) {
1059  ms->ts_copy_start = (mux->of.start_time == AV_NOPTS_VALUE) ?
1060  0 : mux->of.start_time;
1061  if (copy_ts && ifile->start_time != AV_NOPTS_VALUE) {
1062  ms->ts_copy_start = FFMAX(ms->ts_copy_start,
1063  ifile->start_time + ifile->ts_offset);
1064  }
1065  }
1066 
1067  for (int i = 0; i < ist->st->codecpar->nb_coded_side_data; i++) {
1068  const AVPacketSideData *sd_src = &ist->st->codecpar->coded_side_data[i];
1069  AVPacketSideData *sd_dst;
1070 
1071  sd_dst = av_packet_side_data_new(&ost->st->codecpar->coded_side_data,
1072  &ost->st->codecpar->nb_coded_side_data,
1073  sd_src->type, sd_src->size, 0);
1074  if (!sd_dst) {
1075  ret = AVERROR(ENOMEM);
1076  goto fail;
1077  }
1078  memcpy(sd_dst->data, sd_src->data, sd_src->size);
1079  }
1080 
1081  switch (par->codec_type) {
1082  case AVMEDIA_TYPE_AUDIO:
1083  if ((par->block_align == 1 || par->block_align == 1152 || par->block_align == 576) &&
1084  par->codec_id == AV_CODEC_ID_MP3)
1085  par->block_align = 0;
1086  if (par->codec_id == AV_CODEC_ID_AC3)
1087  par->block_align = 0;
1088  break;
1089  case AVMEDIA_TYPE_VIDEO: {
1090  AVRational sar;
1091  if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
1092  sar =
1093  av_mul_q(ost->frame_aspect_ratio,
1094  (AVRational){ par->height, par->width });
1095  av_log(ost, AV_LOG_WARNING, "Overriding aspect ratio "
1096  "with stream copy may produce invalid files\n");
1097  }
1098  else if (ist->st->sample_aspect_ratio.num)
1099  sar = ist->st->sample_aspect_ratio;
1100  else
1101  sar = par->sample_aspect_ratio;
1102  ost->st->sample_aspect_ratio = par->sample_aspect_ratio = sar;
1103  ost->st->r_frame_rate = ist->st->r_frame_rate;
1104  break;
1105  }
1106  }
1107 
1108 fail:
1109  avcodec_free_context(&codec_ctx);
1110  return ret;
1111 }
1112 
1113 static int set_encoder_id(OutputStream *ost, const AVCodec *codec)
1114 {
1115  const char *cname = codec->name;
1116  uint8_t *encoder_string;
1117  int encoder_string_len;
1118 
1119  encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(cname) + 2;
1120  encoder_string = av_mallocz(encoder_string_len);
1121  if (!encoder_string)
1122  return AVERROR(ENOMEM);
1123 
1124  if (!ost->file->bitexact && !ost->bitexact)
1125  av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
1126  else
1127  av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
1128  av_strlcat(encoder_string, cname, encoder_string_len);
1129  av_dict_set(&ost->st->metadata, "encoder", encoder_string,
1130  AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
1131 
1132  return 0;
1133 }
1134 
1135 static int ost_add(Muxer *mux, const OptionsContext *o, enum AVMediaType type,
1136  InputStream *ist, OutputFilter *ofilter, const ViewSpecifier *vs,
1137  OutputStream **post)
1138 {
1139  AVFormatContext *oc = mux->fc;
1140  MuxStream *ms;
1141  OutputStream *ost;
1142  const AVCodec *enc;
1143  AVStream *st;
1144  SchedulerNode src = { .type = SCH_NODE_TYPE_NONE };
1145  AVDictionary *encoder_opts = NULL;
1146  int ret = 0, keep_pix_fmt = 0, autoscale = 1;
1147  int threads_manual = 0;
1148  AVRational enc_tb = { 0, 0 };
1149  enum VideoSyncMethod vsync_method = VSYNC_AUTO;
1150  const char *bsfs = NULL, *time_base = NULL, *codec_tag = NULL;
1151  char *next;
1152  double qscale = -1;
1153 
1154  st = avformat_new_stream(oc, NULL);
1155  if (!st)
1156  return AVERROR(ENOMEM);
1157 
1158  ms = mux_stream_alloc(mux, type);
1159  if (!ms)
1160  return AVERROR(ENOMEM);
1161 
1162  // only streams with sources (i.e. not attachments)
1163  // are handled by the scheduler
1164  if (ist || ofilter) {
1165  ret = GROW_ARRAY(mux->sch_stream_idx, mux->nb_sch_stream_idx);
1166  if (ret < 0)
1167  return ret;
1168 
1169  ret = sch_add_mux_stream(mux->sch, mux->sch_idx);
1170  if (ret < 0)
1171  return ret;
1172 
1173  av_assert0(ret == mux->nb_sch_stream_idx - 1);
1174  mux->sch_stream_idx[ret] = ms->ost.index;
1175  ms->sch_idx = ret;
1176  }
1177 
1178  ost = &ms->ost;
1179 
1180  if (o->streamid) {
1181  AVDictionaryEntry *e;
1182  char idx[16], *p;
1183  snprintf(idx, sizeof(idx), "%d", ost->index);
1184 
1185  e = av_dict_get(o->streamid, idx, NULL, 0);
1186  if (e) {
1187  st->id = strtol(e->value, &p, 0);
1188  if (!e->value[0] || *p) {
1189  av_log(ost, AV_LOG_FATAL, "Invalid stream id: %s\n", e->value);
1190  return AVERROR(EINVAL);
1191  }
1192  }
1193  }
1194 
1195  ms->par_in = avcodec_parameters_alloc();
1196  if (!ms->par_in)
1197  return AVERROR(ENOMEM);
1198 
1199  ms->last_mux_dts = AV_NOPTS_VALUE;
1200 
1201  ost->st = st;
1202  ost->ist = ist;
1203  ost->kf.ref_pts = AV_NOPTS_VALUE;
1204  ms->par_in->codec_type = type;
1205  st->codecpar->codec_type = type;
1206 
1207  ret = choose_encoder(o, oc, ms, &enc);
1208  if (ret < 0) {
1209  av_log(ost, AV_LOG_FATAL, "Error selecting an encoder\n");
1210  return ret;
1211  }
1212 
1213  if (enc) {
1214  ret = sch_add_enc(mux->sch, encoder_thread, ost,
1215  ost->type == AVMEDIA_TYPE_SUBTITLE ? NULL : enc_open);
1216  if (ret < 0)
1217  return ret;
1218  ms->sch_idx_enc = ret;
1219 
1220  ret = enc_alloc(&ost->enc, enc, mux->sch, ms->sch_idx_enc, ost);
1221  if (ret < 0)
1222  return ret;
1223 
1224  av_strlcat(ms->log_name, "/", sizeof(ms->log_name));
1225  av_strlcat(ms->log_name, enc->name, sizeof(ms->log_name));
1226  } else {
1227  if (ofilter) {
1228  av_log(ost, AV_LOG_ERROR,
1229  "Streamcopy requested for output stream fed "
1230  "from a complex filtergraph. Filtering and streamcopy "
1231  "cannot be used together.\n");
1232  return AVERROR(EINVAL);
1233  }
1234 
1235  av_strlcat(ms->log_name, "/copy", sizeof(ms->log_name));
1236  }
1237 
1238  av_log(ost, AV_LOG_VERBOSE, "Created %s stream from ",
1239  av_get_media_type_string(type));
1240  if (ist)
1241  av_log(ost, AV_LOG_VERBOSE, "input stream %d:%d",
1242  ist->file->index, ist->index);
1243  else if (ofilter)
1244  av_log(ost, AV_LOG_VERBOSE, "complex filtergraph %d:[%s]",
1245  ofilter->graph->index, ofilter->name);
1246  else if (type == AVMEDIA_TYPE_ATTACHMENT)
1247  av_log(ost, AV_LOG_VERBOSE, "attached file");
1248  else av_assert0(0);
1249  av_log(ost, AV_LOG_VERBOSE, "\n");
1250 
1251  ms->pkt = av_packet_alloc();
1252  if (!ms->pkt)
1253  return AVERROR(ENOMEM);
1254 
1255  if (ost->enc) {
1256  AVIOContext *s = NULL;
1257  char *buf = NULL, *arg = NULL;
1258  const char *enc_stats_pre = NULL, *enc_stats_post = NULL, *mux_stats = NULL;
1259  const char *enc_time_base = NULL, *enc_reinit_opts = NULL, *preset = NULL;
1260 
1261  ret = filter_codec_opts(o->g->codec_opts, enc->id,
1262  oc, st, enc, &encoder_opts,
1263  &mux->enc_opts_used);
1264  if (ret < 0)
1265  goto fail;
1266 
1267  opt_match_per_stream_str(ost, &o->presets, oc, st, &preset);
1268  opt_match_per_stream_int(ost, &o->autoscale, oc, st, &autoscale);
1269  if (preset && (!(ret = get_preset_file_2(preset, enc->name, &s)))) {
1270  AVBPrint bprint;
1271  av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
1272  do {
1273  av_bprint_clear(&bprint);
1274  buf = get_line(s, &bprint);
1275  if (!buf) {
1276  ret = AVERROR(ENOMEM);
1277  break;
1278  }
1279 
1280  if (!buf[0] || buf[0] == '#')
1281  continue;
1282  if (!(arg = strchr(buf, '='))) {
1283  av_log(ost, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1284  ret = AVERROR(EINVAL);
1285  break;
1286  }
1287  *arg++ = 0;
1288  av_dict_set(&encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1289  } while (!s->eof_reached);
1290  av_bprint_finalize(&bprint, NULL);
1291  avio_closep(&s);
1292  }
1293  if (ret) {
1294  av_log(ost, AV_LOG_FATAL,
1295  "Preset %s specified, but could not be opened.\n", preset);
1296  goto fail;
1297  }
1298 
1299  opt_match_per_stream_str(ost, &o->enc_reinit_opts, oc, st, &enc_reinit_opts);
1300  if (enc_reinit_opts &&
1301  (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)) {
1302  ost->enc->reinit_opts = av_strdup(enc_reinit_opts);
1303  if (!ost->enc->reinit_opts) {
1304  ret = AVERROR(ENOMEM);
1305  goto fail;
1306  }
1307  }
1308 
1309  opt_match_per_stream_str(ost, &o->enc_stats_pre, oc, st, &enc_stats_pre);
1310  if (enc_stats_pre &&
1311  (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)) {
1312  const char *format = "{fidx} {sidx} {n} {t}";
1313 
1314  opt_match_per_stream_str(ost, &o->enc_stats_pre_fmt, oc, st, &format);
1315 
1316  ret = enc_stats_init(ost, &ost->enc_stats_pre, 1, enc_stats_pre, format);
1317  if (ret < 0)
1318  goto fail;
1319  }
1320 
1321  opt_match_per_stream_str(ost, &o->enc_stats_post, oc, st, &enc_stats_post);
1322  if (enc_stats_post &&
1323  (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)) {
1324  const char *format = "{fidx} {sidx} {n} {t}";
1325 
1326  opt_match_per_stream_str(ost, &o->enc_stats_post_fmt, oc, st, &format);
1327 
1328  ret = enc_stats_init(ost, &ost->enc_stats_post, 0, enc_stats_post, format);
1329  if (ret < 0)
1330  goto fail;
1331  }
1332 
1333  opt_match_per_stream_str(ost, &o->mux_stats, oc, st, &mux_stats);
1334  if (mux_stats &&
1335  (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)) {
1336  const char *format = "{fidx} {sidx} {n} {t}";
1337 
1338  opt_match_per_stream_str(ost, &o->mux_stats_fmt, oc, st, &format);
1339 
1340  ret = enc_stats_init(ost, &ms->stats, 0, mux_stats, format);
1341  if (ret < 0)
1342  goto fail;
1343  }
1344 
1345  opt_match_per_stream_str(ost, &o->enc_time_bases, oc, st, &enc_time_base);
1346  if (enc_time_base && type == AVMEDIA_TYPE_SUBTITLE)
1347  av_log(ost, AV_LOG_WARNING,
1348  "-enc_time_base not supported for subtitles, ignoring\n");
1349  else if (enc_time_base) {
1350  AVRational q;
1351 
1352  if (!strcmp(enc_time_base, "demux")) {
1353  q = (AVRational){ ENC_TIME_BASE_DEMUX, 0 };
1354  } else if (!strcmp(enc_time_base, "filter")) {
1355  q = (AVRational){ ENC_TIME_BASE_FILTER, 0 };
1356  } else {
1357  ret = av_parse_ratio(&q, enc_time_base, INT_MAX, 0, NULL);
1358  if (ret < 0 || q.den <= 0 || q.num < 0) {
1359  av_log(ost, AV_LOG_FATAL, "Invalid time base: %s\n", enc_time_base);
1360  ret = ret < 0 ? ret : AVERROR(EINVAL);
1361  goto fail;
1362  }
1363  }
1364 
1365  enc_tb = q;
1366  }
1367 
1368  threads_manual = !!av_dict_get(encoder_opts, "threads", NULL, 0);
1369 
1370  ret = av_dict_copy(&ost->enc->encoder_opts, encoder_opts, 0);
1371  if (ret < 0)
1372  goto fail;
1373  ret = av_opt_set_dict2(ost->enc->enc_ctx, &encoder_opts, AV_OPT_SEARCH_CHILDREN);
1374  if (ret < 0) {
1375  av_log(ost, AV_LOG_ERROR, "Error applying encoder options: %s\n",
1376  av_err2str(ret));
1377  goto fail;
1378  }
1379 
1380  ret = check_avoptions(encoder_opts);
1381  if (ret < 0)
1382  goto fail;
1383 
1384  // default to automatic thread count
1385  if (!threads_manual)
1386  ost->enc->enc_ctx->thread_count = 0;
1387  } else {
1388  ret = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st,
1389  NULL, &encoder_opts,
1390  &mux->enc_opts_used);
1391  if (ret < 0)
1392  goto fail;
1393  }
1394 
1395 
1396  if (o->bitexact) {
1397  ost->bitexact = 1;
1398  } else if (ost->enc) {
1399  ost->bitexact = !!(ost->enc->enc_ctx->flags & AV_CODEC_FLAG_BITEXACT);
1400  }
1401 
1402  if (enc) {
1403  ret = set_encoder_id(ost, enc);
1404  if (ret < 0)
1405  return ret;
1406  }
1407 
1408  opt_match_per_stream_str(ost, &o->time_bases, oc, st, &time_base);
1409  if (time_base) {
1410  AVRational q;
1411  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1412  q.num <= 0 || q.den <= 0) {
1413  av_log(ost, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1414  ret = AVERROR(EINVAL);
1415  goto fail;
1416  }
1417  st->time_base = q;
1418  }
1419 
1420  ms->max_frames = INT64_MAX;
1421  opt_match_per_stream_int64(ost, &o->max_frames, oc, st, &ms->max_frames);
1422  for (int i = 0; i < o->max_frames.nb_opt; i++) {
1423  char *p = o->max_frames.opt[i].specifier;
1424  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1425  av_log(ost, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1426  break;
1427  }
1428  }
1429 
1430  ms->copy_prior_start = -1;
1431  opt_match_per_stream_int(ost, &o->copy_prior_start, oc, st, &ms->copy_prior_start);
1432  opt_match_per_stream_str(ost, &o->bitstream_filters, oc, st, &bsfs);
1433  if (bsfs && *bsfs) {
1434  ret = av_bsf_list_parse_str(bsfs, &ms->bsf_ctx);
1435  if (ret < 0) {
1436  av_log(ost, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1437  goto fail;
1438  }
1439  }
1440 
1441  opt_match_per_stream_str(ost, &o->codec_tags, oc, st, &codec_tag);
1442  if (codec_tag) {
1443  uint32_t tag = strtol(codec_tag, &next, 0);
1444  if (*next) {
1445  uint8_t buf[4] = { 0 };
1446  memcpy(buf, codec_tag, FFMIN(sizeof(buf), strlen(codec_tag)));
1447  tag = AV_RL32(buf);
1448  }
1449  ost->st->codecpar->codec_tag = tag;
1450  ms->par_in->codec_tag = tag;
1451  if (ost->enc)
1452  ost->enc->codec_tag = tag;
1453  }
1454 
1455  opt_match_per_stream_dbl(ost, &o->qscale, oc, st, &qscale);
1456  if (ost->enc && qscale >= 0) {
1457  ost->enc->flags |= AV_CODEC_FLAG_QSCALE;
1458  ost->enc->global_quality = FF_QP2LAMBDA * qscale;
1459  }
1460 
1461  if (ms->sch_idx >= 0) {
1462  int max_muxing_queue_size = 128;
1463  int muxing_queue_data_threshold = 50 * 1024 * 1024;
1464 
1465  opt_match_per_stream_int(ost, &o->max_muxing_queue_size, oc, st,
1466  &max_muxing_queue_size);
1467  opt_match_per_stream_int(ost, &o->muxing_queue_data_threshold,
1468  oc, st, &muxing_queue_data_threshold);
1469 
1470  sch_mux_stream_buffering(mux->sch, mux->sch_idx, ms->sch_idx,
1471  max_muxing_queue_size, muxing_queue_data_threshold);
1472  }
1473 
1474  opt_match_per_stream_int(ost, &o->bits_per_raw_sample, oc, st,
1475  &ost->bits_per_raw_sample);
1476 
1477  opt_match_per_stream_int(ost, &o->fix_sub_duration_heartbeat,
1478  oc, st, &ost->fix_sub_duration_heartbeat);
1479 
1480  if (oc->oformat->flags & AVFMT_GLOBALHEADER && ost->enc)
1481  ost->enc->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1482  if (oc->oformat->flags & AVFMT_FIXED_FRAMESIZE && ost->enc)
1483  ost->enc->flags2 |= AV_CODEC_FLAG2_FIXED_FRAME_SIZE;
1484 
1485  opt_match_per_stream_int(ost, &o->copy_initial_nonkeyframes,
1486  oc, st, &ms->copy_initial_nonkeyframes);
1487  switch (type) {
1488  case AVMEDIA_TYPE_VIDEO: ret = new_stream_video (mux, o, ost, &keep_pix_fmt, &vsync_method); break;
1489  case AVMEDIA_TYPE_AUDIO: ret = new_stream_audio (mux, o, ost); break;
1490  case AVMEDIA_TYPE_SUBTITLE: ret = new_stream_subtitle (mux, o, ost); break;
1491  }
1492  if (ret < 0)
1493  goto fail;
1494 
1495  if (ost->enc &&
1496  (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)) {
1497  ret = ost_bind_filter(mux, ms, ofilter, o, enc_tb, vsync_method,
1498  keep_pix_fmt, autoscale, threads_manual, vs, &src);
1499  if (ret < 0)
1500  goto fail;
1501  } else if (ost->ist) {
1502  ret = ist_use(ost->ist, !!ost->enc, NULL, &src);
1503  if (ret < 0) {
1504  av_log(ost, AV_LOG_ERROR,
1505  "Error binding an input stream\n");
1506  goto fail;
1507  }
1508  ms->sch_idx_src = src.idx;
1509 
1510  // src refers to a decoder for transcoding, demux stream otherwise
1511  if (ost->enc) {
1512  ret = sch_connect(mux->sch,
1513  src, SCH_ENC(ms->sch_idx_enc));
1514  if (ret < 0)
1515  goto fail;
1516  src = SCH_ENC(ms->sch_idx_enc);
1517  }
1518  }
1519 
1520  if (src.type != SCH_NODE_TYPE_NONE) {
1521  ret = sch_connect(mux->sch,
1522  src, SCH_MSTREAM(mux->sch_idx, ms->sch_idx));
1523  if (ret < 0)
1524  goto fail;
1525  } else {
1526  // only attachment streams don't have a source
1527  av_assert0(type == AVMEDIA_TYPE_ATTACHMENT && ms->sch_idx < 0);
1528  }
1529 
1530  if (ost->ist && !ost->enc) {
1531  ret = streamcopy_init(o, mux, ost, &encoder_opts);
1532  if (ret < 0)
1533  goto fail;
1534  }
1535 
1536  // copy estimated duration as a hint to the muxer
1537  if (ost->ist && ost->ist->st->duration > 0) {
1538  ms->stream_duration = ist->st->duration;
1539  ms->stream_duration_tb = ist->st->time_base;
1540  }
1541 
1542  if (post)
1543  *post = ost;
1544 
1545  ret = 0;
1546 
1547 fail:
1548  av_dict_free(&encoder_opts);
1549 
1550  return ret;
1551 }
1552 
1553 static int map_auto_video(Muxer *mux, const OptionsContext *o)
1554 {
1555  AVFormatContext *oc = mux->fc;
1556  InputStreamGroup *best_istg = NULL;
1557  InputStream *best_ist = NULL;
1558  int64_t best_score = 0;
1559  int qcr;
1560 
1561  /* video: highest resolution */
1562  if (av_guess_codec(oc->oformat, NULL, oc->url, NULL, AVMEDIA_TYPE_VIDEO) == AV_CODEC_ID_NONE)
1563  return 0;
1564 
1565  qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1566  for (int j = 0; j < nb_input_files; j++) {
1567  InputFile *ifile = input_files[j];
1568  InputStreamGroup *file_best_istg = NULL;
1569  InputStream *file_best_ist = NULL;
1570  int64_t file_best_score = 0;
1571  for (int i = 0; i < ifile->nb_stream_groups; i++) {
1572  InputStreamGroup *istg = ifile->stream_groups[i];
1573  int64_t score = 0;
1574 
1575  if (!istg->fg)
1576  continue;
1577 
1578  for (int j = 0; j < istg->stg->nb_streams; j++) {
1579  AVStream *st = istg->stg->streams[j];
1580 
1581  if (st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS) {
1582  score = 100000000;
1583  break;
1584  }
1585  }
1586 
1587  switch (istg->stg->type) {
1588  case AV_STREAM_GROUP_PARAMS_TILE_GRID: {
1589  const AVStreamGroupTileGrid *tg = istg->stg->params.tile_grid;
1590  score += tg->width * (int64_t)tg->height
1591  + 5000000*!!(istg->stg->disposition & AV_DISPOSITION_DEFAULT);
1592  break;
1593  }
1594  default:
1595  continue;
1596  }
1597 
1598  if (score > file_best_score) {
1599  file_best_score = score;
1600  file_best_istg = istg;
1601  }
1602  }
1603  for (int i = 0; i < ifile->nb_streams; i++) {
1604  InputStream *ist = ifile->streams[i];
1605  const AVCodecDescriptor *desc = avcodec_descriptor_get(ist->st->codecpar->codec_id);
1606  int64_t score;
1607 
1608  if (ist->user_set_discard == AVDISCARD_ALL ||
1609  ist->st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
1610  (desc && (desc->props & AV_CODEC_PROP_ENHANCEMENT)))
1611  continue;
1612 
1613  score = ist->st->codecpar->width * (int64_t)ist->st->codecpar->height
1614  + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
1615  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
1616  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1617  score = 1;
1618 
1619  if (score > file_best_score) {
1620  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1621  continue;
1622  file_best_score = score;
1623  file_best_ist = ist;
1624  file_best_istg = NULL;
1625  }
1626  }
1627  if (file_best_istg) {
1628  file_best_score -= 5000000*!!(file_best_istg->stg->disposition & AV_DISPOSITION_DEFAULT);
1629  if (file_best_score > best_score) {
1630  best_score = file_best_score;
1631  best_istg = file_best_istg;
1632  best_ist = NULL;
1633  }
1634  }
1635  if (file_best_ist) {
1636  if((qcr == MKTAG('A', 'P', 'I', 'C')) ||
1637  !(file_best_ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1638  file_best_score -= 5000000*!!(file_best_ist->st->disposition & AV_DISPOSITION_DEFAULT);
1639  if (file_best_score > best_score) {
1640  best_score = file_best_score;
1641  best_ist = file_best_ist;
1642  best_istg = NULL;
1643  }
1644  }
1645  }
1646  if (best_istg) {
1647  FilterGraph *fg = best_istg->fg;
1648  OutputFilter *ofilter = fg->outputs[0];
1649 
1650  av_assert0(fg->nb_outputs == 1);
1651  av_log(mux, AV_LOG_VERBOSE, "Creating output stream from stream group derived complex filtergraph %d.\n", fg->index);
1652 
1653  return ost_add(mux, o, AVMEDIA_TYPE_VIDEO, NULL, ofilter, NULL, NULL);
1654  }
1655  if (best_ist)
1656  return ost_add(mux, o, AVMEDIA_TYPE_VIDEO, best_ist, NULL, NULL, NULL);
1657 
1658  return 0;
1659 }
1660 
1661 static int map_auto_audio(Muxer *mux, const OptionsContext *o)
1662 {
1663  AVFormatContext *oc = mux->fc;
1664  InputStream *best_ist = NULL;
1665  int best_score = 0;
1666 
1667  /* audio: most channels */
1668  if (av_guess_codec(oc->oformat, NULL, oc->url, NULL, AVMEDIA_TYPE_AUDIO) == AV_CODEC_ID_NONE)
1669  return 0;
1670 
1671  for (int j = 0; j < nb_input_files; j++) {
1672  InputFile *ifile = input_files[j];
1673  InputStream *file_best_ist = NULL;
1674  int file_best_score = 0;
1675  for (int i = 0; i < ifile->nb_streams; i++) {
1676  InputStream *ist = ifile->streams[i];
1677  int score;
1678 
1679  if (ist->user_set_discard == AVDISCARD_ALL ||
1680  ist->st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1681  continue;
1682 
1683  score = ist->st->codecpar->ch_layout.nb_channels
1684  + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
1685  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
1686  if (score > file_best_score) {
1687  file_best_score = score;
1688  file_best_ist = ist;
1689  }
1690  }
1691  if (file_best_ist) {
1692  file_best_score -= 5000000*!!(file_best_ist->st->disposition & AV_DISPOSITION_DEFAULT);
1693  if (file_best_score > best_score) {
1694  best_score = file_best_score;
1695  best_ist = file_best_ist;
1696  }
1697  }
1698  }
1699  if (best_ist)
1700  return ost_add(mux, o, AVMEDIA_TYPE_AUDIO, best_ist, NULL, NULL, NULL);
1701 
1702  return 0;
1703 }
1704 
1705 static int map_auto_subtitle(Muxer *mux, const OptionsContext *o)
1706 {
1707  AVFormatContext *oc = mux->fc;
1708  const char *subtitle_codec_name = NULL;
1709 
1710  /* subtitles: pick first */
1711  subtitle_codec_name = opt_match_per_type_str(&o->codec_names, 's');
1712  if (!avcodec_find_encoder(oc->oformat->subtitle_codec) && !subtitle_codec_name)
1713  return 0;
1714 
1715  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist))
1716  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1717  AVCodecDescriptor const *input_descriptor =
1718  avcodec_descriptor_get(ist->st->codecpar->codec_id);
1719  AVCodecDescriptor const *output_descriptor = NULL;
1720  AVCodec const *output_codec =
1721  avcodec_find_encoder(oc->oformat->subtitle_codec);
1722  int input_props = 0, output_props = 0;
1723  if (ist->user_set_discard == AVDISCARD_ALL)
1724  continue;
1725  if (output_codec)
1726  output_descriptor = avcodec_descriptor_get(output_codec->id);
1727  if (input_descriptor)
1728  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1729  if (output_descriptor)
1730  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1731  if (subtitle_codec_name ||
1732  input_props & output_props ||
1733  // Map dvb teletext which has neither property to any output subtitle encoder
1734  input_descriptor && output_descriptor &&
1735  (!input_descriptor->props ||
1736  !output_descriptor->props)) {
1737  return ost_add(mux, o, AVMEDIA_TYPE_SUBTITLE, ist, NULL, NULL, NULL);
1738  }
1739  }
1740 
1741  return 0;
1742 }
1743 
1744 static int map_auto_data(Muxer *mux, const OptionsContext *o)
1745 {
1746  AVFormatContext *oc = mux->fc;
1747  /* Data only if codec id match */
1748  enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, oc->url, NULL, AVMEDIA_TYPE_DATA);
1749 
1750  if (codec_id == AV_CODEC_ID_NONE)
1751  return 0;
1752 
1753  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
1754  if (ist->user_set_discard == AVDISCARD_ALL)
1755  continue;
1756  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA &&
1757  ist->st->codecpar->codec_id == codec_id) {
1758  int ret = ost_add(mux, o, AVMEDIA_TYPE_DATA, ist, NULL, NULL, NULL);
1759  if (ret < 0)
1760  return ret;
1761  }
1762  }
1763 
1764  return 0;
1765 }
1766 
1767 static int map_manual(Muxer *mux, const OptionsContext *o, const StreamMap *map)
1768 {
1769  InputStream *ist;
1770  int ret;
1771 
1772  if (map->disabled)
1773  return 0;
1774 
1775  if (map->linklabel) {
1776  FilterGraph *fg;
1777  OutputFilter *ofilter = NULL;
1778  int j, k;
1779 
1780  for (j = 0; j < nb_filtergraphs; j++) {
1781  fg = filtergraphs[j];
1782  for (k = 0; k < fg->nb_outputs; k++) {
1783  const char *linklabel = fg->outputs[k]->linklabel;
1784  if (linklabel && !strcmp(linklabel, map->linklabel)) {
1785  ofilter = fg->outputs[k];
1786  goto loop_end;
1787  }
1788  }
1789  }
1790 loop_end:
1791  if (!ofilter) {
1792  av_log(mux, AV_LOG_FATAL, "Output with label '%s' does not exist "
1793  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1794  return AVERROR(EINVAL);
1795  }
1796 
1797  av_log(mux, AV_LOG_VERBOSE, "Creating output stream from an explicitly "
1798  "mapped complex filtergraph %d, output [%s]\n", fg->index, map->linklabel);
1799 
1800  ret = ost_add(mux, o, ofilter->type, NULL, ofilter, NULL, NULL);
1801  if (ret < 0)
1802  return ret;
1803  } else {
1804  const ViewSpecifier *vs = map->vs.type == VIEW_SPECIFIER_TYPE_NONE ?
1805  NULL : &map->vs;
1806 
1807  ist = input_files[map->file_index]->streams[map->stream_index];
1808  if (ist->user_set_discard == AVDISCARD_ALL) {
1809  av_log(mux, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
1810  map->file_index, map->stream_index);
1811  return AVERROR(EINVAL);
1812  }
1813  if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
1814  return 0;
1815  if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
1816  return 0;
1817  if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1818  return 0;
1819  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
1820  return 0;
1821 
1822  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN &&
1823  !copy_unknown_streams) {
1824  av_log(mux, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
1825  "Cannot map stream #%d:%d - unsupported type.\n",
1826  map->file_index, map->stream_index);
1827  if (!ignore_unknown_streams) {
1828  av_log(mux, AV_LOG_FATAL,
1829  "If you want unsupported types ignored instead "
1830  "of failing, please use the -ignore_unknown option\n"
1831  "If you want them copied, please use -copy_unknown\n");
1832  return AVERROR(EINVAL);
1833  }
1834  return 0;
1835  }
1836 
1837  if (vs && ist->st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
1838  av_log(mux, AV_LOG_ERROR,
1839  "View specifier given for mapping a %s input stream\n",
1840  av_get_media_type_string(ist->st->codecpar->codec_type));
1841  return AVERROR(EINVAL);
1842  }
1843 
1844  ret = ost_add(mux, o, ist->st->codecpar->codec_type, ist, NULL, vs, NULL);
1845  if (ret < 0)
1846  return ret;
1847  }
1848 
1849  return 0;
1850 }
1851 
1852 static int of_add_attachments(Muxer *mux, const OptionsContext *o)
1853 {
1854  MuxStream *ms;
1855  OutputStream *ost;
1856  int err;
1857 
1858  for (int i = 0; i < o->nb_attachments; i++) {
1859  AVIOContext *pb;
1860  uint8_t *attachment;
1861  char *attachment_filename;
1862  const char *p;
1863  int64_t len;
1864 
1865  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1866  av_log(mux, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1867  o->attachments[i]);
1868  return err;
1869  }
1870  if ((len = avio_size(pb)) <= 0) {
1871  av_log(mux, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1872  o->attachments[i]);
1873  err = len ? len : AVERROR_INVALIDDATA;
1874  goto read_fail;
1875  }
1876  if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
1877  av_log(mux, AV_LOG_FATAL, "Attachment %s too large.\n",
1878  o->attachments[i]);
1879  err = AVERROR(ERANGE);
1880  goto read_fail;
1881  }
1882 
1883  attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE);
1884  if (!attachment) {
1885  err = AVERROR(ENOMEM);
1886  goto read_fail;
1887  }
1888 
1889  err = avio_read(pb, attachment, len);
1890  if (err < 0)
1891  av_log(mux, AV_LOG_FATAL, "Error reading attachment file %s: %s\n",
1892  o->attachments[i], av_err2str(err));
1893  else if (err != len) {
1894  av_log(mux, AV_LOG_FATAL, "Could not read all %"PRId64" bytes for "
1895  "attachment file %s\n", len, o->attachments[i]);
1896  err = AVERROR(EIO);
1897  }
1898 
1899 read_fail:
1900  avio_closep(&pb);
1901  if (err < 0)
1902  return err;
1903 
1904  memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1905 
1906  av_log(mux, AV_LOG_VERBOSE, "Creating attachment stream from file %s\n",
1907  o->attachments[i]);
1908 
1909  attachment_filename = av_strdup(o->attachments[i]);
1910  if (!attachment_filename) {
1911  av_free(attachment);
1912  return AVERROR(ENOMEM);
1913  }
1914 
1915  err = ost_add(mux, o, AVMEDIA_TYPE_ATTACHMENT, NULL, NULL, NULL, &ost);
1916  if (err < 0) {
1917  av_free(attachment_filename);
1918  av_freep(&attachment);
1919  return err;
1920  }
1921 
1922  ms = ms_from_ost(ost);
1923 
1924  ost->attachment_filename = attachment_filename;
1925  ms->par_in->extradata = attachment;
1926  ms->par_in->extradata_size = len;
1927 
1928  p = strrchr(o->attachments[i], '/');
1929  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1930  }
1931 
1932  return 0;
1933 }
1934 
1935 static int create_streams(Muxer *mux, const OptionsContext *o)
1936 {
1937  static int (* const map_func[])(Muxer *mux, const OptionsContext *o) = {
1938  [AVMEDIA_TYPE_VIDEO] = map_auto_video,
1939  [AVMEDIA_TYPE_AUDIO] = map_auto_audio,
1940  [AVMEDIA_TYPE_SUBTITLE] = map_auto_subtitle,
1941  [AVMEDIA_TYPE_DATA] = map_auto_data,
1942  };
1943 
1944  AVFormatContext *oc = mux->fc;
1945 
1946  int auto_disable =
1947  o->video_disable * (1 << AVMEDIA_TYPE_VIDEO) |
1948  o->audio_disable * (1 << AVMEDIA_TYPE_AUDIO) |
1949  o->subtitle_disable * (1 << AVMEDIA_TYPE_SUBTITLE) |
1950  o->data_disable * (1 << AVMEDIA_TYPE_DATA);
1951 
1952  int ret;
1953 
1954  /* create streams for all unlabeled output pads */
1955  for (int i = 0; i < nb_filtergraphs; i++) {
1956  FilterGraph *fg = filtergraphs[i];
1957  for (int j = 0; j < fg->nb_outputs; j++) {
1958  OutputFilter *ofilter = fg->outputs[j];
1959 
1960  if (ofilter->linklabel || ofilter->bound)
1961  continue;
1962 
1963  auto_disable |= 1 << ofilter->type;
1964 
1965  av_log(mux, AV_LOG_VERBOSE, "Creating output stream from unlabeled "
1966  "output of complex filtergraph %d.", fg->index);
1967  if (!o->nb_stream_maps)
1968  av_log(mux, AV_LOG_VERBOSE, " This overrides automatic %s mapping.",
1969  av_get_media_type_string(ofilter->type));
1970  av_log(mux, AV_LOG_VERBOSE, "\n");
1971 
1972  ret = ost_add(mux, o, ofilter->type, NULL, ofilter, NULL, NULL);
1973  if (ret < 0)
1974  return ret;
1975  }
1976  }
1977 
1978  if (!o->nb_stream_maps) {
1979  av_log(mux, AV_LOG_VERBOSE, "No explicit maps, mapping streams automatically...\n");
1980 
1981  /* pick the "best" stream of each type */
1982  for (int i = 0; i < FF_ARRAY_ELEMS(map_func); i++) {
1983  if (!map_func[i] || auto_disable & (1 << i))
1984  continue;
1985  ret = map_func[i](mux, o);
1986  if (ret < 0)
1987  return ret;
1988  }
1989  } else {
1990  av_log(mux, AV_LOG_VERBOSE, "Adding streams from explicit maps...\n");
1991 
1992  for (int i = 0; i < o->nb_stream_maps; i++) {
1993  ret = map_manual(mux, o, &o->stream_maps[i]);
1994  if (ret < 0)
1995  return ret;
1996  }
1997  }
1998 
1999  ret = of_add_attachments(mux, o);
2000  if (ret < 0)
2001  return ret;
2002 
2003  // setup fix_sub_duration_heartbeat mappings
2004  for (unsigned i = 0; i < oc->nb_streams; i++) {
2005  MuxStream *src = ms_from_ost(mux->of.streams[i]);
2006 
2007  if (!src->ost.fix_sub_duration_heartbeat)
2008  continue;
2009 
2010  for (unsigned j = 0; j < oc->nb_streams; j++) {
2011  MuxStream *dst = ms_from_ost(mux->of.streams[j]);
2012 
2013  if (src == dst || dst->ost.type != AVMEDIA_TYPE_SUBTITLE ||
2014  !dst->ost.enc || !dst->ost.ist || !dst->ost.ist->fix_sub_duration)
2015  continue;
2016 
2017  ret = sch_mux_sub_heartbeat_add(mux->sch, mux->sch_idx, src->sch_idx,
2018  dst->sch_idx_src);
2019 
2020  }
2021  }
2022 
2023  // handle -apad
2024  if (o->shortest) {
2025  int have_video = 0;
2026 
2027  for (unsigned i = 0; i < mux->of.nb_streams; i++)
2028  if (mux->of.streams[i]->type == AVMEDIA_TYPE_VIDEO) {
2029  have_video = 1;
2030  break;
2031  }
2032 
2033  for (unsigned i = 0; have_video && i < mux->of.nb_streams; i++) {
2034  MuxStream *ms = ms_from_ost(mux->of.streams[i]);
2035  OutputFilter *ofilter = ms->ost.filter;
2036 
2037  if (ms->ost.type != AVMEDIA_TYPE_AUDIO || !ms->apad || !ofilter)
2038  continue;
2039 
2040  ofilter->apad = av_strdup(ms->apad);
2041  if (!ofilter->apad)
2042  return AVERROR(ENOMEM);
2043  }
2044  }
2045  for (unsigned i = 0; i < mux->of.nb_streams; i++) {
2046  MuxStream *ms = ms_from_ost(mux->of.streams[i]);
2047  ms->apad = NULL;
2048  }
2049 
2050  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2051  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2052  av_log(mux, AV_LOG_ERROR, "Output file does not contain any stream\n");
2053  return AVERROR(EINVAL);
2054  }
2055 
2056  return 0;
2057 }
2058 
2059 static int setup_sync_queues(Muxer *mux, AVFormatContext *oc,
2060  int64_t buf_size_us, int shortest)
2061 {
2062  OutputFile *of = &mux->of;
2063  int nb_av_enc = 0, nb_audio_fs = 0, nb_interleaved = 0;
2064  int limit_frames = 0, limit_frames_av_enc = 0;
2065 
2066 #define IS_AV_ENC(ost, type) \
2067  (ost->enc && (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO))
2068 #define IS_INTERLEAVED(type) (type != AVMEDIA_TYPE_ATTACHMENT)
2069 
2070  for (int i = 0; i < oc->nb_streams; i++) {
2071  OutputStream *ost = of->streams[i];
2072  MuxStream *ms = ms_from_ost(ost);
2073  enum AVMediaType type = ost->type;
2074 
2075  ms->sq_idx_mux = -1;
2076 
2077  nb_interleaved += IS_INTERLEAVED(type);
2078  nb_av_enc += IS_AV_ENC(ost, type);
2079  nb_audio_fs += (ost->enc && type == AVMEDIA_TYPE_AUDIO &&
2080  (!(ost->enc->enc_ctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) ||
2081  (ost->enc->flags2 & AV_CODEC_FLAG2_FIXED_FRAME_SIZE)));
2082 
2083  limit_frames |= ms->max_frames < INT64_MAX;
2084  limit_frames_av_enc |= (ms->max_frames < INT64_MAX) && IS_AV_ENC(ost, type);
2085  }
2086 
2087  if (!((nb_interleaved > 1 && shortest) ||
2088  (nb_interleaved > 0 && limit_frames) ||
2089  nb_audio_fs))
2090  return 0;
2091 
2092  /* we use a sync queue before encoding when:
2093  * - 'shortest' is in effect and we have two or more encoded audio/video
2094  * streams
2095  * - at least one encoded audio/video stream is frame-limited, since
2096  * that has similar semantics to 'shortest'
2097  * - at least one audio encoder requires constant frame sizes
2098  *
2099  * Note that encoding sync queues are handled in the scheduler, because
2100  * different encoders run in different threads and need external
2101  * synchronization, while muxer sync queues can be handled inside the muxer
2102  */
2103  if ((shortest && nb_av_enc > 1) || limit_frames_av_enc || nb_audio_fs) {
2104  int sq_idx, ret;
2105 
2106  sq_idx = sch_add_sq_enc(mux->sch, buf_size_us, mux);
2107  if (sq_idx < 0)
2108  return sq_idx;
2109 
2110  for (int i = 0; i < oc->nb_streams; i++) {
2111  OutputStream *ost = of->streams[i];
2112  MuxStream *ms = ms_from_ost(ost);
2113  enum AVMediaType type = ost->type;
2114 
2115  if (!IS_AV_ENC(ost, type))
2116  continue;
2117 
2118  ret = sch_sq_add_enc(mux->sch, sq_idx, ms->sch_idx_enc,
2119  shortest || ms->max_frames < INT64_MAX,
2120  ms->max_frames);
2121  if (ret < 0)
2122  return ret;
2123  }
2124  }
2125 
2126  /* if there are any additional interleaved streams, then ALL the streams
2127  * are also synchronized before sending them to the muxer */
2128  if (nb_interleaved > nb_av_enc) {
2129  mux->sq_mux = sq_alloc(SYNC_QUEUE_PACKETS, buf_size_us, mux);
2130  if (!mux->sq_mux)
2131  return AVERROR(ENOMEM);
2132 
2133  mux->sq_pkt = av_packet_alloc();
2134  if (!mux->sq_pkt)
2135  return AVERROR(ENOMEM);
2136 
2137  for (int i = 0; i < oc->nb_streams; i++) {
2138  OutputStream *ost = of->streams[i];
2139  MuxStream *ms = ms_from_ost(ost);
2140  enum AVMediaType type = ost->type;
2141 
2142  if (!IS_INTERLEAVED(type))
2143  continue;
2144 
2145  ms->sq_idx_mux = sq_add_stream(mux->sq_mux,
2146  shortest || ms->max_frames < INT64_MAX);
2147  if (ms->sq_idx_mux < 0)
2148  return ms->sq_idx_mux;
2149 
2150  if (ms->max_frames != INT64_MAX)
2151  sq_limit_frames(mux->sq_mux, ms->sq_idx_mux, ms->max_frames);
2152  }
2153  }
2154 
2155 #undef IS_AV_ENC
2156 #undef IS_INTERLEAVED
2157 
2158  return 0;
2159 }
2160 
2161 static int of_parse_iamf_audio_element_layers(Muxer *mux, AVStreamGroup *stg, char *ptr)
2162 {
2163  AVIAMFAudioElement *audio_element = stg->params.iamf_audio_element;
2164  AVDictionary *dict = NULL;
2165  const char *token;
2166  int ret = 0;
2167 
2168  audio_element->demixing_info =
2169  av_iamf_param_definition_alloc(AV_IAMF_PARAMETER_DEFINITION_DEMIXING, 1, NULL);
2170  audio_element->recon_gain_info =
2171  av_iamf_param_definition_alloc(AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN, 1, NULL);
2172 
2173  if (!audio_element->demixing_info ||
2174  !audio_element->recon_gain_info)
2175  return AVERROR(ENOMEM);
2176 
2177  /* process manually set layers and parameters */
2178  token = av_strtok(NULL, ",", &ptr);
2179  while (token) {
2180  const AVDictionaryEntry *e;
2181  int demixing = 0, recon_gain = 0;
2182  int layer = 0;
2183 
2184  if (ptr)
2185  ptr += strspn(ptr, " \n\t\r");
2186  if (av_strstart(token, "layer=", &token))
2187  layer = 1;
2188  else if (av_strstart(token, "demixing=", &token))
2189  demixing = 1;
2190  else if (av_strstart(token, "recon_gain=", &token))
2191  recon_gain = 1;
2192 
2193  av_dict_free(&dict);
2194  ret = av_dict_parse_string(&dict, token, "=", ":", 0);
2195  if (ret < 0) {
2196  av_log(mux, AV_LOG_ERROR, "Error parsing audio element specification %s\n", token);
2197  goto fail;
2198  }
2199 
2200  if (layer) {
2201  AVIAMFLayer *audio_layer = av_iamf_audio_element_add_layer(audio_element);
2202  if (!audio_layer) {
2203  av_log(mux, AV_LOG_ERROR, "Error adding layer to stream group %d\n", stg->index);
2204  ret = AVERROR(ENOMEM);
2205  goto fail;
2206  }
2207  av_opt_set_dict(audio_layer, &dict);
2208  } else if (demixing || recon_gain) {
2209  AVIAMFParamDefinition *param = demixing ? audio_element->demixing_info
2210  : audio_element->recon_gain_info;
2211  void *subblock = av_iamf_param_definition_get_subblock(param, 0);
2212 
2213  av_opt_set_dict(param, &dict);
2214  av_opt_set_dict(subblock, &dict);
2215  }
2216 
2217  // make sure that no entries are left in the dict
2218  e = NULL;
2219  if (e = av_dict_iterate(dict, e)) {
2220  av_log(mux, AV_LOG_FATAL, "Unknown layer key %s.\n", e->key);
2221  ret = AVERROR(EINVAL);
2222  goto fail;
2223  }
2224  token = av_strtok(NULL, ",", &ptr);
2225  }
2226 
2227 fail:
2228  av_dict_free(&dict);
2229  if (!ret && !audio_element->nb_layers) {
2230  av_log(mux, AV_LOG_ERROR, "No layer in audio element specification\n");
2231  ret = AVERROR(EINVAL);
2232  }
2233 
2234  return ret;
2235 }
2236 
2237 static int of_parse_iamf_submixes(Muxer *mux, AVStreamGroup *stg, char *ptr)
2238 {
2239  AVFormatContext *oc = mux->fc;
2240  AVIAMFMixPresentation *mix = stg->params.iamf_mix_presentation;
2241  AVDictionary *dict = NULL;
2242  const char *token;
2243  char *submix_str = NULL;
2244  int ret = 0;
2245 
2246  /* process manually set submixes */
2247  token = av_strtok(NULL, ",", &ptr);
2248  while (token) {
2249  AVIAMFSubmix *submix = NULL;
2250  const char *subtoken;
2251  char *subptr = NULL;
2252 
2253  if (ptr)
2254  ptr += strspn(ptr, " \n\t\r");
2255  if (!av_strstart(token, "submix=", &token)) {
2256  av_log(mux, AV_LOG_ERROR, "No submix in mix presentation specification \"%s\"\n", token);
2257  goto fail;
2258  }
2259 
2260  submix_str = av_strdup(token);
2261  if (!submix_str)
2262  goto fail;
2263 
2264  submix = av_iamf_mix_presentation_add_submix(mix);
2265  if (!submix) {
2266  av_log(mux, AV_LOG_ERROR, "Error adding submix to stream group %d\n", stg->index);
2267  ret = AVERROR(ENOMEM);
2268  goto fail;
2269  }
2270  submix->output_mix_config =
2271  av_iamf_param_definition_alloc(AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN, 0, NULL);
2272  if (!submix->output_mix_config) {
2273  ret = AVERROR(ENOMEM);
2274  goto fail;
2275  }
2276 
2277  subptr = NULL;
2278  subtoken = av_strtok(submix_str, "|", &subptr);
2279  while (subtoken) {
2280  const AVDictionaryEntry *e;
2281  int element = 0, layout = 0;
2282 
2283  if (subptr)
2284  subptr += strspn(subptr, " \n\t\r");
2285  if (av_strstart(subtoken, "element=", &subtoken))
2286  element = 1;
2287  else if (av_strstart(subtoken, "layout=", &subtoken))
2288  layout = 1;
2289 
2290  av_dict_free(&dict);
2291  ret = av_dict_parse_string(&dict, subtoken, "=", ":", 0);
2292  if (ret < 0) {
2293  av_log(mux, AV_LOG_ERROR, "Error parsing submix specification \"%s\"\n", subtoken);
2294  goto fail;
2295  }
2296 
2297  if (element) {
2298  AVIAMFSubmixElement *submix_element;
2299  char *endptr = NULL;
2300  int64_t idx = -1;
2301 
2302  if (e = av_dict_get(dict, "stg", NULL, 0))
2303  idx = strtoll(e->value, &endptr, 0);
2304  if (!endptr || *endptr || idx < 0 || idx >= oc->nb_stream_groups - 1 ||
2305  oc->stream_groups[idx]->type != AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT) {
2306  av_log(mux, AV_LOG_ERROR, "Invalid or missing stream group index in "
2307  "submix element specification \"%s\"\n", subtoken);
2308  ret = AVERROR(EINVAL);
2309  goto fail;
2310  }
2311  submix_element = av_iamf_submix_add_element(submix);
2312  if (!submix_element) {
2313  av_log(mux, AV_LOG_ERROR, "Error adding element to submix\n");
2314  ret = AVERROR(ENOMEM);
2315  goto fail;
2316  }
2317 
2318  submix_element->audio_element_id = oc->stream_groups[idx]->id;
2319 
2320  submix_element->element_mix_config =
2321  av_iamf_param_definition_alloc(AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN, 0, NULL);
2322  if (!submix_element->element_mix_config)
2323  ret = AVERROR(ENOMEM);
2324  av_dict_set(&dict, "stg", NULL, 0);
2325  av_opt_set_dict2(submix_element, &dict, AV_OPT_SEARCH_CHILDREN);
2326  } else if (layout) {
2327  AVIAMFSubmixLayout *submix_layout = av_iamf_submix_add_layout(submix);
2328  if (!submix_layout) {
2329  av_log(mux, AV_LOG_ERROR, "Error adding layout to submix\n");
2330  ret = AVERROR(ENOMEM);
2331  goto fail;
2332  }
2333  av_opt_set_dict(submix_layout, &dict);
2334  } else
2335  av_opt_set_dict2(submix, &dict, AV_OPT_SEARCH_CHILDREN);
2336 
2337  if (ret < 0) {
2338  goto fail;
2339  }
2340 
2341  // make sure that no entries are left in the dict
2342  e = NULL;
2343  while (e = av_dict_iterate(dict, e)) {
2344  av_log(mux, AV_LOG_FATAL, "Unknown submix key %s.\n", e->key);
2345  ret = AVERROR(EINVAL);
2346  goto fail;
2347  }
2348  subtoken = av_strtok(NULL, "|", &subptr);
2349  }
2350  av_freep(&submix_str);
2351 
2352  if (!submix->nb_elements) {
2353  av_log(mux, AV_LOG_ERROR, "No audio elements in submix specification \"%s\"\n", token);
2354  ret = AVERROR(EINVAL);
2355  }
2356  token = av_strtok(NULL, ",", &ptr);
2357  }
2358 
2359 fail:
2360  av_dict_free(&dict);
2361  av_free(submix_str);
2362 
2363  return ret;
2364 }
2365 
2366 static int of_serialize_options(Muxer *mux, void *obj, AVBPrint *bp)
2367 {
2368  char *ptr;
2369  int ret;
2370 
2371  ret = av_opt_serialize(obj, 0, AV_OPT_SERIALIZE_SKIP_DEFAULTS | AV_OPT_SERIALIZE_SEARCH_CHILDREN,
2372  &ptr, '=', ':');
2373  if (ret < 0) {
2374  av_log(mux, AV_LOG_ERROR, "Failed to serialize group\n");
2375  return ret;
2376  }
2377 
2378  av_bprintf(bp, "%s", ptr);
2379  ret = strlen(ptr);
2380  av_free(ptr);
2381 
2382  return ret;
2383 }
2384 
2385 #define SERIALIZE(parent, child) do { \
2386  ret = of_serialize_options(mux, parent->child, bp); \
2387  if (ret < 0) \
2388  return ret; \
2389 } while (0)
2390 
2391 #define SERIALIZE_LOOP_SUBBLOCK(obj) do { \
2392  for (int k = 0; k < obj->nb_subblocks; k++) { \
2393  ret = of_serialize_options(mux, \
2394  av_iamf_param_definition_get_subblock(obj, k), bp); \
2395  if (ret < 0) \
2396  return ret; \
2397  } \
2398 } while (0)
2399 
2400 #define SERIALIZE_LOOP(parent, child, suffix, separator) do { \
2401  for (int j = 0; j < parent->nb_## child ## suffix; j++) { \
2402  av_bprintf(bp, separator#child "="); \
2403  SERIALIZE(parent, child ## suffix[j]); \
2404  } \
2405 } while (0)
2406 
2407 static int64_t get_stream_group_index_from_id(Muxer *mux, int64_t id)
2408 {
2409  AVFormatContext *oc = mux->fc;
2410 
2411  for (unsigned i = 0; i < oc->nb_stream_groups; i++)
2412  if (oc->stream_groups[i]->id == id)
2413  return oc->stream_groups[i]->index;
2414 
2415  return AVERROR(EINVAL);
2416 }
2417 
2418 static int of_map_group(Muxer *mux, AVDictionary **dict, AVBPrint *bp, const char *map)
2419 {
2420  AVStreamGroup *stg;
2421  int ret, file_idx, stream_idx;
2422  char *ptr;
2423 
2424  file_idx = strtol(map, &ptr, 0);
2425  if (file_idx >= nb_input_files || file_idx < 0 || map == ptr) {
2426  av_log(mux, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2427  return AVERROR(EINVAL);
2428  }
2429 
2430  stream_idx = strtol(*ptr == '=' ? ptr + 1 : ptr, &ptr, 0);
2431  if (*ptr || stream_idx >= input_files[file_idx]->ctx->nb_stream_groups || stream_idx < 0) {
2432  av_log(mux, AV_LOG_ERROR, "Invalid input stream group index: %d.\n", stream_idx);
2433  return AVERROR(EINVAL);
2434  }
2435 
2436  stg = input_files[file_idx]->ctx->stream_groups[stream_idx];
2437  ret = of_serialize_options(mux, stg, bp);
2438  if (ret < 0)
2439  return ret;
2440 
2441  ret = av_dict_parse_string(dict, bp->str, "=", ":", 0);
2442  if (ret < 0)
2443  av_log(mux, AV_LOG_ERROR, "Error parsing mapped group specification %s\n", ptr);
2444  av_dict_set_int(dict, "type", stg->type, 0);
2445 
2446  av_bprint_clear(bp);
2447  switch(stg->type) {
2448  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT: {
2449  AVIAMFAudioElement *audio_element = stg->params.iamf_audio_element;
2450 
2451  if (audio_element->demixing_info) {
2452  AVIAMFParamDefinition *demixing_info = audio_element->demixing_info;
2453  av_bprintf(bp, ",demixing=");
2454  SERIALIZE(audio_element, demixing_info);
2455  if (ret && demixing_info->nb_subblocks)
2456  av_bprintf(bp, ":");
2457  SERIALIZE_LOOP_SUBBLOCK(demixing_info);
2458  }
2459  if (audio_element->recon_gain_info) {
2460  AVIAMFParamDefinition *recon_gain_info = audio_element->recon_gain_info;
2461  av_bprintf(bp, ",recon_gain=");
2462  SERIALIZE(audio_element, recon_gain_info);
2463  if (ret && recon_gain_info->nb_subblocks)
2464  av_bprintf(bp, ":");
2465  SERIALIZE_LOOP_SUBBLOCK(recon_gain_info);
2466  }
2467  SERIALIZE_LOOP(audio_element, layer, s, ",");
2468  break;
2469  }
2470  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION: {
2471  AVIAMFMixPresentation *mix = stg->params.iamf_mix_presentation;
2472 
2473  for (int i = 0; i < mix->nb_submixes; i++) {
2474  AVIAMFSubmix *submix = mix->submixes[i];
2475  AVIAMFParamDefinition *output_mix_config = submix->output_mix_config;
2476 
2477  av_bprintf(bp, ",submix=");
2478  SERIALIZE(mix, submixes[i]);
2479  if (ret && output_mix_config->nb_subblocks)
2480  av_bprintf(bp, ":");
2481  SERIALIZE_LOOP_SUBBLOCK(output_mix_config);
2482  for (int j = 0; j < submix->nb_elements; j++) {
2483  AVIAMFSubmixElement *element = submix->elements[j];
2484  AVIAMFParamDefinition *element_mix_config = element->element_mix_config;
2485  int64_t id = get_stream_group_index_from_id(mux, element->audio_element_id);
2486 
2487  if (id < 0) {
2488  av_log(mux, AV_LOG_ERROR, "Invalid or missing stream group index in"
2489  "submix element");
2490  return id;
2491  }
2492 
2493  av_bprintf(bp, "|element=");
2494  SERIALIZE(submix, elements[j]);
2495  if (ret && element_mix_config->nb_subblocks)
2496  av_bprintf(bp, ":");
2497  SERIALIZE_LOOP_SUBBLOCK(element_mix_config);
2498  if (ret)
2499  av_bprintf(bp, ":");
2500  av_bprintf(bp, "stg=%"PRId64, id);
2501  }
2502  SERIALIZE_LOOP(submix, layout, s, "|");
2503  }
2504  break;
2505  }
2506  case AV_STREAM_GROUP_PARAMS_LCEVC:
2507  case AV_STREAM_GROUP_PARAMS_TREF:
2508  case AV_STREAM_GROUP_PARAMS_DOLBY_VISION:
2509  break;
2510  default:
2511  av_log(mux, AV_LOG_ERROR, "Unsupported mapped group type %d.\n", stg->type);
2512  ret = AVERROR(EINVAL);
2513  break;
2514  }
2515  return 0;
2516 }
2517 
2518 static int of_parse_group_token(Muxer *mux, const char *token, char *ptr)
2519 {
2520  AVFormatContext *oc = mux->fc;
2521  AVStreamGroup *stg;
2522  AVDictionary *dict = NULL, *tmp = NULL;
2523  char *mapped_string = NULL;
2524  const AVDictionaryEntry *e;
2525  const AVOption opts[] = {
2526  { "type", "Set group type", offsetof(AVStreamGroup, type), AV_OPT_TYPE_INT,
2527  { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, .unit = "type" },
2528  { "iamf_audio_element", NULL, 0, AV_OPT_TYPE_CONST,
2529  { .i64 = AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT }, .unit = "type" },
2530  { "iamf_mix_presentation", NULL, 0, AV_OPT_TYPE_CONST,
2531  { .i64 = AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION }, .unit = "type" },
2532  { "lcevc", NULL, 0, AV_OPT_TYPE_CONST,
2533  { .i64 = AV_STREAM_GROUP_PARAMS_LCEVC }, .unit = "type" },
2534  { "tref", NULL, 0, AV_OPT_TYPE_CONST,
2535  { .i64 = AV_STREAM_GROUP_PARAMS_TREF }, .unit = "type" },
2536  { NULL },
2537  };
2538  const AVClass class = {
2539  .class_name = "StreamGroupType",
2540  .item_name = av_default_item_name,
2541  .option = opts,
2542  .version = LIBAVUTIL_VERSION_INT,
2543  };
2544  const AVClass *pclass = &class;
2545  int type, ret;
2546 
2547  ret = av_dict_parse_string(&dict, token, "=", ":", AV_DICT_MULTIKEY);
2548  if (ret < 0) {
2549  av_log(mux, AV_LOG_ERROR, "Error parsing group specification %s\n", token);
2550  return ret;
2551  }
2552 
2553  av_dict_copy(&tmp, dict, 0);
2554  e = av_dict_get(dict, "map", NULL, 0);
2555  if (e) {
2556  AVBPrint bp;
2557 
2558  if (ptr) {
2559  av_log(mux, AV_LOG_ERROR, "Unexpected extra parameters when mapping a"
2560  " stream group\n");
2561  ret = AVERROR(EINVAL);
2562  goto end;
2563  }
2564 
2565  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
2566  ret = of_map_group(mux, &tmp, &bp, e->value);
2567  if (ret < 0) {
2568  av_bprint_finalize(&bp, NULL);
2569  goto end;
2570  }
2571 
2572  av_bprint_finalize(&bp, &mapped_string);
2573  ptr = mapped_string;
2574  }
2575 
2576  // "type" is not a user settable AVOption in AVStreamGroup, so handle it here
2577  e = av_dict_get(tmp, "type", NULL, 0);
2578  if (!e) {
2579  av_log(mux, AV_LOG_ERROR, "No type specified for Stream Group in \"%s\"\n", token);
2580  ret = AVERROR(EINVAL);
2581  goto end;
2582  }
2583 
2584  ret = av_opt_eval_int(&pclass, opts, e->value, &type);
2585  if (!ret && type == AV_STREAM_GROUP_PARAMS_NONE)
2586  ret = AVERROR(EINVAL);
2587  if (ret < 0) {
2588  av_log(mux, AV_LOG_ERROR, "Invalid group type \"%s\"\n", e->value);
2589  goto end;
2590  }
2591 
2592  stg = avformat_stream_group_create(oc, type, &tmp);
2593  if (!stg) {
2594  ret = AVERROR(ENOMEM);
2595  goto end;
2596  }
2597 
2598  e = NULL;
2599  while (e = av_dict_get(dict, "st", e, 0)) {
2600  char *endptr;
2601  int64_t idx = strtoll(e->value, &endptr, 0);
2602  if (*endptr || idx < 0 || idx >= oc->nb_streams) {
2603  av_log(mux, AV_LOG_ERROR, "Invalid stream index %"PRId64"\n", idx);
2604  ret = AVERROR(EINVAL);
2605  goto end;
2606  }
2607  ret = avformat_stream_group_add_stream(stg, oc->streams[idx]);
2608  if (ret < 0)
2609  goto end;
2610  OutputStream *ost = mux->of.streams[idx];
2611  if (ost->enc && (type == AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT ||
2612  type == AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION))
2613  ost->enc->flags2 |= AV_CODEC_FLAG2_FIXED_FRAME_SIZE;
2614  }
2615  while (e = av_dict_get(dict, "stg", e, 0)) {
2616  char *endptr;
2617  int64_t idx = strtoll(e->value, &endptr, 0);
2618  if (*endptr || idx < 0 || idx >= oc->nb_stream_groups - 1) {
2619  av_log(mux, AV_LOG_ERROR, "Invalid stream group index %"PRId64"\n", idx);
2620  ret = AVERROR(EINVAL);
2621  goto end;
2622  }
2623  for (unsigned i = 0; i < oc->stream_groups[idx]->nb_streams; i++) {
2624  ret = avformat_stream_group_add_stream(stg, oc->stream_groups[idx]->streams[i]);
2625  if (ret < 0)
2626  goto end;
2627  }
2628  }
2629 
2630  switch(type) {
2631  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
2632  ret = of_parse_iamf_audio_element_layers(mux, stg, ptr);
2633  break;
2634  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
2635  ret = of_parse_iamf_submixes(mux, stg, ptr);
2636  break;
2637  default:
2638  break;
2639  }
2640 
2641  if (ret < 0)
2642  goto end;
2643 
2644  // make sure that nothing but "st" and "stg" entries are left in the dict
2645  e = NULL;
2646  av_dict_set(&tmp, "map", NULL, 0);
2647  av_dict_set(&tmp, "type", NULL, 0);
2648  while (e = av_dict_iterate(tmp, e)) {
2649  if (!strcmp(e->key, "st") || !strcmp(e->key, "stg"))
2650  continue;
2651 
2652  av_log(mux, AV_LOG_FATAL, "Unknown group key %s.\n", e->key);
2653  ret = AVERROR(EINVAL);
2654  goto end;
2655  }
2656 
2657  ret = 0;
2658 end:
2659  av_free(mapped_string);
2660  av_dict_free(&dict);
2661  av_dict_free(&tmp);
2662 
2663  return ret;
2664 }
2665 
2666 static int of_add_groups(Muxer *mux, const OptionsContext *o)
2667 {
2668  /* process manually set groups */
2669  for (int i = 0; i < o->stream_groups.nb_opt; i++) {
2670  const char *token;
2671  char *str, *ptr = NULL;
2672  int ret = 0;
2673 
2674  str = av_strdup(o->stream_groups.opt[i].u.str);
2675  if (!str)
2676  return ret;
2677 
2678  token = av_strtok(str, ",", &ptr);
2679  if (token) {
2680  if (ptr)
2681  ptr += strspn(ptr, " \n\t\r");
2682  ret = of_parse_group_token(mux, token, ptr);
2683  }
2684 
2685  av_free(str);
2686  if (ret < 0)
2687  return ret;
2688  }
2689 
2690  return 0;
2691 }
2692 
2693 static int of_add_programs(Muxer *mux, const OptionsContext *o)
2694 {
2695  AVFormatContext *oc = mux->fc;
2696  /* process manually set programs */
2697  for (int i = 0; i < o->program.nb_opt; i++) {
2698  AVDictionary *dict = NULL;
2699  const AVDictionaryEntry *e;
2700  AVProgram *program;
2701  int ret, progid = i + 1;
2702 
2703  ret = av_dict_parse_string(&dict, o->program.opt[i].u.str, "=", ":",
2704  AV_DICT_MULTIKEY);
2705  if (ret < 0) {
2706  av_log(mux, AV_LOG_ERROR, "Error parsing program specification %s\n",
2707  o->program.opt[i].u.str);
2708  return ret;
2709  }
2710 
2711  e = av_dict_get(dict, "program_num", NULL, 0);
2712  if (e) {
2713  progid = strtol(e->value, NULL, 0);
2714  av_dict_set(&dict, e->key, NULL, 0);
2715  }
2716 
2717  program = av_new_program(oc, progid);
2718  if (!program) {
2719  ret = AVERROR(ENOMEM);
2720  goto fail;
2721  }
2722 
2723  e = av_dict_get(dict, "title", NULL, 0);
2724  if (e) {
2725  av_dict_set(&program->metadata, e->key, e->value, 0);
2726  av_dict_set(&dict, e->key, NULL, 0);
2727  }
2728 
2729  e = NULL;
2730  while (e = av_dict_get(dict, "st", e, 0)) {
2731  int st_num = strtol(e->value, NULL, 0);
2732  av_program_add_stream_index(oc, progid, st_num);
2733  }
2734 
2735  // make sure that nothing but "st" entries are left in the dict
2736  e = NULL;
2737  while (e = av_dict_iterate(dict, e)) {
2738  if (!strcmp(e->key, "st"))
2739  continue;
2740 
2741  av_log(mux, AV_LOG_FATAL, "Unknown program key %s.\n", e->key);
2742  ret = AVERROR(EINVAL);
2743  goto fail;
2744  }
2745 
2746 fail:
2747  av_dict_free(&dict);
2748  if (ret < 0)
2749  return ret;
2750  }
2751 
2752  return 0;
2753 }
2754 
2755 /**
2756  * Parse a metadata specifier passed as 'arg' parameter.
2757  * @param arg metadata string to parse
2758  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2759  * @param index for type c/p, chapter/program index is written here
2760  * @param stream_spec for type s, the stream specifier is written here
2761  */
2762 static int parse_meta_type(void *logctx, const char *arg,
2763  char *type, int *index, const char **stream_spec)
2764 {
2765  if (*arg) {
2766  *type = *arg;
2767  switch (*arg) {
2768  case 'g':
2769  break;
2770  case 's':
2771  if (*(++arg) && *arg != ':') {
2772  av_log(logctx, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
2773  return AVERROR(EINVAL);
2774  }
2775  *stream_spec = *arg == ':' ? arg + 1 : "";
2776  break;
2777  case 'c':
2778  case 'p':
2779  if (*(++arg) == ':')
2780  *index = strtol(++arg, NULL, 0);
2781  break;
2782  default:
2783  av_log(logctx, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2784  return AVERROR(EINVAL);
2785  }
2786  } else
2787  *type = 'g';
2788 
2789  return 0;
2790 }
2791 
2792 static int of_add_metadata(OutputFile *of, AVFormatContext *oc,
2793  const OptionsContext *o)
2794 {
2795  for (int i = 0; i < o->metadata.nb_opt; i++) {
2796  AVDictionary **m;
2797  char type, *val;
2798  const char *stream_spec;
2799  int index = 0, ret = 0;
2800 
2801  val = strchr(o->metadata.opt[i].u.str, '=');
2802  if (!val) {
2803  av_log(of, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2804  o->metadata.opt[i].u.str);
2805  return AVERROR(EINVAL);
2806  }
2807  *val++ = 0;
2808 
2809  ret = parse_meta_type(of, o->metadata.opt[i].specifier, &type, &index, &stream_spec);
2810  if (ret < 0)
2811  return ret;
2812 
2813  if (type == 's') {
2814  for (int j = 0; j < oc->nb_streams; j++) {
2815  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2816  av_dict_set(&oc->streams[j]->metadata, o->metadata.opt[i].u.str, *val ? val : NULL, 0);
2817  } else if (ret < 0)
2818  return ret;
2819  }
2820  } else {
2821  switch (type) {
2822  case 'g':
2823  m = &oc->metadata;
2824  break;
2825  case 'c':
2826  if (index < 0 || index >= oc->nb_chapters) {
2827  av_log(of, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2828  return AVERROR(EINVAL);
2829  }
2830  m = &oc->chapters[index]->metadata;
2831  break;
2832  case 'p':
2833  if (index < 0 || index >= oc->nb_programs) {
2834  av_log(of, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2835  return AVERROR(EINVAL);
2836  }
2837  m = &oc->programs[index]->metadata;
2838  break;
2839  default:
2840  av_log(of, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata.opt[i].specifier);
2841  return AVERROR(EINVAL);
2842  }
2843  av_dict_set(m, o->metadata.opt[i].u.str, *val ? val : NULL, 0);
2844  }
2845  }
2846 
2847  return 0;
2848 }
2849 
2850 static int copy_chapters(InputFile *ifile, OutputFile *ofile, AVFormatContext *os,
2851  int copy_metadata)
2852 {
2853  AVFormatContext *is = ifile->ctx;
2854  AVChapter **tmp;
2855 
2856  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2857  if (!tmp)
2858  return AVERROR(ENOMEM);
2859  os->chapters = tmp;
2860 
2861  for (int i = 0; i < is->nb_chapters; i++) {
2862  AVChapter *in_ch = is->chapters[i], *out_ch;
2863  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2864  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2865  AV_TIME_BASE_Q, in_ch->time_base);
2866  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2867  av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2868 
2869 
2870  if (in_ch->end < ts_off)
2871  continue;
2872  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2873  break;
2874 
2875  out_ch = av_mallocz(sizeof(AVChapter));
2876  if (!out_ch)
2877  return AVERROR(ENOMEM);
2878 
2879  out_ch->id = in_ch->id;
2880  out_ch->time_base = in_ch->time_base;
2881  out_ch->start = FFMAX(0, in_ch->start - ts_off);
2882  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2883 
2884  if (copy_metadata)
2885  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2886 
2887  os->chapters[os->nb_chapters++] = out_ch;
2888  }
2889  return 0;
2890 }
2891 
2892 static int copy_metadata(Muxer *mux, AVFormatContext *ic,
2893  const char *outspec, const char *inspec,
2894  int *metadata_global_manual, int *metadata_streams_manual,
2895  int *metadata_chapters_manual)
2896 {
2897  AVFormatContext *oc = mux->fc;
2898  AVDictionary **meta_in = NULL;
2899  AVDictionary **meta_out = NULL;
2900  int i, ret = 0;
2901  char type_in, type_out;
2902  const char *istream_spec = NULL, *ostream_spec = NULL;
2903  int idx_in = 0, idx_out = 0;
2904 
2905  ret = parse_meta_type(mux, inspec, &type_in, &idx_in, &istream_spec);
2906  if (ret >= 0)
2907  ret = parse_meta_type(mux, outspec, &type_out, &idx_out, &ostream_spec);
2908  if (ret < 0)
2909  return ret;
2910 
2911  if (type_in == 'g' || type_out == 'g' || (!*outspec && !ic))
2912  *metadata_global_manual = 1;
2913  if (type_in == 's' || type_out == 's' || (!*outspec && !ic))
2914  *metadata_streams_manual = 1;
2915  if (type_in == 'c' || type_out == 'c' || (!*outspec && !ic))
2916  *metadata_chapters_manual = 1;
2917 
2918  /* ic is NULL when just disabling automatic mappings */
2919  if (!ic)
2920  return 0;
2921 
2922 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2923  if ((index) < 0 || (index) >= (nb_elems)) {\
2924  av_log(mux, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
2925  (desc), (index));\
2926  return AVERROR(EINVAL);\
2927  }
2928 
2929 #define SET_DICT(type, meta, context, index)\
2930  switch (type) {\
2931  case 'g':\
2932  meta = &context->metadata;\
2933  break;\
2934  case 'c':\
2935  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
2936  meta = &context->chapters[index]->metadata;\
2937  break;\
2938  case 'p':\
2939  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
2940  meta = &context->programs[index]->metadata;\
2941  break;\
2942  case 's':\
2943  break; /* handled separately below */ \
2944  default: av_assert0(0);\
2945  }\
2946 
2947  SET_DICT(type_in, meta_in, ic, idx_in);
2948  SET_DICT(type_out, meta_out, oc, idx_out);
2949 
2950  /* for input streams choose first matching stream */
2951  if (type_in == 's') {
2952  for (i = 0; i < ic->nb_streams; i++) {
2953  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
2954  meta_in = &ic->streams[i]->metadata;
2955  break;
2956  } else if (ret < 0)
2957  return ret;
2958  }
2959  if (!meta_in) {
2960  av_log(mux, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
2961  return AVERROR(EINVAL);
2962  }
2963  }
2964 
2965  if (type_out == 's') {
2966  for (i = 0; i < oc->nb_streams; i++) {
2967  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
2968  meta_out = &oc->streams[i]->metadata;
2969  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2970  } else if (ret < 0)
2971  return ret;
2972  }
2973  } else
2974  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2975 
2976  return 0;
2977 }
2978 
2979 #define REENC_MASK(type) (1u << (type))
2980 #define REENC_AUDIO_ONLY REENC_MASK(AVMEDIA_TYPE_AUDIO)
2981 #define REENC_VIDEO_ONLY REENC_MASK(AVMEDIA_TYPE_VIDEO)
2982 #define REENC_ANY (REENC_AUDIO_ONLY | REENC_VIDEO_ONLY)
2983 
2984 static const struct {
2985  const char *key;
2986  int flags;
2987  unsigned reenc_mask; /* 0 = always delete; non-zero = bit-mask of
2988  * REENC_* values whose re-encoding triggers
2989  * deletion of this key */
2990 } reenc_delete_keys[] = {
2991  // Note: "encoder" is intentionally absent — set_encoder_id() stamps it
2992  // after copy_meta() runs, so it always reflects the current encoder.
2993 
2994  // iTunes gapless playback: encoder-specific sample counts and padding;
2995  // gapless_playback is the M4A/MOV equivalent of iTunPGAP
2996  { "iTunPGAP", 0, REENC_AUDIO_ONLY },
2997  { "comment-iTunPGAP-eng", 0, REENC_AUDIO_ONLY },
2998  { "iTunSMPB", 0, REENC_AUDIO_ONLY },
2999  { "comment-iTunSMPB-eng", 0, REENC_AUDIO_ONLY },
3000  { "gapless_playback", 0, REENC_AUDIO_ONLY },
3001  // iTunes Sound Check: peak amplitude computed from the original waveform
3002  { "iTunNORM", 0, REENC_AUDIO_ONLY },
3003  { "comment-iTunNORM-eng", 0, REENC_AUDIO_ONLY },
3004  // encoding provenance: describe the original encoder, not the new one
3005  { "encoded_by", 0, REENC_ANY },
3006  { "encoding_tool", 0, REENC_ANY },
3007  // MOV/MP4 stream: vendor 4CC identifies the original encoder
3008  { "vendor_id", 0, REENC_ANY },
3009  // Matroska stream stats written by mkvmerge; all are invalidated by re-encoding
3010  { "BPS", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3011  { "DURATION", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3012  { "NUMBER_OF_BYTES", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3013  { "NUMBER_OF_FRAMES", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3014  { "_STATISTICS_TAGS", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3015  { "_STATISTICS_WRITING_APP", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3016  { "_STATISTICS_WRITING_DATE_UTC", AV_DICT_IGNORE_SUFFIX, REENC_ANY },
3017 
3018  // MOV/MP4: source container brand written by the demuxer; muxer ignores
3019  // these keys and writes its own ftyp, so they always describe the source file
3020  { "major_brand", 0, 0 },
3021  { "minor_version", 0, 0 },
3022  { "compatible_brands", 0, 0 },
3023  { NULL }
3024 };
3025 
3026 static int meta_spec_matches(void *log_ctx, AVFormatContext *oc, AVStream *st,
3027  const char *spec)
3028 {
3029  char type;
3030  int index = 0;
3031  const char *stream_spec = NULL;
3032 
3033  if (parse_meta_type(log_ctx, spec, &type, &index, &stream_spec) < 0)
3034  return 0;
3035 
3036  if (*spec) {
3037  if (type == 'g' && st)
3038  return 0;
3039  if (type == 's') {
3040  int ret;
3041  if (!st)
3042  return 0;
3043  ret = check_stream_specifier(oc, st, stream_spec);
3044  return ret < 0 ? ret : ret > 0;
3045  }
3046  if (type == 'c' || type == 'p')
3047  return 0;
3048  }
3049  return 1;
3050 }
3051 
3052 static int reenc_delete_metadata_key(const OptionsContext *o, void *log_ctx,
3053  AVFormatContext *oc, AVStream *st,
3054  const char *family, const char *key, int flags)
3055 {
3056  for (int i = 0; i < o->keep_metadata.nb_opt; i++) {
3057  int ret = meta_spec_matches(log_ctx, oc, st, o->keep_metadata.opt[i].specifier);
3058  if (ret < 0)
3059  return ret;
3060  if (!ret)
3061  continue;
3062  const char *keep = o->keep_metadata.opt[i].u.str;
3063  if (flags & AV_DICT_IGNORE_SUFFIX) {
3064  /* accept the unsuffixed family name (e.g. NUMBER_OF_BYTES keeps
3065  * NUMBER_OF_BYTES-eng) or the exact matched key; an arbitrary
3066  * prefix like NUMBER does not match NUMBER_OF_BYTES-eng */
3067  if (!strcmp(keep, family) || !strcmp(keep, key))
3068  return 0;
3069  } else {
3070  if (!strcmp(key, keep))
3071  return 0;
3072  }
3073  }
3074  for (int i = 0; i < o->metadata.nb_opt; i++) {
3075  int ret;
3076  /* plain -metadata (empty specifier) applies to global metadata only,
3077  * matching of_add_metadata(); don't let it suppress stream-level pruning */
3078  if (!*o->metadata.opt[i].specifier && st)
3079  continue;
3080  ret = meta_spec_matches(log_ctx, oc, st, o->metadata.opt[i].specifier);
3081  if (ret < 0)
3082  return ret;
3083  if (!ret)
3084  continue;
3085  size_t klen = strcspn(o->metadata.opt[i].u.str, "=");
3086  if (!strncmp(key, o->metadata.opt[i].u.str, klen) && key[klen] == '\0')
3087  return 0;
3088  }
3089  return 1;
3090 }
3091 
3092 static int reenc_delete_stale_metadata(const OptionsContext *o, void *log_ctx,
3093  AVFormatContext *oc, AVStream *st,
3094  AVDictionary **dict, const char *kind,
3095  unsigned reenc_mask)
3096 {
3097  for (int i = 0; reenc_delete_keys[i].key; i++) {
3098  const char *key = reenc_delete_keys[i].key;
3099  int flags = reenc_delete_keys[i].flags;
3100  const AVDictionaryEntry *e;
3101  int ret;
3102 
3103  if (reenc_delete_keys[i].reenc_mask && !(reenc_delete_keys[i].reenc_mask & reenc_mask))
3104  continue;
3105 
3106  e = NULL;
3107  while ((e = av_dict_get(*dict, key, e, flags | AV_DICT_MATCH_CASE))) {
3108  ret = reenc_delete_metadata_key(o, log_ctx, oc, st, key, e->key, flags);
3109  if (ret < 0)
3110  return ret;
3111  if (!ret)
3112  continue;
3113  if (reenc_mask & reenc_delete_keys[i].reenc_mask)
3114  av_log(log_ctx, AV_LOG_WARNING,
3115  "Discarding %s metadata '%s' because %s stream is being "
3116  "re-encoded. Use '-keep_metadata %s' to keep it.\n",
3117  kind, e->key,
3118  !strcmp(kind, "stream") ? "the" : "a", e->key);
3119  av_dict_set(dict, e->key, NULL, 0);
3120  e = NULL;
3121  }
3122  }
3123  return 0;
3124 }
3125 
3126 static int copy_meta(Muxer *mux, const OptionsContext *o)
3127 {
3128  OutputFile *of = &mux->of;
3129  AVFormatContext *oc = mux->fc;
3130  int chapters_input_file = o->chapters_input_file;
3131  int metadata_global_manual = 0;
3132  int metadata_streams_manual = 0;
3133  int metadata_chapters_manual = 0;
3134  int ret;
3135 
3136  /* copy metadata */
3137  for (int i = 0; i < o->metadata_map.nb_opt; i++) {
3138  char *p;
3139  int in_file_index = strtol(o->metadata_map.opt[i].u.str, &p, 0);
3140 
3141  if (in_file_index >= nb_input_files) {
3142  av_log(mux, AV_LOG_FATAL, "Invalid input file index %d while "
3143  "processing metadata maps\n", in_file_index);
3144  return AVERROR(EINVAL);
3145  }
3146  ret = copy_metadata(mux,
3147  in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL,
3148  o->metadata_map.opt[i].specifier, *p ? p + 1 : p,
3149  &metadata_global_manual, &metadata_streams_manual,
3150  &metadata_chapters_manual);
3151  if (ret < 0)
3152  return ret;
3153  }
3154 
3155  /* copy chapters */
3156  if (chapters_input_file >= nb_input_files) {
3157  if (chapters_input_file == INT_MAX) {
3158  /* copy chapters from the first input file that has them*/
3159  chapters_input_file = -1;
3160  for (int i = 0; i < nb_input_files; i++)
3161  if (input_files[i]->ctx->nb_chapters) {
3162  chapters_input_file = i;
3163  break;
3164  }
3165  } else {
3166  av_log(mux, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3167  chapters_input_file);
3168  return AVERROR(EINVAL);
3169  }
3170  }
3171  if (chapters_input_file >= 0)
3172  copy_chapters(input_files[chapters_input_file], of, oc,
3173  !metadata_chapters_manual);
3174 
3175  /* copy global metadata by default */
3176  if (!metadata_global_manual && nb_input_files){
3177  av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
3178  AV_DICT_DONT_OVERWRITE);
3179  if (of->recording_time != INT64_MAX)
3180  av_dict_set(&oc->metadata, "duration", NULL, 0);
3181  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
3182  av_dict_set(&oc->metadata, "company_name", NULL, 0);
3183  av_dict_set(&oc->metadata, "product_name", NULL, 0);
3184  av_dict_set(&oc->metadata, "product_version", NULL, 0);
3185 
3186  }
3187  for (int i = 0; i < o->keep_metadata.nb_opt; i++) {
3188  char type;
3189  int index = 0;
3190  const char *stream_spec = NULL;
3191  const char *spec = o->keep_metadata.opt[i].specifier;
3192  ret = parse_meta_type(mux, spec, &type, &index, &stream_spec);
3193  if (ret < 0)
3194  return ret;
3195  if (type == 'c' || type == 'p') {
3196  av_log(mux, AV_LOG_WARNING,
3197  "-keep_metadata:%s: chapter and program metadata filtering "
3198  "is not supported and will be ignored.\n", spec);
3199  } else if (type == 's') {
3200  for (int j = 0; j < oc->nb_streams; j++) {
3201  ret = check_stream_specifier(oc, oc->streams[j], stream_spec);
3202  if (ret < 0)
3203  return ret;
3204  }
3205  }
3206  }
3207 
3208  /* reenc_mask keys only apply when an audio/video stream is re-encoded;
3209  * subtitle/attachment re-encodes do not affect format-level tags.
3210  * Runs unconditionally so -map_metadata does not bypass the pruning. */
3211  {
3212  unsigned reenc_mask = 0;
3213  for (int i = 0; i < of->nb_streams; i++) {
3214  OutputStream *ost = of->streams[i];
3215  if (ost->enc)
3216  reenc_mask |= REENC_MASK(ost->st->codecpar->codec_type);
3217  }
3218  ret = reenc_delete_stale_metadata(o, mux, oc, NULL, &oc->metadata, "format", reenc_mask);
3219  if (ret < 0)
3220  return ret;
3221  }
3222  if (!metadata_streams_manual)
3223  for (int i = 0; i < of->nb_streams; i++) {
3224  OutputStream *ost = of->streams[i];
3225 
3226  if (!ost->ist) /* this is true e.g. for attached files */
3227  continue;
3228  av_dict_copy(&ost->st->metadata, ost->ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3229  }
3230  /* runs unconditionally so -map_metadata does not bypass the pruning;
3231  * applies to all output streams, including filter outputs without ost->ist */
3232  for (int i = 0; i < of->nb_streams; i++) {
3233  OutputStream *ost = of->streams[i];
3234 
3235  ret = reenc_delete_stale_metadata(o, ost, oc, ost->st, &ost->st->metadata, "stream",
3236  ost->enc ? REENC_MASK(ost->st->codecpar->codec_type) : 0);
3237  if (ret < 0)
3238  return ret;
3239  }
3240 
3241  return 0;
3242 }
3243 
3244 static int set_dispositions(Muxer *mux, const OptionsContext *o)
3245 {
3246  OutputFile *of = &mux->of;
3247  AVFormatContext *ctx = mux->fc;
3248 
3249  // indexed by type+1, because AVMEDIA_TYPE_UNKNOWN=-1
3250  int nb_streams[AVMEDIA_TYPE_NB + 1] = { 0 };
3251  int have_default[AVMEDIA_TYPE_NB + 1] = { 0 };
3252  int have_manual = 0;
3253  int ret = 0;
3254 
3255  const char **dispositions;
3256 
3257  dispositions = av_calloc(ctx->nb_streams, sizeof(*dispositions));
3258  if (!dispositions)
3259  return AVERROR(ENOMEM);
3260 
3261  // first, copy the input dispositions
3262  for (int i = 0; i < ctx->nb_streams; i++) {
3263  OutputStream *ost = of->streams[i];
3264 
3265  nb_streams[ost->type + 1]++;
3266 
3267  opt_match_per_stream_str(ost, &o->disposition, ctx, ost->st, &dispositions[i]);
3268 
3269  have_manual |= !!dispositions[i];
3270 
3271  if (ost->ist) {
3272  ost->st->disposition = ost->ist->st->disposition;
3273 
3274  if (ost->st->disposition & AV_DISPOSITION_DEFAULT)
3275  have_default[ost->type + 1] = 1;
3276  }
3277  }
3278 
3279  if (have_manual) {
3280  // process manually set dispositions - they override the above copy
3281  for (int i = 0; i < ctx->nb_streams; i++) {
3282  OutputStream *ost = of->streams[i];
3283  const char *disp = dispositions[i];
3284 
3285  if (!disp)
3286  continue;
3287 
3288  ret = av_opt_set(ost->st, "disposition", disp, 0);
3289  if (ret < 0)
3290  goto finish;
3291  }
3292  } else {
3293  // For each media type with more than one stream, find a suitable stream to
3294  // mark as default, unless one is already marked default.
3295  // "Suitable" means the first of that type, skipping attached pictures.
3296  for (int i = 0; i < ctx->nb_streams; i++) {
3297  OutputStream *ost = of->streams[i];
3298  enum AVMediaType type = ost->type;
3299 
3300  if (nb_streams[type + 1] < 2 || have_default[type + 1] ||
3301  ost->st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3302  continue;
3303 
3304  ost->st->disposition |= AV_DISPOSITION_DEFAULT;
3305  have_default[type + 1] = 1;
3306  }
3307  }
3308 
3309 finish:
3310  av_freep(&dispositions);
3311 
3312  return ret;
3313 }
3314 
3315 static const char *const forced_keyframes_const_names[] = {
3316  "n",
3317  "n_forced",
3318  "prev_forced_n",
3319  "prev_forced_t",
3320  "t",
3321  NULL
3322 };
3323 
3324 static int compare_int64(const void *a, const void *b)
3325 {
3326  return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
3327 }
3328 
3329 static int parse_forced_key_frames(void *log, KeyframeForceCtx *kf,
3330  const Muxer *mux, const char *spec)
3331 {
3332  int n = 1, i, ret, size, index = 0;
3333  int64_t t, *pts;
3334 
3335  for (const char *p = spec; *p; p++)
3336  if (*p == ',')
3337  n++;
3338  size = n;
3339 
3340  char *spec_dup = av_strdup(spec);
3341  pts = av_malloc_array(size, sizeof(*pts));
3342  if (!spec_dup || !pts) {
3343  ret = AVERROR(ENOMEM);
3344  goto fail;
3345  }
3346 
3347  char *p = spec_dup;
3348  for (i = 0; i < n; i++) {
3349  char *next = strchr(p, ',');
3350 
3351  if (next)
3352  *next++ = 0;
3353 
3354  if (strstr(p, "chapters") == p) {
3355  AVChapter * const *ch = mux->fc->chapters;
3356  unsigned int nb_ch = mux->fc->nb_chapters;
3357  int j;
3358 
3359  if (nb_ch > INT_MAX - size) {
3360  ret = AVERROR(ERANGE);
3361  goto fail;
3362  }
3363  size += nb_ch - 1;
3364  pts = av_realloc_f(pts, size, sizeof(*pts));
3365  if (!pts) {
3366  ret = AVERROR(ENOMEM);
3367  goto fail;
3368  }
3369 
3370  if (p[8]) {
3371  ret = av_parse_time(&t, p + 8, 1);
3372  if (ret < 0) {
3373  av_log(log, AV_LOG_ERROR,
3374  "Invalid chapter time offset: %s\n", p + 8);
3375  goto fail;
3376  }
3377  } else
3378  t = 0;
3379 
3380  for (j = 0; j < nb_ch; j++) {
3381  const AVChapter *c = ch[j];
3382  av_assert1(index < size);
3383  pts[index++] = av_rescale_q(c->start, c->time_base,
3384  AV_TIME_BASE_Q) + t;
3385  }
3386 
3387  } else {
3388  av_assert1(index < size);
3389  ret = av_parse_time(&t, p, 1);
3390  if (ret < 0) {
3391  av_log(log, AV_LOG_ERROR, "Invalid keyframe time: %s\n", p);
3392  goto fail;
3393  }
3394 
3395  pts[index++] = t;
3396  }
3397 
3398  p = next;
3399  }
3400 
3401  av_assert0(index == size);
3402  qsort(pts, size, sizeof(*pts), compare_int64);
3403  kf->nb_pts = size;
3404  kf->pts = pts;
3405 
3406  av_freep(&spec_dup);
3407 
3408  return 0;
3409 fail:
3410  av_freep(&spec_dup);
3411  av_freep(&pts);
3412  return ret;
3413 }
3414 
3415 static int process_forced_keyframes(Muxer *mux, const OptionsContext *o)
3416 {
3417  for (int i = 0; i < mux->of.nb_streams; i++) {
3418  OutputStream *ost = mux->of.streams[i];
3419  const char *forced_keyframes = NULL;
3420 
3421  opt_match_per_stream_str(ost, &o->forced_key_frames,
3422  mux->fc, ost->st, &forced_keyframes);
3423 
3424  if (!(ost->type == AVMEDIA_TYPE_VIDEO &&
3425  ost->enc && forced_keyframes))
3426  continue;
3427 
3428  if (!strncmp(forced_keyframes, "expr:", 5)) {
3429  int ret = av_expr_parse(&ost->kf.pexpr, forced_keyframes + 5,
3430  forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3431  if (ret < 0) {
3432  av_log(ost, AV_LOG_ERROR,
3433  "Invalid force_key_frames expression '%s'\n", forced_keyframes + 5);
3434  return ret;
3435  }
3436  ost->kf.expr_const_values[FKF_N] = 0;
3437  ost->kf.expr_const_values[FKF_N_FORCED] = 0;
3438  ost->kf.expr_const_values[FKF_PREV_FORCED_N] = NAN;
3439  ost->kf.expr_const_values[FKF_PREV_FORCED_T] = NAN;
3440 
3441  // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3442  // parse it only for static kf timings
3443  } else if (!strcmp(forced_keyframes, "source")) {
3444  ost->kf.type = KF_FORCE_SOURCE;
3445  } else if (!strcmp(forced_keyframes, "scd_metadata")) {
3446  ost->kf.type = KF_FORCE_SCD_METADATA;
3447  } else {
3448  int ret = parse_forced_key_frames(ost, &ost->kf, mux, forced_keyframes);
3449  if (ret < 0)
3450  return ret;
3451  }
3452  }
3453 
3454  return 0;
3455 }
3456 
3457 static const char *output_file_item_name(void *obj)
3458 {
3459  const Muxer *mux = obj;
3460 
3461  return mux->log_name;
3462 }
3463 
3464 static const AVClass output_file_class = {
3465  .class_name = "OutputFile",
3466  .version = LIBAVUTIL_VERSION_INT,
3467  .item_name = output_file_item_name,
3468  .category = AV_CLASS_CATEGORY_MUXER,
3469 };
3470 
3471 static Muxer *mux_alloc(void)
3472 {
3473  Muxer *mux = allocate_array_elem(&output_files, sizeof(*mux), &nb_output_files);
3474 
3475  if (!mux)
3476  return NULL;
3477 
3478  mux->of.class = &output_file_class;
3479  mux->of.index = nb_output_files - 1;
3480 
3481  snprintf(mux->log_name, sizeof(mux->log_name), "out#%d", mux->of.index);
3482 
3483  return mux;
3484 }
3485 
3486 int of_open(const OptionsContext *o, const char *filename, Scheduler *sch)
3487 {
3488  Muxer *mux;
3489  AVFormatContext *oc;
3490  int err;
3491  OutputFile *of;
3492 
3493  int64_t recording_time = o->recording_time;
3494  int64_t stop_time = o->stop_time;
3495 
3496  mux = mux_alloc();
3497  if (!mux)
3498  return AVERROR(ENOMEM);
3499 
3500  of = &mux->of;
3501 
3502  if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
3503  stop_time = INT64_MAX;
3504  av_log(mux, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
3505  }
3506 
3507  if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
3508  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
3509  if (stop_time <= start_time) {
3510  av_log(mux, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
3511  return AVERROR(EINVAL);
3512  } else {
3513  recording_time = stop_time - start_time;
3514  }
3515  }
3516 
3517  if (recording_time < 0) {
3518  av_log(mux, AV_LOG_ERROR, "-t value must be non-negative; aborting.\n");
3519  return AVERROR(EINVAL);
3520  }
3521 
3522  of->recording_time = recording_time;
3523  of->start_time = o->start_time;
3524 
3525  mux->limit_filesize = o->limit_filesize;
3526  av_dict_copy(&mux->opts, o->g->format_opts, 0);
3527 
3528  if (!strcmp(filename, "-"))
3529  filename = "pipe:";
3530 
3531  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3532  if (!oc) {
3533  av_log(mux, AV_LOG_FATAL, "Error initializing the muxer for %s: %s\n",
3534  filename, av_err2str(err));
3535  return err;
3536  }
3537  mux->fc = oc;
3538 
3539  av_strlcat(mux->log_name, "/", sizeof(mux->log_name));
3540  av_strlcat(mux->log_name, oc->oformat->name, sizeof(mux->log_name));
3541 
3542 
3543  if (recording_time != INT64_MAX)
3544  oc->duration = recording_time;
3545 
3546  oc->interrupt_callback = int_cb;
3547 
3548  if (o->bitexact) {
3549  oc->flags |= AVFMT_FLAG_BITEXACT;
3550  of->bitexact = 1;
3551  } else {
3552  of->bitexact = check_opt_bitexact(oc, mux->opts, "fflags",
3553  AVFMT_FLAG_BITEXACT);
3554  }
3555 
3556  err = sch_add_mux(sch, muxer_thread, mux_check_init, mux,
3557  !strcmp(oc->oformat->name, "rtp"), o->thread_queue_size);
3558  if (err < 0)
3559  return err;
3560  mux->sch = sch;
3561  mux->sch_idx = err;
3562 
3563  /* create all output streams for this file */
3564  err = create_streams(mux, o);
3565  if (err < 0)
3566  return err;
3567 
3568  /* check if all codec options have been used */
3569  err = check_avoptions_used(o->g->codec_opts, mux->enc_opts_used, mux, 0);
3570  av_dict_free(&mux->enc_opts_used);
3571  if (err < 0)
3572  return err;
3573 
3574  /* check filename in case of an image number is expected */
3575  if (oc->oformat->flags & AVFMT_NEEDNUMBER && !av_filename_number_test(oc->url)) {
3576  av_log(mux, AV_LOG_FATAL,
3577  "Output filename '%s' does not contain a numeric pattern like "
3578  "'%%d', which is required by output format '%s'.\n",
3579  oc->url, oc->oformat->name);
3580  return AVERROR(EINVAL);
3581  }
3582 
3583  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3584  /* test if it already exists to avoid losing precious files */
3585  err = assert_file_overwrite(filename);
3586  if (err < 0)
3587  return err;
3588 
3589  /* open the file */
3590  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3591  &oc->interrupt_callback,
3592  &mux->opts)) < 0) {
3593  av_log(mux, AV_LOG_FATAL, "Error opening output %s: %s\n",
3594  filename, av_err2str(err));
3595  return err;
3596  }
3597  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename)) {
3598  err = assert_file_overwrite(filename);
3599  if (err < 0)
3600  return err;
3601  }
3602 
3603  if (o->mux_preload) {
3604  av_dict_set_int(&mux->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
3605  }
3606  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3607 
3608  /* copy metadata and chapters from input files */
3609  err = copy_meta(mux, o);
3610  if (err < 0)
3611  return err;
3612 
3613  err = of_add_groups(mux, o);
3614  if (err < 0)
3615  return err;
3616 
3617  err = of_add_programs(mux, o);
3618  if (err < 0)
3619  return err;
3620 
3621  err = of_add_metadata(of, oc, o);
3622  if (err < 0)
3623  return err;
3624 
3625  err = set_dispositions(mux, o);
3626  if (err < 0) {
3627  av_log(mux, AV_LOG_FATAL, "Error setting output stream dispositions\n");
3628  return err;
3629  }
3630 
3631  // parse forced keyframe specifications;
3632  // must be done after chapters are created
3633  err = process_forced_keyframes(mux, o);
3634  if (err < 0) {
3635  av_log(mux, AV_LOG_FATAL, "Error processing forced keyframes\n");
3636  return err;
3637  }
3638 
3639  err = setup_sync_queues(mux, oc, o->shortest_buf_duration * AV_TIME_BASE,
3640  o->shortest);
3641  if (err < 0) {
3642  av_log(mux, AV_LOG_FATAL, "Error setting up output sync queues\n");
3643  return err;
3644  }
3645 
3646  of->url = filename;
3647 
3648  /* initialize streamcopy streams. */
3649  for (int i = 0; i < of->nb_streams; i++) {
3650  OutputStream *ost = of->streams[i];
3651 
3652  if (!ost->enc) {
3653  err = of_stream_init(of, ost, NULL);
3654  if (err < 0)
3655  return err;
3656  }
3657  }
3658 
3659  return 0;
3660 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:604
formats
formats
Definition: signature.h:47
av_strdup
#define av_strdup(s)
Definition: ops_static.c:55
KeyframeForceCtx::pts
int64_t * pts
Definition: ffmpeg.h:598
MuxStream::ost
OutputStream ost
Definition: ffmpeg_mux.h:37
iamf.h
fopen_utf8
static FILE * fopen_utf8(const char *path, const char *mode)
Definition: fopen_utf8.h:66
map_manual
static int map_manual(Muxer *mux, const OptionsContext *o, const StreamMap *map)
Definition: ffmpeg_mux_init.c:1767
SYNC_QUEUE_PACKETS
@ SYNC_QUEUE_PACKETS
Definition: sync_queue.h:29
AVCodec
AVCodec.
Definition: codec.h:175
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:568
av_codec_get_id
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
MuxStream::copy_initial_nonkeyframes
int copy_initial_nonkeyframes
Definition: ffmpeg_mux.h:81
MuxStream::sch_idx_enc
int sch_idx_enc
Definition: ffmpeg_mux.h:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:371
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
InputFile::start_time
int64_t start_time
Definition: ffmpeg.h:522
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:71
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
Muxer::fc
AVFormatContext * fc
Definition: ffmpeg_mux.h:98
AVFormatContext::stream_groups
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
Definition: avformat.h:1420
name
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
Definition: writing_filters.txt:88
OptionsContext::stop_time
int64_t stop_time
Definition: ffmpeg.h:179
ost_get_filters
static int ost_get_filters(const OptionsContext *o, AVFormatContext *oc, OutputStream *ost, char **dst)
Definition: ffmpeg_mux_init.c:416
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1178
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:456
program
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
Definition: undefined.txt:6
OutputFilter::graph
struct FilterGraph * graph
Definition: ffmpeg.h:378
FKF_PREV_FORCED_T
@ FKF_PREV_FORCED_T
Definition: ffmpeg.h:539
InputFile::nb_stream_groups
int nb_stream_groups
Definition: ffmpeg.h:532
OptionsContext::force_fps
SpecifierOptList force_fps
Definition: ffmpeg.h:204
AVCodecContext::alpha_mode
enum AVAlphaMode alpha_mode
Indicates how the alpha channel of the video is represented.
Definition: avcodec.h:1937
OptionsContext::forced_key_frames
SpecifierOptList forced_key_frames
Definition: ffmpeg.h:202
ist_use
int ist_use(InputStream *ist, int decoding_needed, const ViewSpecifier *vs, SchedulerNode *src)
Definition: ffmpeg_demux.c:1057
VSYNC_VFR
@ VSYNC_VFR
Definition: ffmpeg.h:60
mix
static int mix(int c0, int c1)
Definition: 4xm.c:717
ms_from_ost
static MuxStream * ms_from_ost(OutputStream *ost)
Definition: ffmpeg_mux.h:123
AVOutputFormat::name
const char * name
Definition: avformat.h:527
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1296
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
AVERROR
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
nb_input_files
int nb_input_files
Definition: ffmpeg.c:109
opt.h
flag
int flag
Definition: cpu.c:40
of_serialize_options
static int of_serialize_options(Muxer *mux, void *obj, AVBPrint *bp)
Definition: ffmpeg_mux_init.c:2366
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:53
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1194
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
AV_STREAM_GROUP_PARAMS_LCEVC
@ AV_STREAM_GROUP_PARAMS_LCEVC
Definition: avformat.h:1151
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:671
MuxStream::sch_idx
int sch_idx
Definition: ffmpeg_mux.h:55
KF_FORCE_SCD_METADATA
@ KF_FORCE_SCD_METADATA
Definition: ffmpeg.h:589
AVSTREAM_EVENT_FLAG_NEW_PACKETS
#define AVSTREAM_EVENT_FLAG_NEW_PACKETS
Definition: avformat.h:890
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: cmdutils.c:1605
ENC_STATS_PTS
@ ENC_STATS_PTS
Definition: ffmpeg.h:555
OutputFilter::apad
char * apad
Definition: ffmpeg.h:391
Muxer::sch_stream_idx
int * sch_stream_idx
Definition: ffmpeg_mux.h:104
ENC_STATS_FRAME_NUM_IN
@ ENC_STATS_FRAME_NUM_IN
Definition: ffmpeg.h:552
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:565
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1040
FKF_PREV_FORCED_N
@ FKF_PREV_FORCED_N
Definition: ffmpeg.h:538
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1433
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:49
Muxer::nb_sch_stream_idx
int nb_sch_stream_idx
Definition: ffmpeg_mux.h:105
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
enc_open
int enc_open(void *opaque, const AVFrame *frame)
Definition: ffmpeg_enc.c:424
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3460
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:501
av_iamf_param_definition_alloc
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.
Definition: iamf.c:159
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:692
ENC_STATS_DTS
@ ENC_STATS_DTS
Definition: ffmpeg.h:559
sq_limit_frames
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.
Definition: sync_queue.c:628
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
AV_CODEC_CONFIG_SAMPLE_RATE
@ AV_CODEC_CONFIG_SAMPLE_RATE
int, terminated by 0
Definition: avcodec.h:2575
of_parse_iamf_audio_element_layers
static int of_parse_iamf_audio_element_layers(Muxer *mux, AVStreamGroup *stg, char *ptr)
Definition: ffmpeg_mux_init.c:2161
KeyframeForceCtx::nb_pts
int nb_pts
Definition: ffmpeg.h:599
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:213
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:498
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
InputStream::user_set_discard
int user_set_discard
Definition: ffmpeg.h:474
OptionsContext::bits_per_raw_sample
SpecifierOptList bits_per_raw_sample
Definition: ffmpeg.h:238
parse_and_set_vsync
int parse_and_set_vsync(const char *arg, enum VideoSyncMethod *vsync_var, int file_idx, int st_idx)
Definition: ffmpeg_opt.c:359
ENC_STATS_AVG_BITRATE
@ ENC_STATS_AVG_BITRATE
Definition: ffmpeg.h:565
AVCodecContext::intra_matrix
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
Definition: avcodec.h:960
OptionsContext::audio_ch_layouts
SpecifierOptList audio_ch_layouts
Definition: ffmpeg.h:142
OptionsContext::qscale
SpecifierOptList qscale
Definition: ffmpeg.h:201
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1244
ist_iter
InputStream * ist_iter(InputStream *prev)
Definition: ffmpeg.c:397
normalize.log
log
Definition: normalize.py:21
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:639
OptionsContext::nb_attachments
int nb_attachments
Definition: ffmpeg.h:174
OutputFile::start_time
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:698
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:985
InputFile::index
int index
Definition: ffmpeg.h:511
OptionsContext::presets
SpecifierOptList presets
Definition: ffmpeg.h:216
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1401
OptionsContext::mux_max_delay
float mux_max_delay
Definition: ffmpeg.h:182
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:424
AVStreamGroup::params
union AVStreamGroup::@462 params
Group type-specific parameters.
subtitle_codec_name
static const char * subtitle_codec_name
Definition: ffplay.c:343
ENC_STATS_LITERAL
@ ENC_STATS_LITERAL
Definition: ffmpeg.h:548
OptionsContext::subtitle_disable
int subtitle_disable
Definition: ffmpeg.h:189
AV_CODEC_CONFIG_COLOR_RANGE
@ AV_CODEC_CONFIG_COLOR_RANGE
AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.
Definition: avcodec.h:2578
OptionsContext::passlogfiles
SpecifierOptList passlogfiles
Definition: ffmpeg.h:226
AVOption
AVOption.
Definition: opt.h:428
OutputStream::index
int index
Definition: ffmpeg.h:643
streamcopy_init
static int streamcopy_init(const OptionsContext *o, const Muxer *mux, OutputStream *ost, AVDictionary **encoder_opts)
Definition: ffmpeg_mux_init.c:985
b
#define b
Definition: input.c:43
ofilter_bind_enc
int ofilter_bind_enc(OutputFilter *ofilter, unsigned sched_idx_enc, const OutputFilterOptions *opts)
Definition: ffmpeg_filter.c:903
FilterGraph::index
int index
Definition: ffmpeg.h:401
choose_pixel_fmt
static enum AVPixelFormat choose_pixel_fmt(const AVCodecContext *avctx, enum AVPixelFormat target)
Definition: ffmpeg_mux_init.c:468
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:855
AVChapter::start
int64_t start
Definition: avformat.h:1295
Muxer::of
OutputFile of
Definition: ffmpeg_mux.h:93
MuxStream::force_fps
int force_fps
Definition: ffmpeg_mux.h:87
RcOverride::qscale
int qscale
Definition: avcodec.h:196
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
base
uint8_t base
Definition: vp3data.h:128
freeenv_utf8
static void freeenv_utf8(char *var)
Definition: getenv_utf8.h:72
nb_streams
static unsigned int nb_streams
Definition: ffprobe.c:352
OptionGroup::swr_opts
AVDictionary * swr_opts
Definition: cmdutils.h:350
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1546
AVIAMFParamDefinition
Parameters as defined in section 3.6.1 of IAMF.
Definition: iamf.h:193
OptionsContext::bitexact
int bitexact
Definition: ffmpeg.h:185
ViewSpecifier
Definition: ffmpeg.h:116
get_stream_group_index_from_id
static int64_t get_stream_group_index_from_id(Muxer *mux, int64_t id)
Definition: ffmpeg_mux_init.c:2407
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:61
video_disable
static int video_disable
Definition: ffplay.c:318
AVDictionary
Definition: dict.c:32
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_CONFIG_PIX_FORMAT
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition: avcodec.h:2573
MuxStream::copy_prior_start
int copy_prior_start
Definition: ffmpeg_mux.h:82
OptionsContext::format
const char * format
Definition: ffmpeg.h:139
parse_forced_key_frames
static int parse_forced_key_frames(void *log, KeyframeForceCtx *kf, const Muxer *mux, const char *spec)
Definition: ffmpeg_mux_init.c:3329
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
key
const char * key
Definition: ffmpeg_mux_init.c:2985
enc_stats_init
static int enc_stats_init(OutputStream *ost, EncStats *es, int pre, const char *path, const char *fmt_spec)
Definition: ffmpeg_mux_init.c:246
ost_add
static int ost_add(Muxer *mux, const OptionsContext *o, enum AVMediaType type, InputStream *ist, OutputFilter *ofilter, const ViewSpecifier *vs, OutputStream **post)
Definition: ffmpeg_mux_init.c:1135
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:326
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
parse_matrix_coeffs
static int parse_matrix_coeffs(void *logctx, uint16_t *dest, const char *str)
Definition: ffmpeg_mux_init.c:440
OptionsContext::frame_pix_fmts
SpecifierOptList frame_pix_fmts
Definition: ffmpeg.h:148
set_dispositions
static int set_dispositions(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:3244
av_opt_serialize
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.
Definition: opt.c:2836
MuxStream::ts_copy_start
int64_t ts_copy_start
Definition: ffmpeg_mux.h:66
OutputStream::file
struct OutputFile * file
Definition: ffmpeg.h:641
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:539
MuxStream::stream_duration_tb
AVRational stream_duration_tb
Definition: ffmpeg_mux.h:73
ENC_STATS_TIMEBASE_IN
@ ENC_STATS_TIMEBASE_IN
Definition: ffmpeg.h:554
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:318
get_preset_file_2
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
Definition: ffmpeg_mux_init.c:126
OutputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:695
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:121
av_expr_parse
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.
Definition: eval.c:735
Muxer
Definition: ffmpeg_mux.h:92
InputStream
Definition: ffmpeg.h:465
OptionsContext::chapters_input_file
int chapters_input_file
Definition: ffmpeg.h:176
AVPacketSideData::size
size_t size
Definition: packet.h:426
OutputFilterOptions
Definition: ffmpeg.h:294
EncStatsFile
Definition: ffmpeg_mux_init.c:156
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1618
map_auto_subtitle
static int map_auto_subtitle(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1705
OptionsContext::max_frame_rates
SpecifierOptList max_frame_rates
Definition: ffmpeg.h:146
AV_OPT_SERIALIZE_SEARCH_CHILDREN
#define AV_OPT_SERIALIZE_SEARCH_CHILDREN
Serialize options in possible children of the given object.
Definition: opt.h:1094
finish
static void finish(void)
Definition: movenc.c:374
OptionsContext::enc_reinit_opts
SpecifierOptList enc_reinit_opts
Definition: ffmpeg.h:239
fopen_utf8.h
av_iamf_mix_presentation_add_submix
AVIAMFSubmix * av_iamf_mix_presentation_add_submix(AVIAMFMixPresentation *mix_presentation)
Allocate a submix and add it to a given AVIAMFMixPresentation.
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:452
of_parse_group_token
static int of_parse_group_token(Muxer *mux, const char *token, char *ptr)
Definition: ffmpeg_mux_init.c:2518
InputStreamGroup
Definition: ffmpeg.h:496
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:133
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1055
mux_alloc
static Muxer * mux_alloc(void)
Definition: ffmpeg_mux_init.c:3471
opt_match_per_stream_int
void opt_match_per_stream_int(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, int *out)
OptionsContext::enc_stats_pre_fmt
SpecifierOptList enc_stats_pre_fmt
Definition: ffmpeg.h:243
AVFMT_FIXED_FRAMESIZE
#define AVFMT_FIXED_FRAMESIZE
Format wants fixed size audio frames..
Definition: avformat.h:518
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:973
OptionsContext::mux_stats_fmt
SpecifierOptList mux_stats_fmt
Definition: ffmpeg.h:245
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:517
sch_add_mux_stream
int sch_add_mux_stream(Scheduler *sch, unsigned mux_idx)
Add a muxed stream for a previously added muxer.
Definition: ffmpeg_sched.c:694
SCH_NODE_TYPE_NONE
@ SCH_NODE_TYPE_NONE
Definition: ffmpeg_sched.h:94
copy_meta
static int copy_meta(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:3126
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:500
AVChapter
Definition: avformat.h:1292
val
static double val(void *priv, double ch)
Definition: aeval.c:77
SCH_ENC
#define SCH_ENC(encoder)
Definition: ffmpeg_sched.h:123
type
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
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:649
OptionsContext
Definition: ffmpeg.h:132
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:887
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:282
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:454
Muxer::sq_pkt
AVPacket * sq_pkt
Definition: ffmpeg_mux.h:118
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:825
av_codec_get_tag2
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.
AV_OPT_SERIALIZE_SKIP_DEFAULTS
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS
Serialize options that are not set to default values only.
Definition: opt.h:1092
enc_stats_files
static EncStatsFile * enc_stats_files
Definition: ffmpeg_mux_init.c:161
new_stream_video
static int new_stream_video(Muxer *mux, const OptionsContext *o, OutputStream *ost, int *keep_pix_fmt, enum VideoSyncMethod *vsync_method)
Definition: ffmpeg_mux_init.c:548
AV_STREAM_GROUP_PARAMS_DOLBY_VISION
@ AV_STREAM_GROUP_PARAMS_DOLBY_VISION
Definition: avformat.h:1153
AVRational::num
int num
Numerator.
Definition: rational.h:59
OutputFilter::bound
int bound
Definition: ffmpeg.h:388
flags
int flags
Definition: ffmpeg_mux_init.c:2986
InputFile
Definition: ffmpeg.h:508
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
Definition: iamf.h:181
OptionsContext::recording_time
int64_t recording_time
Definition: ffmpeg.h:178
OptionsContext::nb_stream_maps
int nb_stream_maps
Definition: ffmpeg.h:172
OptionsContext::audio_disable
int audio_disable
Definition: ffmpeg.h:188
check_stream_specifier
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1338
preset
preset
Definition: vf_curves.c:47
avassert.h
RcOverride::quality_factor
float quality_factor
Definition: avcodec.h:197
MuxStream::log_name
char log_name[32]
Definition: ffmpeg_mux.h:46
opt_match_per_stream_int64
void opt_match_per_stream_int64(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, int64_t *out)
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1580
reenc_delete_keys
static const struct @13 reenc_delete_keys[]
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:347
av_dump_format
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,...
Definition: dump.c:852
AVCodecTag
Definition: internal.h:42
ENC_STATS_PTS_IN
@ ENC_STATS_PTS_IN
Definition: ffmpeg.h:557
OptionsContext::metadata
SpecifierOptList metadata
Definition: ffmpeg.h:195
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:185
OptionsContext::filters
SpecifierOptList filters
Definition: ffmpeg.h:219
choose_encoder
static int choose_encoder(const OptionsContext *o, AVFormatContext *s, MuxStream *ms, const AVCodec **enc)
Definition: ffmpeg_mux_init.c:69
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
avformat_query_codec
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
Definition: mux_utils.c:32
av_iamf_submix_add_layout
AVIAMFSubmixLayout * av_iamf_submix_add_layout(AVIAMFSubmix *submix)
Allocate a submix layout and add it to a given AVIAMFSubmix.
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1149
output_stream_class
static const AVClass output_stream_class
Definition: ffmpeg_mux_init.c:385
VSYNC_VSCFR
@ VSYNC_VSCFR
Definition: ffmpeg.h:61
EncStats::components
EncStatsComponent * components
Definition: ffmpeg.h:577
of_parse_iamf_submixes
static int of_parse_iamf_submixes(Muxer *mux, AVStreamGroup *stg, char *ptr)
Definition: ffmpeg_mux_init.c:2237
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
assert_file_overwrite
int assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:816
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1295
SpecifierOpt::specifier
char * specifier
Definition: cmdutils.h:169
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
mux_stream_alloc
static MuxStream * mux_stream_alloc(Muxer *mux, enum AVMediaType type)
Definition: ffmpeg_mux_init.c:392
AV_CODEC_CONFIG_SAMPLE_FORMAT
@ AV_CODEC_CONFIG_SAMPLE_FORMAT
AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE.
Definition: avcodec.h:2576
intreadwrite.h
sch_add_mux
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.
Definition: ffmpeg_sched.c:670
OptionsContext::intra_matrices
SpecifierOptList intra_matrices
Definition: ffmpeg.h:212
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1338
MuxStream::pkt
AVPacket * pkt
Definition: ffmpeg_mux.h:51
OptionsContext::stream_groups
SpecifierOptList stream_groups
Definition: ffmpeg.h:234
FilterGraph::outputs
OutputFilter ** outputs
Definition: ffmpeg.h:405
enc_stats_get_file
static int enc_stats_get_file(AVIOContext **io, const char *path)
Definition: ffmpeg_mux_init.c:164
of_add_groups
static int of_add_groups(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:2666
InputStream::framerate
AVRational framerate
Definition: ffmpeg.h:486
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1484
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
The aspect ratio (width/height) which a single pixel should have when displayed.
Definition: codec_par.h:161
output_file_class
static const AVClass output_file_class
Definition: ffmpeg_mux_init.c:3464
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1545
RcOverride
Definition: avcodec.h:193
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1434
ENC_STATS_FILE_IDX
@ ENC_STATS_FILE_IDX
Definition: ffmpeg.h:549
AVDictionaryEntry::key
char * key
Definition: dict.h:91
frame_size
int frame_size
Definition: mxfenc.c:2489
OptionsContext::limit_filesize
int64_t limit_filesize
Definition: ffmpeg.h:180
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AVCodecParameters::width
int width
The width of the video frame in pixels.
Definition: codec_par.h:143
av_iamf_param_definition_get_subblock
static av_always_inline void * av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx)
Get the subblock at the specified.
Definition: iamf.h:260
VIEW_SPECIFIER_TYPE_NONE
@ VIEW_SPECIFIER_TYPE_NONE
Definition: ffmpeg.h:105
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
OptionsContext::autoscale
SpecifierOptList autoscale
Definition: ffmpeg.h:237
OutputFilter::linklabel
uint8_t * linklabel
Definition: ffmpeg.h:389
av_strtok
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().
Definition: avstring.c:179
get_line
static char * get_line(AVIOContext *s, AVBPrint *bprint)
Definition: ffmpeg_mux_init.c:113
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:55
ENC_STATS_BITRATE
@ ENC_STATS_BITRATE
Definition: ffmpeg.h:564
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
AVMEDIA_TYPE_NB
@ AVMEDIA_TYPE_NB
Definition: avutil.h:205
output_stream_item_name
static const char * output_stream_item_name(void *obj)
Definition: ffmpeg_mux_init.c:378
of_add_metadata
static int of_add_metadata(OutputFile *of, AVFormatContext *oc, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:2792
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
OptionsContext::sample_fmts
SpecifierOptList sample_fmts
Definition: ffmpeg.h:200
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1170
AVPacketSideData::data
uint8_t * data
Definition: packet.h:425
ignore_unknown_streams
int ignore_unknown_streams
Definition: ffmpeg_opt.c:86
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
RcOverride::start_frame
int start_frame
Definition: avcodec.h:194
channels
channels
Definition: aptx.h:31
OFILTER_FLAG_AUTOSCALE
@ OFILTER_FLAG_AUTOSCALE
Definition: ffmpeg.h:289
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
KF_FORCE_SOURCE
@ KF_FORCE_SOURCE
Definition: ffmpeg.h:587
encoder_thread
int encoder_thread(void *arg)
Definition: ffmpeg_enc.c:1009
OptionsContext::shortest
int shortest
Definition: ffmpeg.h:184
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:552
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:88
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
InputStreamGroup::stg
AVStreamGroup * stg
Definition: ffmpeg.h:505
NAN
#define NAN
Definition: mathematics.h:115
MuxStream::max_frames
int64_t max_frames
Definition: ffmpeg_mux.h:61
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
AVFMT_NEEDNUMBER
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:489
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:453
Muxer::limit_filesize
int64_t limit_filesize
Definition: ffmpeg_mux.h:113
meta_spec_matches
static int meta_spec_matches(void *log_ctx, AVFormatContext *oc, AVStream *st, const char *spec)
Definition: ffmpeg_mux_init.c:3026
arg
const char * arg
Definition: jacosubdec.c:65
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
pixfmt_in_list
static int pixfmt_in_list(const enum AVPixelFormat *formats, enum AVPixelFormat format)
Definition: ffmpeg_mux_init.c:459
sq_add_stream
int sq_add_stream(SyncQueue *sq, int limiting)
Add a new stream to the sync queue.
Definition: sync_queue.c:598
OptionsContext::start_time
int64_t start_time
Definition: ffmpeg.h:136
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
AVFormatContext
Format I/O context.
Definition: avformat.h:1333
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
MuxStream::max_frame_rate
AVRational max_frame_rate
Definition: ffmpeg_mux.h:86
fail
#define fail
Definition: test.h:479
ENC_STATS_KEYFRAME
@ ENC_STATS_KEYFRAME
Definition: ffmpeg.h:566
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:348
opts
static AVDictionary * opts
Definition: movenc.c:51
new_stream_subtitle
static int new_stream_subtitle(Muxer *mux, const OptionsContext *o, OutputStream *ost)
Definition: ffmpeg_mux_init.c:820
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:789
AVCodecParameters::avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
OutputFilter::name
uint8_t * name
Definition: ffmpeg.h:379
parse_meta_type
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.
Definition: ffmpeg_mux_init.c:2762
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:805
NULL
#define NULL
Definition: coverity.c:32
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: avformat.c:343
MuxStream::frame_rate
AVRational frame_rate
Definition: ffmpeg_mux.h:85
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:681
InputStream::st
AVStream * st
Definition: ffmpeg.h:473
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
AV_CODEC_CONFIG_FRAME_RATE
@ AV_CODEC_CONFIG_FRAME_RATE
AVRational, terminated by {0, 0}.
Definition: avcodec.h:2574
MuxStream::sch_idx_src
int sch_idx_src
Definition: ffmpeg_mux.h:57
OptionsContext::audio_channels
SpecifierOptList audio_channels
Definition: ffmpeg.h:143
map_auto_video
static int map_auto_video(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1553
nb_enc_stats_files
static int nb_enc_stats_files
Definition: ffmpeg_mux_init.c:162
sch_add_enc
int sch_add_enc(Scheduler *sch, SchThreadFunc func, void *ctx, int(*open_cb)(void *opaque, const AVFrame *frame))
Definition: ffmpeg_sched.c:837
ENC_STATS_PTS_TIME
@ ENC_STATS_PTS_TIME
Definition: ffmpeg.h:556
OptionsContext::fix_sub_duration_heartbeat
SpecifierOptList fix_sub_duration_heartbeat
Definition: ffmpeg.h:223
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
OFILTER_FLAG_AUDIO_24BIT
@ OFILTER_FLAG_AUDIO_24BIT
Definition: ffmpeg.h:288
EncStats::lock
pthread_mutex_t lock
Definition: ffmpeg.h:582
OptionsContext::copy_prior_start
SpecifierOptList copy_prior_start
Definition: ffmpeg.h:218
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:427
filter_codec_opts
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.
Definition: cmdutils.c:1423
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1375
AV_CODEC_PROP_BITMAP_SUB
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: codec_desc.h:111
parseutils.h
AVIAMFLayer
A layer defining a Channel Layout in the Audio Element.
Definition: iamf.h:294
EncStats
Definition: ffmpeg.h:576
OptionsContext::program
SpecifierOptList program
Definition: ffmpeg.h:233
EncStatsFile::io
AVIOContext * io
Definition: ffmpeg_mux_init.c:158
getenv_utf8
static char * getenv_utf8(const char *varname)
Definition: getenv_utf8.h:67
copy_unknown_streams
int copy_unknown_streams
Definition: ffmpeg_opt.c:87
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:846
OptionsContext::frame_aspect_ratios
SpecifierOptList frame_aspect_ratios
Definition: ffmpeg.h:205
MuxStream::bsf_ctx
AVBSFContext * bsf_ctx
Definition: ffmpeg_mux.h:48
MuxStream::par_in
AVCodecParameters * par_in
Codec parameters for packets submitted to the muxer (i.e.
Definition: ffmpeg_mux.h:43
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:116
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:592
of_stream_init
int of_stream_init(OutputFile *of, OutputStream *ost, const AVCodecContext *enc_ctx)
Definition: ffmpeg_mux.c:606
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
reenc_delete_stale_metadata
static int reenc_delete_stale_metadata(const OptionsContext *o, void *log_ctx, AVFormatContext *oc, AVStream *st, AVDictionary **dict, const char *kind, unsigned reenc_mask)
Definition: ffmpeg_mux_init.c:3092
av_parse_ratio
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.
Definition: parseutils.c:45
OptionsContext::max_frames
SpecifierOptList max_frames
Definition: ffmpeg.h:197
Muxer::log_name
char log_name[32]
Definition: ffmpeg_mux.h:96
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1345
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
The channel layout and number of channels.
Definition: codec_par.h:207
OutputFile::index
int index
Definition: ffmpeg.h:690
OutputFile::class
const AVClass * class
Definition: ffmpeg.h:688
ENC_STATS_PTS_TIME_IN
@ ENC_STATS_PTS_TIME_IN
Definition: ffmpeg.h:558
FilterGraph::nb_outputs
int nb_outputs
Definition: ffmpeg.h:406
copy_metadata
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)
Definition: ffmpeg_mux_init.c:2892
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:351
index
int index
Definition: gxfenc.c:90
c
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
Definition: undefined.txt:32
find_codec
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **codec)
Definition: ffmpeg_opt.c:783
InputStream::par
AVCodecParameters * par
Codec parameters - to be used by the decoding/streamcopy code.
Definition: ffmpeg.h:481
input_files
InputFile ** input_files
Definition: ffmpeg.c:108
OutputFile::streams
OutputStream ** streams
Definition: ffmpeg.h:694
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
Scheduler
Definition: ffmpeg_sched.c:278
AVIAMFSubmixElement::audio_element_id
unsigned int audio_element_id
The id of the Audio Element this submix element references.
Definition: iamf.h:455
avformat_stream_group_add_stream
int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
Add an already allocated stream to a stream group.
Definition: options.c:558
FilterGraph
Definition: ffmpeg.h:399
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:75
AVIAMFSubmix
Submix layout as defined in section 3.7 of IAMF.
Definition: iamf.h:559
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1389
ENC_TIME_BASE_DEMUX
@ ENC_TIME_BASE_DEMUX
Definition: ffmpeg.h:65
of_add_programs
static int of_add_programs(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:2693
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_EXPERIMENTAL, AVFMT_GLOBALHEADER,...
Definition: avformat.h:546
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1150
avcodec_get_supported_config
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.
Definition: avcodec.c:818
AV_CODEC_CONFIG_CHANNEL_LAYOUT
@ AV_CODEC_CONFIG_CHANNEL_LAYOUT
AVChannelLayout, terminated by {0}.
Definition: avcodec.h:2577
VideoSyncMethod
VideoSyncMethod
Definition: ffmpeg.h:56
av_get_exact_bits_per_sample
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:461
av_opt_find
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.
Definition: opt.c:2067
OptionsContext::apad
SpecifierOptList apad
Definition: ffmpeg.h:230
OptionsContext::enc_stats_post_fmt
SpecifierOptList enc_stats_post_fmt
Definition: ffmpeg.h:244
OutputStream::filter
OutputFilter * filter
Definition: ffmpeg.h:666
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVCodecContext::rc_override
RcOverride * rc_override
Definition: avcodec.h:1281
OptionsContext::thread_queue_size
int thread_queue_size
Definition: ffmpeg.h:158
AVMediaType
AVMediaType
Definition: avutil.h:198
Muxer::sq_mux
SyncQueue * sq_mux
Definition: ffmpeg_mux.h:117
AV_STREAM_GROUP_PARAMS_TREF
@ AV_STREAM_GROUP_PARAMS_TREF
Definition: avformat.h:1152
InputStreamGroup::fg
FilterGraph * fg
Definition: ffmpeg.h:504
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
MuxStream::apad
const char * apad
Definition: ffmpeg_mux.h:89
OptionsContext::enc_stats_pre
SpecifierOptList enc_stats_pre
Definition: ffmpeg.h:240
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
output_files
OutputFile ** output_files
Definition: ffmpeg.c:111
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
start_time
static int64_t start_time
Definition: ffplay.c:329
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1449
EncStatsType
EncStatsType
Definition: ffmpeg.h:547
Muxer::sch
Scheduler * sch
Definition: ffmpeg_mux.h:100
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1047
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
StreamMap
Definition: ffmpeg.h:122
ENC_STATS_NB_SAMPLES
@ ENC_STATS_NB_SAMPLES
Definition: ffmpeg.h:562
size
int size
Definition: twinvq_data.h:10344
reenc_delete_metadata_key
static int reenc_delete_metadata_key(const OptionsContext *o, void *log_ctx, AVFormatContext *oc, AVStream *st, const char *family, const char *key, int flags)
Definition: ffmpeg_mux_init.c:3052
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:64
AV_CODEC_CONFIG_ALPHA_MODE
@ AV_CODEC_CONFIG_ALPHA_MODE
AVAlphaMode, terminated by AVALPHA_MODE_UNSPECIFIED.
Definition: avcodec.h:2580
avio.h
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1192
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:877
OptionsContext::streamid
AVDictionary * streamid
Definition: ffmpeg.h:193
enc_alloc
int enc_alloc(Encoder **penc, const AVCodec *codec, Scheduler *sch, unsigned sch_idx, void *log_parent)
Definition: ffmpeg_enc.c:125
av_malloc
#define av_malloc(s)
Definition: ops_static.c:52
OptionsContext::pass
SpecifierOptList pass
Definition: ffmpeg.h:225
OutputStream::type
enum AVMediaType type
Definition: ffmpeg.h:638
OutputFile::url
const char * url
Definition: ffmpeg.h:692
setup_sync_queues
static int setup_sync_queues(Muxer *mux, AVFormatContext *oc, int64_t buf_size_us, int shortest)
Definition: ffmpeg_mux_init.c:2059
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:488
AVCodecContext::chroma_intra_matrix
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:976
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:199
Muxer::opts
AVDictionary * opts
Definition: ffmpeg_mux.h:107
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:844
OptionsContext::disposition
SpecifierOptList disposition
Definition: ffmpeg.h:232
AVFMT_NOSTREAMS
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:503
allocate_array_elem
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.
Definition: cmdutils.c:1540
of_enc_stats_close
void of_enc_stats_close(void)
Definition: ffmpeg_mux_init.c:197
MuxStream
Definition: ffmpeg_mux.h:36
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:294
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:606
getenv_utf8.h
a
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
Definition: undefined.txt:41
av_iamf_submix_add_element
AVIAMFSubmixElement * av_iamf_submix_add_element(AVIAMFSubmix *submix)
Allocate a submix element and add it to a given AVIAMFSubmix.
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:359
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:184
opt_match_per_stream_dbl
void opt_match_per_stream_dbl(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, double *out)
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:233
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
AVCodecParameters::avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:57
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1148
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1234
av_parse_video_size
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.
Definition: parseutils.c:150
Muxer::sch_idx
unsigned sch_idx
Definition: ffmpeg_mux.h:101
ENC_STATS_FRAME_NUM
@ ENC_STATS_FRAME_NUM
Definition: ffmpeg.h:551
KeyframeForceCtx
Definition: ffmpeg.h:592
OutputFilter::type
enum AVMediaType type
Definition: ffmpeg.h:393
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1193
OptionsContext::chroma_intra_matrices
SpecifierOptList chroma_intra_matrices
Definition: ffmpeg.h:214
fg_create_simple
int fg_create_simple(FilterGraph **pfg, InputStream *ist, char **graph_desc, Scheduler *sch, unsigned sched_idx_enc, const OutputFilterOptions *opts)
Definition: ffmpeg_filter.c:1342
mux_check_init
int mux_check_init(void *arg)
Definition: ffmpeg_mux.c:550
AVCodec::id
enum AVCodecID id
Definition: codec.h:189
layout
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
Definition: filter_design.txt:18
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:421
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
of_open
int of_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_mux_init.c:3486
av_channel_layout_from_string
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
Definition: channel_layout.c:313
bprint.h
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1058
map_auto_data
static int map_auto_data(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1744
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1147
log.h
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:497
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
RcOverride::end_frame
int end_frame
Definition: avcodec.h:195
OptionsContext::frame_rates
SpecifierOptList frame_rates
Definition: ffmpeg.h:145
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1293
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:141
MuxStream::stats
EncStats stats
Definition: ffmpeg_mux.h:53
OptionsContext::stream_maps
StreamMap * stream_maps
Definition: ffmpeg.h:171
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:2038
pix_fmt_parse
static enum AVPixelFormat pix_fmt_parse(OutputStream *ost, const char *name)
Definition: ffmpeg_mux_init.c:499
AVCodecParameters::height
int height
The height of the video frame in pixels.
Definition: codec_par.h:150
av_get_sample_fmt
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:58
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
OptionsContext::fps_mode
SpecifierOptList fps_mode
Definition: ffmpeg.h:203
AVCodecParameters::block_align
int block_align
The number of bytes per coded audio frame, required by some formats.
Definition: codec_par.h:221
VSYNC_CFR
@ VSYNC_CFR
Definition: ffmpeg.h:59
OptionsContext::shortest_buf_duration
float shortest_buf_duration
Definition: ffmpeg.h:183
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVProgram::metadata
AVDictionary * metadata
Definition: avformat.h:1263
OutputFile::bitexact
int bitexact
Definition: ffmpeg.h:700
display.h
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:616
OptionsContext::mux_stats
SpecifierOptList mux_stats
Definition: ffmpeg.h:242
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
s
uint8_t s
Definition: llvidencdsp.c:39
OptionsContext::muxing_queue_data_threshold
SpecifierOptList muxing_queue_data_threshold
Definition: ffmpeg.h:228
OptionsContext::keep_metadata
SpecifierOptList keep_metadata
Definition: ffmpeg.h:196
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:204
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:513
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFormatContext::max_delay
int max_delay
Definition: avformat.h:1478
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1257
OptionsContext::enc_stats_post
SpecifierOptList enc_stats_post
Definition: ffmpeg.h:241
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:182
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
SchedulerNode
Definition: ffmpeg_sched.h:103
ENC_STATS_STREAM_IDX
@ ENC_STATS_STREAM_IDX
Definition: ffmpeg.h:550
filtergraphs
FilterGraph ** filtergraphs
Definition: ffmpeg.c:114
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:322
InputFile::stream_groups
InputStreamGroup ** stream_groups
Definition: ffmpeg.h:531
AVCodecContext::height
int height
Definition: avcodec.h:604
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:83
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
ENC_STATS_SAMPLE_NUM
@ ENC_STATS_SAMPLE_NUM
Definition: ffmpeg.h:561
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
nb_output_files
int nb_output_files
Definition: ffmpeg.c:112
AVIAMFParamDefinition::nb_subblocks
unsigned int nb_subblocks
Number of subblocks in the array.
Definition: iamf.h:208
sch_connect
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
Definition: ffmpeg_sched.c:973
avcodec.h
OptionGroup::sws_dict
AVDictionary * sws_dict
Definition: cmdutils.h:349
av_opt_eval_flags
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:835
tag
uint32_t tag
Definition: movenc.c:2073
OptionsContext::metadata_map
SpecifierOptList metadata_map
Definition: ffmpeg.h:215
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:778
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1501
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:766
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:204
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1352
av_strlcat
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,...
Definition: avstring.c:95
output_file_item_name
static const char * output_file_item_name(void *obj)
Definition: ffmpeg_mux_init.c:3457
av_opt_eval_int
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
AV_CODEC_PROP_ENHANCEMENT
#define AV_CODEC_PROP_ENHANCEMENT
Video codec contains enhancement information meant to be applied to other existing frames,...
Definition: codec_desc.h:105
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:116
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:527
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:122
ost_bind_filter
static int ost_bind_filter(const Muxer *mux, MuxStream *ms, OutputFilter *ofilter, const OptionsContext *o, AVRational enc_tb, enum VideoSyncMethod vsync_method, int keep_pix_fmt, int autoscale, int threads_manual, const ViewSpecifier *vs, SchedulerNode *src)
Definition: ffmpeg_mux_init.c:862
dict.h
av_packet_side_data_new
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.
Definition: packet.c:620
check_avoptions_used
int check_avoptions_used(const AVDictionary *opts, const AVDictionary *opts_used, void *logctx, int decode)
Definition: ffmpeg.c:515
set_encoder_id
static int set_encoder_id(OutputStream *ost, const AVCodec *codec)
Definition: ffmpeg_mux_init.c:1113
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:607
av_guess_codec
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.
Definition: format.c:117
SCH_MSTREAM
#define SCH_MSTREAM(file, stream)
Definition: ffmpeg_sched.h:114
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:3392
OptionsContext::max_muxing_queue_size
SpecifierOptList max_muxing_queue_size
Definition: ffmpeg.h:227
AVStreamGroup
Definition: avformat.h:1159
of_add_attachments
static int of_add_attachments(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1852
av_get_media_type_string
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.
Definition: utils.c:28
AVCodecContext
main external API structure.
Definition: avcodec.h:443
OptionsContext::inter_matrices
SpecifierOptList inter_matrices
Definition: ffmpeg.h:213
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:772
AV_CLASS_CATEGORY_MUXER
@ AV_CLASS_CATEGORY_MUXER
Definition: log.h:32
av_find_best_pix_fmt_of_2
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.
Definition: pixdesc.c:3739
AVStreamGroup::nb_streams
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
Definition: avformat.h:1221
OptionsContext::audio_sample_rate
SpecifierOptList audio_sample_rate
Definition: ffmpeg.h:144
OptionsContext::mux_preload
float mux_preload
Definition: ffmpeg.h:181
AVRational::den
int den
Denominator.
Definition: rational.h:60
InputStream::file
struct InputFile * file
Definition: ffmpeg.h:469
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:174
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:258
avfilter.h
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
av_dict_parse_string
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.
Definition: dict.c:210
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:615
OptionsContext::frame_sizes
SpecifierOptList frame_sizes
Definition: ffmpeg.h:147
OptionsContext::video_disable
int video_disable
Definition: ffmpeg.h:187
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:538
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:900
AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
Definition: iamf.h:173
EncStats::lock_initialized
int lock_initialized
Definition: ffmpeg.h:583
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1468
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:536
InputFile::ts_offset
int64_t ts_offset
Definition: ffmpeg.h:520
av_iamf_audio_element_add_layer
AVIAMFLayer * av_iamf_audio_element_add_layer(AVIAMFAudioElement *audio_element)
Allocate a layer and add it to a given AVIAMFAudioElement.
VSYNC_AUTO
@ VSYNC_AUTO
Definition: ffmpeg.h:57
OutputFilter
Definition: ffmpeg.h:375
map_auto_audio
static int map_auto_audio(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1661
av_dict_set_int
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.
Definition: dict.c:177
OptionsContext::codec_tags
SpecifierOptList codec_tags
Definition: ffmpeg.h:199
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:575
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
desc
const char * desc
Definition: libsvtav1.c:83
OptionsContext::time_bases
SpecifierOptList time_bases
Definition: ffmpeg.h:235
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AVERROR_ENCODER_NOT_FOUND
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:56
av_bsf_list_parse_str
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...
Definition: bsf.c:524
unescape
static int unescape(char **pdst, size_t *dst_len, const char **pstr, char delim)
Definition: ffmpeg_mux_init.c:207
avutil.h
AVIAMFAudioElement::demixing_info
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:379
sch_sq_add_enc
int sch_sq_add_enc(Scheduler *sch, unsigned sq_idx, unsigned enc_idx, int limiting, uint64_t max_frames)
Definition: ffmpeg_sched.c:942
mem.h
AVIAMFSubmix::output_mix_config
AVIAMFParamDefinition * output_mix_config
Information required for post-processing the mixed audio signal to generate the audio signal for play...
Definition: iamf.h:598
MuxStream::sq_idx_mux
int sq_idx_mux
Definition: ffmpeg_mux.h:59
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1186
SpecifierOpt::u
union SpecifierOpt::@0 u
avio_open2
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.
Definition: avio.c:559
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:322
ffmpeg_mux.h
OptionsContext::rc_overrides
SpecifierOptList rc_overrides
Definition: ffmpeg.h:211
AVCodecParameters::avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:138
new_stream_audio
static int new_stream_audio(Muxer *mux, const OptionsContext *o, OutputStream *ost)
Definition: ffmpeg_mux_init.c:781
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
sch_mux_sub_heartbeat_add
int sch_mux_sub_heartbeat_add(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, unsigned dec_idx)
Definition: ffmpeg_sched.c:1292
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
avformat_stream_group_create
AVStreamGroup * avformat_stream_group_create(AVFormatContext *s, enum AVStreamGroupParamsType type, AVDictionary **options)
Add a new empty stream group to a media file.
Definition: options.c:470
InputStream::index
int index
Definition: ffmpeg.h:471
of_map_group
static int of_map_group(Muxer *mux, AVDictionary **dict, AVBPrint *bp, const char *map)
Definition: ffmpeg_mux_init.c:2418
AVFormatContext::nb_stream_groups
unsigned int nb_stream_groups
Number of elements in AVFormatContext.stream_groups.
Definition: avformat.h:1408
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1068
ffmpeg_sched.h
EncStatsFile::path
char * path
Definition: ffmpeg_mux_init.c:157
compare_int64
static int compare_int64(const void *a, const void *b)
Definition: ffmpeg_mux_init.c:3324
OptionsContext::copy_initial_nonkeyframes
SpecifierOptList copy_initial_nonkeyframes
Definition: ffmpeg.h:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FKF_N_FORCED
@ FKF_N_FORCED
Definition: ffmpeg.h:537
AVDictionaryEntry
Definition: dict.h:90
OptionsContext::attachments
const char ** attachments
Definition: ffmpeg.h:173
ENC_TIME_BASE_FILTER
@ ENC_TIME_BASE_FILTER
Definition: ffmpeg.h:66
av_add_q
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:57
audio_disable
static int audio_disable
Definition: ffplay.c:317
EncStatsComponent
Definition: ffmpeg.h:569
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:717
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
OFILTER_FLAG_DISABLE_CONVERT
@ OFILTER_FLAG_DISABLE_CONVERT
Definition: ffmpeg.h:286
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:247
AVCodecContext::inter_matrix
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions,...
Definition: avcodec.h:969
cmdutils.h
Muxer::enc_opts_used
AVDictionary * enc_opts_used
Definition: ffmpeg_mux.h:110
AVCodecContext::rc_override_count
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:1280
InputFile::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:514
EncStats::nb_components
int nb_components
Definition: ffmpeg.h:578
OptionsContext::data_disable
int data_disable
Definition: ffmpeg.h:190
nb_filtergraphs
int nb_filtergraphs
Definition: ffmpeg.c:115
AVIAMFSubmixElement::element_mix_config
AVIAMFParamDefinition * element_mix_config
Information required required for applying any processing to the referenced and rendered Audio Elemen...
Definition: iamf.h:464
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
AV_CODEC_FLAG2_FIXED_FRAME_SIZE
#define AV_CODEC_FLAG2_FIXED_FRAME_SIZE
Force audio encoders to use a fixed frame size.
Definition: avcodec.h:359
muxer_thread
int muxer_thread(void *arg)
Definition: ffmpeg_mux.c:402
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:449
ENC_STATS_PKT_SIZE
@ ENC_STATS_PKT_SIZE
Definition: ffmpeg.h:563
OutputStream
Definition: mux.c:53
check_opt_bitexact
static int check_opt_bitexact(void *ctx, const AVDictionary *opts, const char *opt_name, int flag)
Definition: ffmpeg_mux_init.c:53
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
forced_keyframes_const_names
static const char *const forced_keyframes_const_names[]
Definition: ffmpeg_mux_init.c:3315
read_file_to_string
char * read_file_to_string(const char *filename)
Definition: cmdutils.c:1571
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
process_forced_keyframes
static int process_forced_keyframes(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:3415
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:130
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3891
AVIAMFAudioElement::recon_gain_info
AVIAMFParamDefinition * recon_gain_info
Recon gain information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:386
sq_alloc
SyncQueue * sq_alloc(enum SyncQueueType type, int64_t buf_size_us, void *logctx)
Allocate a sync queue of the given type.
Definition: sync_queue.c:654
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:2062
AVDictionaryEntry::value
char * value
Definition: dict.h:92
avstring.h
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:226
opt_match_per_type_str
const char * opt_match_per_type_str(const SpecifierOptList *sol, char mediatype)
Definition: ffmpeg_opt.c:165
opt_match_per_stream_str
void opt_match_per_stream_str(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, const char **out)
sch_mux_stream_buffering
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.
Definition: ffmpeg_sched.c:1251
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:528
FKF_N
@ FKF_N
Definition: ffmpeg.h:536
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:95
ENC_STATS_DTS_TIME
@ ENC_STATS_DTS_TIME
Definition: ffmpeg.h:560
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1294
OutputFile::recording_time
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:697
reenc_mask
unsigned reenc_mask
Definition: ffmpeg_mux_init.c:2987
VSYNC_PASSTHROUGH
@ VSYNC_PASSTHROUGH
Definition: ffmpeg.h:58
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:298
snprintf
#define snprintf
Definition: snprintf.h:34
EncStats::io
AVIOContext * io
Definition: ffmpeg.h:580
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
OptionsContext::bitstream_filters
SpecifierOptList bitstream_filters
Definition: ffmpeg.h:198
src
#define src
Definition: vp8dsp.c:248
copy_chapters
static int copy_chapters(InputFile *ifile, OutputFile *ofile, AVFormatContext *os, int copy_metadata)
Definition: ffmpeg_mux_init.c:2850
MuxStream::last_mux_dts
int64_t last_mux_dts
Definition: ffmpeg_mux.h:70
OptionsContext::enc_time_bases
SpecifierOptList enc_time_bases
Definition: ffmpeg.h:236
av_opt_is_set_to_default_by_name
int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
Check if given option is set to its default value.
Definition: opt.c:2781
ENC_STATS_TIMEBASE
@ ENC_STATS_TIMEBASE
Definition: ffmpeg.h:553
create_streams
static int create_streams(Muxer *mux, const OptionsContext *o)
Definition: ffmpeg_mux_init.c:1935
MuxStream::stream_duration
int64_t stream_duration
Definition: ffmpeg_mux.h:72
OutputStream::class
const AVClass * class
Definition: ffmpeg.h:636
av_get_pix_fmt_name
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.
Definition: pixdesc.c:3380
AV_IAMF_PARAMETER_DEFINITION_DEMIXING
@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING
Subblocks are of struct type AVIAMFDemixingInfo.
Definition: iamf.h:177
OutputFile
Definition: ffmpeg.h:687
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:290
sch_add_sq_enc
int sch_add_sq_enc(Scheduler *sch, uint64_t buf_size_us, void *logctx)
Add an pre-encoding sync queue to the scheduler.
Definition: ffmpeg_sched.c:917
AV_CODEC_CONFIG_COLOR_SPACE
@ AV_CODEC_CONFIG_COLOR_SPACE
AVColorSpace, terminated by AVCOL_SPC_UNSPECIFIED.
Definition: avcodec.h:2579
Generated on Fri Aug 14 2026 19:22:33 for FFmpeg by   doxygen 1.8.17