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