FFmpeg
ffmpeg_opt.c
Go to the documentation of this file.
1 
2 /*
3  * ffmpeg option parsing
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "ffmpeg.h"
25 #include "cmdutils.h"
26 
27 #include "libavformat/avformat.h"
28 
29 #include "libavcodec/avcodec.h"
30 
31 #include "libavfilter/avfilter.h"
32 
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44 
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 
47 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 {\
49  int i, ret;\
50  for (i = 0; i < o->nb_ ## name; i++) {\
51  char *spec = o->name[i].specifier;\
52  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53  outvar = o->name[i].u.type;\
54  else if (ret < 0)\
55  exit_program(1);\
56  }\
57 }
58 
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 {\
61  int i;\
62  for (i = 0; i < o->nb_ ## name; i++) {\
63  char *spec = o->name[i].specifier;\
64  if (!strcmp(spec, mediatype))\
65  outvar = o->name[i].u.type;\
66  }\
67 }
68 
69 const HWAccel hwaccels[] = {
70 #if CONFIG_VIDEOTOOLBOX
72 #endif
73 #if CONFIG_LIBMFX
74  { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
75 #endif
76 #if CONFIG_CUVID
78 #endif
79  { 0 },
80 };
83 
86 
89 float dts_error_threshold = 3600*30;
90 
91 int audio_volume = 256;
96 int do_benchmark = 0;
98 int do_hex_dump = 0;
99 int do_pkt_dump = 0;
100 int copy_ts = 0;
102 int copy_tb = -1;
103 int debug_ts = 0;
106 int print_stats = -1;
107 int qp_hist = 0;
110 float max_error_rate = 2.0/3;
114 
115 
116 static int intra_only = 0;
117 static int file_overwrite = 0;
118 static int no_file_overwrite = 0;
119 static int do_psnr = 0;
120 static int input_sync;
122 static int ignore_unknown_streams = 0;
123 static int copy_unknown_streams = 0;
124 static int find_stream_info = 1;
125 
127 {
128  const OptionDef *po = options;
129  int i;
130 
131  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132  while (po->name) {
133  void *dst = (uint8_t*)o + po->u.off;
134 
135  if (po->flags & OPT_SPEC) {
136  SpecifierOpt **so = dst;
137  int i, *count = (int*)(so + 1);
138  for (i = 0; i < *count; i++) {
139  av_freep(&(*so)[i].specifier);
140  if (po->flags & OPT_STRING)
141  av_freep(&(*so)[i].u.str);
142  }
143  av_freep(so);
144  *count = 0;
145  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
146  av_freep(dst);
147  po++;
148  }
149 
150  for (i = 0; i < o->nb_stream_maps; i++)
152  av_freep(&o->stream_maps);
154  av_freep(&o->streamid_map);
155  av_freep(&o->attachments);
156 }
157 
159 {
160  memset(o, 0, sizeof(*o));
161 
162  o->stop_time = INT64_MAX;
163  o->mux_max_delay = 0.7;
166  o->recording_time = INT64_MAX;
167  o->limit_filesize = UINT64_MAX;
168  o->chapters_input_file = INT_MAX;
169  o->accurate_seek = 1;
170 }
171 
172 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 {
175  int i;
176 
177  printf("Hardware acceleration methods:\n");
178  while ((type = av_hwdevice_iterate_types(type)) !=
180  printf("%s\n", av_hwdevice_get_type_name(type));
181  for (i = 0; hwaccels[i].name; i++)
182  printf("%s\n", hwaccels[i].name);
183  printf("\n");
184  return 0;
185 }
186 
187 /* return a copy of the input with the stream specifiers removed from the keys */
189 {
190  AVDictionaryEntry *e = NULL;
191  AVDictionary *ret = NULL;
192 
193  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
194  char *p = strchr(e->key, ':');
195 
196  if (p)
197  *p = 0;
198  av_dict_set(&ret, e->key, e->value, 0);
199  if (p)
200  *p = ':';
201  }
202  return ret;
203 }
204 
205 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206 {
207  static const AVOption opts[] = {
208  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
209  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
210  { NULL },
211  };
212  static const AVClass class = {
213  .class_name = "",
214  .item_name = av_default_item_name,
215  .option = opts,
216  .version = LIBAVUTIL_VERSION_INT,
217  };
218  const AVClass *pclass = &class;
219 
220  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
221 }
222 
223 static int opt_sameq(void *optctx, const char *opt, const char *arg)
224 {
225  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
226  "If you are looking for an option to preserve the quality (which is not "
227  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228  opt, opt);
229  return AVERROR(EINVAL);
230 }
231 
232 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233 {
234  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
235  return opt_default(optctx, "channel", arg);
236 }
237 
238 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239 {
240  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
241  return opt_default(optctx, "standard", arg);
242 }
243 
244 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245 {
246  OptionsContext *o = optctx;
247  return parse_option(o, "codec:a", arg, options);
248 }
249 
250 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251 {
252  OptionsContext *o = optctx;
253  return parse_option(o, "codec:v", arg, options);
254 }
255 
256 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257 {
258  OptionsContext *o = optctx;
259  return parse_option(o, "codec:s", arg, options);
260 }
261 
262 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263 {
264  OptionsContext *o = optctx;
265  return parse_option(o, "codec:d", arg, options);
266 }
267 
268 static int opt_map(void *optctx, const char *opt, const char *arg)
269 {
270  OptionsContext *o = optctx;
271  StreamMap *m = NULL;
272  int i, negative = 0, file_idx, disabled = 0;
273  int sync_file_idx = -1, sync_stream_idx = 0;
274  char *p, *sync;
275  char *map;
276  char *allow_unused;
277 
278  if (*arg == '-') {
279  negative = 1;
280  arg++;
281  }
282  map = av_strdup(arg);
283  if (!map)
284  return AVERROR(ENOMEM);
285 
286  /* parse sync stream first, just pick first matching stream */
287  if (sync = strchr(map, ',')) {
288  *sync = 0;
289  sync_file_idx = strtol(sync + 1, &sync, 0);
290  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
291  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
292  exit_program(1);
293  }
294  if (*sync)
295  sync++;
296  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
297  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
298  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
299  sync_stream_idx = i;
300  break;
301  }
302  if (i == input_files[sync_file_idx]->nb_streams) {
303  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
304  "match any streams.\n", arg);
305  exit_program(1);
306  }
307  if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
308  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
309  "stream.\n", arg);
310  exit_program(1);
311  }
312  }
313 
314 
315  if (map[0] == '[') {
316  /* this mapping refers to lavfi output */
317  const char *c = map + 1;
319  m = &o->stream_maps[o->nb_stream_maps - 1];
320  m->linklabel = av_get_token(&c, "]");
321  if (!m->linklabel) {
322  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
323  exit_program(1);
324  }
325  } else {
326  if (allow_unused = strchr(map, '?'))
327  *allow_unused = 0;
328  file_idx = strtol(map, &p, 0);
329  if (file_idx >= nb_input_files || file_idx < 0) {
330  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
331  exit_program(1);
332  }
333  if (negative)
334  /* disable some already defined maps */
335  for (i = 0; i < o->nb_stream_maps; i++) {
336  m = &o->stream_maps[i];
337  if (file_idx == m->file_index &&
340  *p == ':' ? p + 1 : p) > 0)
341  m->disabled = 1;
342  }
343  else
344  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346  *p == ':' ? p + 1 : p) <= 0)
347  continue;
348  if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
349  disabled = 1;
350  continue;
351  }
353  m = &o->stream_maps[o->nb_stream_maps - 1];
354 
355  m->file_index = file_idx;
356  m->stream_index = i;
357 
358  if (sync_file_idx >= 0) {
359  m->sync_file_index = sync_file_idx;
360  m->sync_stream_index = sync_stream_idx;
361  } else {
362  m->sync_file_index = file_idx;
363  m->sync_stream_index = i;
364  }
365  }
366  }
367 
368  if (!m) {
369  if (allow_unused) {
370  av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371  } else if (disabled) {
372  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
373  "To ignore this, add a trailing '?' to the map.\n", arg);
374  exit_program(1);
375  } else {
376  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
377  "To ignore this, add a trailing '?' to the map.\n", arg);
378  exit_program(1);
379  }
380  }
381 
382  av_freep(&map);
383  return 0;
384 }
385 
386 static int opt_attach(void *optctx, const char *opt, const char *arg)
387 {
388  OptionsContext *o = optctx;
390  o->attachments[o->nb_attachments - 1] = arg;
391  return 0;
392 }
393 
394 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
395 {
396  OptionsContext *o = optctx;
397  int n;
398  AVStream *st;
399  AudioChannelMap *m;
400  char *allow_unused;
401  char *mapchan;
402  mapchan = av_strdup(arg);
403  if (!mapchan)
404  return AVERROR(ENOMEM);
405 
408 
409  /* muted channel syntax */
410  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
411  if ((n == 1 || n == 3) && m->channel_idx == -1) {
412  m->file_idx = m->stream_idx = -1;
413  if (n == 1)
414  m->ofile_idx = m->ostream_idx = -1;
415  av_free(mapchan);
416  return 0;
417  }
418 
419  /* normal syntax */
420  n = sscanf(arg, "%d.%d.%d:%d.%d",
421  &m->file_idx, &m->stream_idx, &m->channel_idx,
422  &m->ofile_idx, &m->ostream_idx);
423 
424  if (n != 3 && n != 5) {
425  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
426  "[file.stream.channel|-1][:syncfile:syncstream]\n");
427  exit_program(1);
428  }
429 
430  if (n != 5) // only file.stream.channel specified
431  m->ofile_idx = m->ostream_idx = -1;
432 
433  /* check input */
434  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
435  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
436  m->file_idx);
437  exit_program(1);
438  }
439  if (m->stream_idx < 0 ||
441  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
442  m->file_idx, m->stream_idx);
443  exit_program(1);
444  }
445  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
446  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
447  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
448  m->file_idx, m->stream_idx);
449  exit_program(1);
450  }
451  /* allow trailing ? to map_channel */
452  if (allow_unused = strchr(mapchan, '?'))
453  *allow_unused = 0;
454  if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
456  if (allow_unused) {
457  av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
458  m->file_idx, m->stream_idx, m->channel_idx);
459  } else {
460  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
461  "To ignore this, add a trailing '?' to the map_channel.\n",
462  m->file_idx, m->stream_idx, m->channel_idx);
463  exit_program(1);
464  }
465 
466  }
467  av_free(mapchan);
468  return 0;
469 }
470 
471 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
472 {
474  sdp_filename = av_strdup(arg);
475  return 0;
476 }
477 
478 #if CONFIG_VAAPI
479 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
480 {
481  HWDevice *dev;
482  const char *prefix = "vaapi:";
483  char *tmp;
484  int err;
485  tmp = av_asprintf("%s%s", prefix, arg);
486  if (!tmp)
487  return AVERROR(ENOMEM);
488  err = hw_device_init_from_string(tmp, &dev);
489  av_free(tmp);
490  if (err < 0)
491  return err;
492  hw_device_ctx = av_buffer_ref(dev->device_ref);
493  if (!hw_device_ctx)
494  return AVERROR(ENOMEM);
495  return 0;
496 }
497 #endif
498 
499 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
500 {
501  if (!strcmp(arg, "list")) {
503  printf("Supported hardware device types:\n");
504  while ((type = av_hwdevice_iterate_types(type)) !=
506  printf("%s\n", av_hwdevice_get_type_name(type));
507  printf("\n");
508  exit_program(0);
509  } else {
510  return hw_device_init_from_string(arg, NULL);
511  }
512 }
513 
514 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
515 {
516  if (filter_hw_device) {
517  av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
518  return AVERROR(EINVAL);
519  }
520  filter_hw_device = hw_device_get_by_name(arg);
521  if (!filter_hw_device) {
522  av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
523  return AVERROR(EINVAL);
524  }
525  return 0;
526 }
527 
528 /**
529  * Parse a metadata specifier passed as 'arg' parameter.
530  * @param arg metadata string to parse
531  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
532  * @param index for type c/p, chapter/program index is written here
533  * @param stream_spec for type s, the stream specifier is written here
534  */
535 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
536 {
537  if (*arg) {
538  *type = *arg;
539  switch (*arg) {
540  case 'g':
541  break;
542  case 's':
543  if (*(++arg) && *arg != ':') {
544  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
545  exit_program(1);
546  }
547  *stream_spec = *arg == ':' ? arg + 1 : "";
548  break;
549  case 'c':
550  case 'p':
551  if (*(++arg) == ':')
552  *index = strtol(++arg, NULL, 0);
553  break;
554  default:
555  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
556  exit_program(1);
557  }
558  } else
559  *type = 'g';
560 }
561 
562 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
563 {
564  AVDictionary **meta_in = NULL;
565  AVDictionary **meta_out = NULL;
566  int i, ret = 0;
567  char type_in, type_out;
568  const char *istream_spec = NULL, *ostream_spec = NULL;
569  int idx_in = 0, idx_out = 0;
570 
571  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
572  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
573 
574  if (!ic) {
575  if (type_out == 'g' || !*outspec)
576  o->metadata_global_manual = 1;
577  if (type_out == 's' || !*outspec)
579  if (type_out == 'c' || !*outspec)
581  return 0;
582  }
583 
584  if (type_in == 'g' || type_out == 'g')
585  o->metadata_global_manual = 1;
586  if (type_in == 's' || type_out == 's')
588  if (type_in == 'c' || type_out == 'c')
590 
591  /* ic is NULL when just disabling automatic mappings */
592  if (!ic)
593  return 0;
594 
595 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
596  if ((index) < 0 || (index) >= (nb_elems)) {\
597  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
598  (desc), (index));\
599  exit_program(1);\
600  }
601 
602 #define SET_DICT(type, meta, context, index)\
603  switch (type) {\
604  case 'g':\
605  meta = &context->metadata;\
606  break;\
607  case 'c':\
608  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
609  meta = &context->chapters[index]->metadata;\
610  break;\
611  case 'p':\
612  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
613  meta = &context->programs[index]->metadata;\
614  break;\
615  case 's':\
616  break; /* handled separately below */ \
617  default: av_assert0(0);\
618  }\
619 
620  SET_DICT(type_in, meta_in, ic, idx_in);
621  SET_DICT(type_out, meta_out, oc, idx_out);
622 
623  /* for input streams choose first matching stream */
624  if (type_in == 's') {
625  for (i = 0; i < ic->nb_streams; i++) {
626  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
627  meta_in = &ic->streams[i]->metadata;
628  break;
629  } else if (ret < 0)
630  exit_program(1);
631  }
632  if (!meta_in) {
633  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
634  exit_program(1);
635  }
636  }
637 
638  if (type_out == 's') {
639  for (i = 0; i < oc->nb_streams; i++) {
640  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
641  meta_out = &oc->streams[i]->metadata;
642  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
643  } else if (ret < 0)
644  exit_program(1);
645  }
646  } else
647  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
648 
649  return 0;
650 }
651 
652 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
653 {
654  OptionsContext *o = optctx;
655  char buf[128];
656  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
657  struct tm time = *gmtime((time_t*)&recording_timestamp);
658  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
659  return -1;
660  parse_option(o, "metadata", buf, options);
661 
662  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
663  "tag instead.\n", opt);
664  return 0;
665 }
666 
667 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
668 {
669  const AVCodecDescriptor *desc;
670  const char *codec_string = encoder ? "encoder" : "decoder";
671  AVCodec *codec;
672 
673  codec = encoder ?
676 
677  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
678  codec = encoder ? avcodec_find_encoder(desc->id) :
679  avcodec_find_decoder(desc->id);
680  if (codec)
681  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
682  codec_string, codec->name, desc->name);
683  }
684 
685  if (!codec) {
686  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
687  exit_program(1);
688  }
689  if (codec->type != type) {
690  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
691  exit_program(1);
692  }
693  return codec;
694 }
695 
697 {
698  char *codec_name = NULL;
699 
700  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
701  if (codec_name) {
702  AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
703  st->codecpar->codec_id = codec->id;
704  return codec;
705  } else
707 }
708 
709 /* Add all the streams from the given input file to the global
710  * list of input streams. */
712 {
713  int i, ret;
714 
715  for (i = 0; i < ic->nb_streams; i++) {
716  AVStream *st = ic->streams[i];
717  AVCodecParameters *par = st->codecpar;
718  InputStream *ist = av_mallocz(sizeof(*ist));
719  char *framerate = NULL, *hwaccel_device = NULL;
720  const char *hwaccel = NULL;
721  char *hwaccel_output_format = NULL;
722  char *codec_tag = NULL;
723  char *next;
724  char *discard_str = NULL;
725  const AVClass *cc = avcodec_get_class();
726  const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
727 
728  if (!ist)
729  exit_program(1);
730 
732  input_streams[nb_input_streams - 1] = ist;
733 
734  ist->st = st;
735  ist->file_index = nb_input_files;
736  ist->discard = 1;
737  st->discard = AVDISCARD_ALL;
738  ist->nb_samples = 0;
739  ist->min_pts = INT64_MAX;
740  ist->max_pts = INT64_MIN;
741 
742  ist->ts_scale = 1.0;
743  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
744 
745  ist->autorotate = 1;
746  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
747 
748  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
749  if (codec_tag) {
750  uint32_t tag = strtol(codec_tag, &next, 0);
751  if (*next)
752  tag = AV_RL32(codec_tag);
753  st->codecpar->codec_tag = tag;
754  }
755 
756  ist->dec = choose_decoder(o, ic, st);
757  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
758 
759  ist->reinit_filters = -1;
760  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
761 
762  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
764 
765  if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
770 
771  if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
772  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
773  discard_str);
774  exit_program(1);
775  }
776 
778 
779  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
780  if (!ist->dec_ctx) {
781  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
782  exit_program(1);
783  }
784 
785  ret = avcodec_parameters_to_context(ist->dec_ctx, par);
786  if (ret < 0) {
787  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
788  exit_program(1);
789  }
790 
791  if (o->bitexact)
793 
794  switch (par->codec_type) {
795  case AVMEDIA_TYPE_VIDEO:
796  if(!ist->dec)
797  ist->dec = avcodec_find_decoder(par->codec_id);
798 #if FF_API_LOWRES
799  if (st->codec->lowres) {
800  ist->dec_ctx->lowres = st->codec->lowres;
801  ist->dec_ctx->width = st->codec->width;
802  ist->dec_ctx->height = st->codec->height;
803  ist->dec_ctx->coded_width = st->codec->coded_width;
804  ist->dec_ctx->coded_height = st->codec->coded_height;
805  }
806 #endif
807 
808  // avformat_find_stream_info() doesn't set this for us anymore.
809  ist->dec_ctx->framerate = st->avg_frame_rate;
810 
811  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
812  if (framerate && av_parse_video_rate(&ist->framerate,
813  framerate) < 0) {
814  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
815  framerate);
816  exit_program(1);
817  }
818 
819  ist->top_field_first = -1;
820  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
821 
822  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
823  if (hwaccel) {
824  // The NVDEC hwaccels use a CUDA device, so remap the name here.
825  if (!strcmp(hwaccel, "nvdec"))
826  hwaccel = "cuda";
827 
828  if (!strcmp(hwaccel, "none"))
829  ist->hwaccel_id = HWACCEL_NONE;
830  else if (!strcmp(hwaccel, "auto"))
831  ist->hwaccel_id = HWACCEL_AUTO;
832  else {
833  enum AVHWDeviceType type;
834  int i;
835  for (i = 0; hwaccels[i].name; i++) {
836  if (!strcmp(hwaccels[i].name, hwaccel)) {
837  ist->hwaccel_id = hwaccels[i].id;
838  break;
839  }
840  }
841 
842  if (!ist->hwaccel_id) {
843  type = av_hwdevice_find_type_by_name(hwaccel);
844  if (type != AV_HWDEVICE_TYPE_NONE) {
846  ist->hwaccel_device_type = type;
847  }
848  }
849 
850  if (!ist->hwaccel_id) {
851  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
852  hwaccel);
853  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
854  type = AV_HWDEVICE_TYPE_NONE;
855  while ((type = av_hwdevice_iterate_types(type)) !=
857  av_log(NULL, AV_LOG_FATAL, "%s ",
859  for (i = 0; hwaccels[i].name; i++)
860  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
861  av_log(NULL, AV_LOG_FATAL, "\n");
862  exit_program(1);
863  }
864  }
865  }
866 
867  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
868  if (hwaccel_device) {
869  ist->hwaccel_device = av_strdup(hwaccel_device);
870  if (!ist->hwaccel_device)
871  exit_program(1);
872  }
873 
874  MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
875  hwaccel_output_format, ic, st);
876  if (hwaccel_output_format) {
877  ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
879  av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
880  "format: %s", hwaccel_output_format);
881  }
882  } else {
884  }
885 
887 
888  break;
889  case AVMEDIA_TYPE_AUDIO:
890  ist->guess_layout_max = INT_MAX;
891  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
893  break;
894  case AVMEDIA_TYPE_DATA:
895  case AVMEDIA_TYPE_SUBTITLE: {
896  char *canvas_size = NULL;
897  if(!ist->dec)
898  ist->dec = avcodec_find_decoder(par->codec_id);
899  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
900  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
901  if (canvas_size &&
902  av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
903  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
904  exit_program(1);
905  }
906  break;
907  }
910  break;
911  default:
912  abort();
913  }
914 
915  ret = avcodec_parameters_from_context(par, ist->dec_ctx);
916  if (ret < 0) {
917  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
918  exit_program(1);
919  }
920  }
921 }
922 
923 static void assert_file_overwrite(const char *filename)
924 {
925  const char *proto_name = avio_find_protocol_name(filename);
926 
928  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
929  exit_program(1);
930  }
931 
932  if (!file_overwrite) {
933  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
935  fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
936  fflush(stderr);
937  term_exit();
938  signal(SIGINT, SIG_DFL);
939  if (!read_yesno()) {
940  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
941  exit_program(1);
942  }
943  term_init();
944  }
945  else {
946  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
947  exit_program(1);
948  }
949  }
950  }
951 
952  if (proto_name && !strcmp(proto_name, "file")) {
953  for (int i = 0; i < nb_input_files; i++) {
954  InputFile *file = input_files[i];
955  if (file->ctx->iformat->flags & AVFMT_NOFILE)
956  continue;
957  if (!strcmp(filename, file->ctx->url)) {
958  av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
959  av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
960  exit_program(1);
961  }
962  }
963  }
964 }
965 
966 static void dump_attachment(AVStream *st, const char *filename)
967 {
968  int ret;
969  AVIOContext *out = NULL;
971 
972  if (!st->codecpar->extradata_size) {
973  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
974  nb_input_files - 1, st->index);
975  return;
976  }
977  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
978  filename = e->value;
979  if (!*filename) {
980  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
981  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
982  exit_program(1);
983  }
984 
985  assert_file_overwrite(filename);
986 
987  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
988  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
989  filename);
990  exit_program(1);
991  }
992 
994  avio_flush(out);
995  avio_close(out);
996 }
997 
998 static int open_input_file(OptionsContext *o, const char *filename)
999 {
1000  InputFile *f;
1001  AVFormatContext *ic;
1003  int err, i, ret;
1004  int64_t timestamp;
1005  AVDictionary *unused_opts = NULL;
1006  AVDictionaryEntry *e = NULL;
1007  char * video_codec_name = NULL;
1008  char * audio_codec_name = NULL;
1009  char *subtitle_codec_name = NULL;
1010  char * data_codec_name = NULL;
1011  int scan_all_pmts_set = 0;
1012 
1013  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1014  o->stop_time = INT64_MAX;
1015  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1016  }
1017 
1018  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1019  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1020  if (o->stop_time <= start_time) {
1021  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1022  exit_program(1);
1023  } else {
1025  }
1026  }
1027 
1028  if (o->format) {
1029  if (!(file_iformat = av_find_input_format(o->format))) {
1030  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1031  exit_program(1);
1032  }
1033  }
1034 
1035  if (!strcmp(filename, "-"))
1036  filename = "pipe:";
1037 
1038  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1039  strcmp(filename, "/dev/stdin");
1040 
1041  /* get default parameters from command line */
1042  ic = avformat_alloc_context();
1043  if (!ic) {
1044  print_error(filename, AVERROR(ENOMEM));
1045  exit_program(1);
1046  }
1047  if (o->nb_audio_sample_rate) {
1048  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1049  }
1050  if (o->nb_audio_channels) {
1051  /* because we set audio_channels based on both the "ac" and
1052  * "channel_layout" options, we need to check that the specified
1053  * demuxer actually has the "channels" option before setting it */
1054  if (file_iformat && file_iformat->priv_class &&
1055  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1057  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1058  }
1059  }
1060  if (o->nb_frame_rates) {
1061  /* set the format-level framerate option;
1062  * this is important for video grabbers, e.g. x11 */
1063  if (file_iformat && file_iformat->priv_class &&
1064  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1066  av_dict_set(&o->g->format_opts, "framerate",
1067  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1068  }
1069  }
1070  if (o->nb_frame_sizes) {
1071  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1072  }
1073  if (o->nb_frame_pix_fmts)
1074  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1075 
1076  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1077  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1078  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1079  MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1080 
1081  if (video_codec_name)
1082  ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1083  if (audio_codec_name)
1084  ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1085  if (subtitle_codec_name)
1086  ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1087  if (data_codec_name)
1088  ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1089 
1090  ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1091  ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1092  ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1093  ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1094 
1095  ic->flags |= AVFMT_FLAG_NONBLOCK;
1096  if (o->bitexact)
1097  ic->flags |= AVFMT_FLAG_BITEXACT;
1098  ic->interrupt_callback = int_cb;
1099 
1100  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1101  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1102  scan_all_pmts_set = 1;
1103  }
1104  /* open the input file with generic avformat function */
1105  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1106  if (err < 0) {
1107  print_error(filename, err);
1108  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1109  av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1110  exit_program(1);
1111  }
1112  if (scan_all_pmts_set)
1113  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1116 
1117  /* apply forced codec ids */
1118  for (i = 0; i < ic->nb_streams; i++)
1119  choose_decoder(o, ic, ic->streams[i]);
1120 
1121  if (find_stream_info) {
1123  int orig_nb_streams = ic->nb_streams;
1124 
1125  /* If not enough info to get the stream parameters, we decode the
1126  first frames to get it. (used in mpeg case for example) */
1127  ret = avformat_find_stream_info(ic, opts);
1128 
1129  for (i = 0; i < orig_nb_streams; i++)
1130  av_dict_free(&opts[i]);
1131  av_freep(&opts);
1132 
1133  if (ret < 0) {
1134  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1135  if (ic->nb_streams == 0) {
1136  avformat_close_input(&ic);
1137  exit_program(1);
1138  }
1139  }
1140  }
1141 
1143  av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1145  }
1146 
1147  if (o->start_time_eof != AV_NOPTS_VALUE) {
1148  if (o->start_time_eof >= 0) {
1149  av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1150  exit_program(1);
1151  }
1152  if (ic->duration > 0) {
1153  o->start_time = o->start_time_eof + ic->duration;
1154  if (o->start_time < 0) {
1155  av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1157  }
1158  } else
1159  av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1160  }
1161  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1162  /* add the stream start time */
1163  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1164  timestamp += ic->start_time;
1165 
1166  /* if seeking requested, we execute it */
1167  if (o->start_time != AV_NOPTS_VALUE) {
1168  int64_t seek_timestamp = timestamp;
1169 
1170  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1171  int dts_heuristic = 0;
1172  for (i=0; i<ic->nb_streams; i++) {
1173  const AVCodecParameters *par = ic->streams[i]->codecpar;
1174  if (par->video_delay) {
1175  dts_heuristic = 1;
1176  break;
1177  }
1178  }
1179  if (dts_heuristic) {
1180  seek_timestamp -= 3*AV_TIME_BASE / 23;
1181  }
1182  }
1183  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1184  if (ret < 0) {
1185  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1186  filename, (double)timestamp / AV_TIME_BASE);
1187  }
1188  }
1189 
1190  /* update the current parameters so that they match the one of the input stream */
1191  add_input_streams(o, ic);
1192 
1193  /* dump the file content */
1194  av_dump_format(ic, nb_input_files, filename, 0);
1195 
1197  f = av_mallocz(sizeof(*f));
1198  if (!f)
1199  exit_program(1);
1200  input_files[nb_input_files - 1] = f;
1201 
1202  f->ctx = ic;
1204  f->start_time = o->start_time;
1207  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1208  f->nb_streams = ic->nb_streams;
1209  f->rate_emu = o->rate_emu;
1210  f->accurate_seek = o->accurate_seek;
1211  f->loop = o->loop;
1212  f->duration = 0;
1213  f->time_base = (AVRational){ 1, 1 };
1214 #if HAVE_THREADS
1215  f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1216 #endif
1217 
1218  /* check if all codec options have been used */
1219  unused_opts = strip_specifiers(o->g->codec_opts);
1220  for (i = f->ist_index; i < nb_input_streams; i++) {
1221  e = NULL;
1222  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1224  av_dict_set(&unused_opts, e->key, NULL, 0);
1225  }
1226 
1227  e = NULL;
1228  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1229  const AVClass *class = avcodec_get_class();
1230  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1232  const AVClass *fclass = avformat_get_class();
1233  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1235  if (!option || foption)
1236  continue;
1237 
1238 
1239  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1240  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1241  "input file #%d (%s) is not a decoding option.\n", e->key,
1242  option->help ? option->help : "", nb_input_files - 1,
1243  filename);
1244  exit_program(1);
1245  }
1246 
1247  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1248  "input file #%d (%s) has not been used for any stream. The most "
1249  "likely reason is either wrong type (e.g. a video option with "
1250  "no video streams) or that it is a private option of some decoder "
1251  "which was not actually used for any stream.\n", e->key,
1252  option->help ? option->help : "", nb_input_files - 1, filename);
1253  }
1254  av_dict_free(&unused_opts);
1255 
1256  for (i = 0; i < o->nb_dump_attachment; i++) {
1257  int j;
1258 
1259  for (j = 0; j < ic->nb_streams; j++) {
1260  AVStream *st = ic->streams[j];
1261 
1262  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1263  dump_attachment(st, o->dump_attachment[i].u.str);
1264  }
1265  }
1266 
1268 
1269  return 0;
1270 }
1271 
1273 {
1274  AVIOContext *line;
1275  uint8_t *buf;
1276  char c;
1277 
1278  if (avio_open_dyn_buf(&line) < 0) {
1279  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1280  exit_program(1);
1281  }
1282 
1283  while ((c = avio_r8(s)) && c != '\n')
1284  avio_w8(line, c);
1285  avio_w8(line, 0);
1286  avio_close_dyn_buf(line, &buf);
1287 
1288  return buf;
1289 }
1290 
1291 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1292 {
1293  int i, ret = -1;
1294  char filename[1000];
1295  const char *base[3] = { getenv("AVCONV_DATADIR"),
1296  getenv("HOME"),
1297  AVCONV_DATADIR,
1298  };
1299 
1300  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1301  if (!base[i])
1302  continue;
1303  if (codec_name) {
1304  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1305  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1306  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1307  }
1308  if (ret < 0) {
1309  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1310  i != 1 ? "" : "/.avconv", preset_name);
1311  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1312  }
1313  }
1314  return ret;
1315 }
1316 
1318 {
1319  enum AVMediaType type = ost->st->codecpar->codec_type;
1320  char *codec_name = NULL;
1321 
1322  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1323  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1324  if (!codec_name) {
1325  ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1326  NULL, ost->st->codecpar->codec_type);
1327  ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1328  if (!ost->enc) {
1329  av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1330  "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1331  "probably disabled. Please choose an encoder manually.\n",
1332  ost->file_index, ost->index, s->oformat->name,
1335  }
1336  } else if (!strcmp(codec_name, "copy"))
1337  ost->stream_copy = 1;
1338  else {
1339  ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1340  ost->st->codecpar->codec_id = ost->enc->id;
1341  }
1342  ost->encoding_needed = !ost->stream_copy;
1343  } else {
1344  /* no encoding supported for other media types */
1345  ost->stream_copy = 1;
1346  ost->encoding_needed = 0;
1347  }
1348 
1349  return 0;
1350 }
1351 
1353 {
1354  OutputStream *ost;
1355  AVStream *st = avformat_new_stream(oc, NULL);
1356  int idx = oc->nb_streams - 1, ret = 0;
1357  const char *bsfs = NULL, *time_base = NULL;
1358  char *next, *codec_tag = NULL;
1359  double qscale = -1;
1360  int i;
1361 
1362  if (!st) {
1363  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1364  exit_program(1);
1365  }
1366 
1367  if (oc->nb_streams - 1 < o->nb_streamid_map)
1368  st->id = o->streamid_map[oc->nb_streams - 1];
1369 
1371  if (!(ost = av_mallocz(sizeof(*ost))))
1372  exit_program(1);
1374 
1375  ost->file_index = nb_output_files - 1;
1376  ost->index = idx;
1377  ost->st = st;
1379  st->codecpar->codec_type = type;
1380 
1381  ret = choose_encoder(o, oc, ost);
1382  if (ret < 0) {
1383  av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1384  "%d:%d\n", ost->file_index, ost->index);
1385  exit_program(1);
1386  }
1387 
1388  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1389  if (!ost->enc_ctx) {
1390  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1391  exit_program(1);
1392  }
1393  ost->enc_ctx->codec_type = type;
1394 
1396  if (!ost->ref_par) {
1397  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1398  exit_program(1);
1399  }
1400 
1401  if (ost->enc) {
1402  AVIOContext *s = NULL;
1403  char *buf = NULL, *arg = NULL, *preset = NULL;
1404 
1405  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1406 
1407  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1408  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1409  do {
1410  buf = get_line(s);
1411  if (!buf[0] || buf[0] == '#') {
1412  av_free(buf);
1413  continue;
1414  }
1415  if (!(arg = strchr(buf, '='))) {
1416  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1417  exit_program(1);
1418  }
1419  *arg++ = 0;
1421  av_free(buf);
1422  } while (!s->eof_reached);
1423  avio_closep(&s);
1424  }
1425  if (ret) {
1427  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1428  preset, ost->file_index, ost->index);
1429  exit_program(1);
1430  }
1431  } else {
1433  }
1434 
1435 
1436  if (o->bitexact)
1438 
1439  MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1440  if (time_base) {
1441  AVRational q;
1442  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1443  q.num <= 0 || q.den <= 0) {
1444  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1445  exit_program(1);
1446  }
1447  st->time_base = q;
1448  }
1449 
1450  MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1451  if (time_base) {
1452  AVRational q;
1453  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1454  q.den <= 0) {
1455  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1456  exit_program(1);
1457  }
1458  ost->enc_timebase = q;
1459  }
1460 
1461  ost->max_frames = INT64_MAX;
1462  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1463  for (i = 0; i<o->nb_max_frames; i++) {
1464  char *p = o->max_frames[i].specifier;
1465  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1466  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1467  break;
1468  }
1469  }
1470 
1471  ost->copy_prior_start = -1;
1472  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1473 
1474  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1475  while (bsfs && *bsfs) {
1476  const AVBitStreamFilter *filter;
1477  char *bsf, *bsf_options_str, *bsf_name;
1478 
1479  bsf = av_get_token(&bsfs, ",");
1480  if (!bsf)
1481  exit_program(1);
1482  bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1483  if (!bsf_name)
1484  exit_program(1);
1485 
1486  filter = av_bsf_get_by_name(bsf_name);
1487  if (!filter) {
1488  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1489  exit_program(1);
1490  }
1491 
1492  ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1493  ost->nb_bitstream_filters + 1,
1494  sizeof(*ost->bsf_ctx));
1495  if (!ost->bsf_ctx)
1496  exit_program(1);
1497 
1498  ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1499  if (ret < 0) {
1500  av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1501  exit_program(1);
1502  }
1503 
1504  ost->nb_bitstream_filters++;
1505 
1506  if (bsf_options_str && filter->priv_class) {
1507  const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1508  const char * shorthand[2] = {NULL};
1509 
1510  if (opt)
1511  shorthand[0] = opt->name;
1512 
1513  ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1514  if (ret < 0) {
1515  av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1516  exit_program(1);
1517  }
1518  }
1519  av_freep(&bsf);
1520 
1521  if (*bsfs)
1522  bsfs++;
1523  }
1524 
1525  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1526  if (codec_tag) {
1527  uint32_t tag = strtol(codec_tag, &next, 0);
1528  if (*next)
1529  tag = AV_RL32(codec_tag);
1530  ost->st->codecpar->codec_tag =
1531  ost->enc_ctx->codec_tag = tag;
1532  }
1533 
1534  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1535  if (qscale >= 0) {
1537  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1538  }
1539 
1540  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1541  ost->disposition = av_strdup(ost->disposition);
1542 
1543  ost->max_muxing_queue_size = 128;
1544  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1545  ost->max_muxing_queue_size *= sizeof(AVPacket);
1546 
1547  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1549 
1550  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1551 
1552  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1553  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1554  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1555 
1556  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1557 
1558  ost->source_index = source_index;
1559  if (source_index >= 0) {
1560  ost->sync_ist = input_streams[source_index];
1561  input_streams[source_index]->discard = 0;
1562  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1563  }
1565 
1566  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1567  if (!ost->muxing_queue)
1568  exit_program(1);
1569 
1570  return ost;
1571 }
1572 
1573 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1574 {
1575  int i;
1576  const char *p = str;
1577  for (i = 0;; i++) {
1578  dest[i] = atoi(p);
1579  if (i == 63)
1580  break;
1581  p = strchr(p, ',');
1582  if (!p) {
1583  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1584  exit_program(1);
1585  }
1586  p++;
1587  }
1588 }
1589 
1590 /* read file contents into a string */
1591 static uint8_t *read_file(const char *filename)
1592 {
1593  AVIOContext *pb = NULL;
1594  AVIOContext *dyn_buf = NULL;
1595  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1596  uint8_t buf[1024], *str;
1597 
1598  if (ret < 0) {
1599  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1600  return NULL;
1601  }
1602 
1603  ret = avio_open_dyn_buf(&dyn_buf);
1604  if (ret < 0) {
1605  avio_closep(&pb);
1606  return NULL;
1607  }
1608  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1609  avio_write(dyn_buf, buf, ret);
1610  avio_w8(dyn_buf, 0);
1611  avio_closep(&pb);
1612 
1613  ret = avio_close_dyn_buf(dyn_buf, &str);
1614  if (ret < 0)
1615  return NULL;
1616  return str;
1617 }
1618 
1620  OutputStream *ost)
1621 {
1622  AVStream *st = ost->st;
1623 
1624  if (ost->filters_script && ost->filters) {
1625  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1626  "output stream #%d:%d.\n", nb_output_files, st->index);
1627  exit_program(1);
1628  }
1629 
1630  if (ost->filters_script)
1631  return read_file(ost->filters_script);
1632  else if (ost->filters)
1633  return av_strdup(ost->filters);
1634 
1636  "null" : "anull");
1637 }
1638 
1640  const OutputStream *ost, enum AVMediaType type)
1641 {
1642  if (ost->filters_script || ost->filters) {
1644  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1645  "Filtering and streamcopy cannot be used together.\n",
1646  ost->filters ? "Filtergraph" : "Filtergraph script",
1647  ost->filters ? ost->filters : ost->filters_script,
1648  av_get_media_type_string(type), ost->file_index, ost->index);
1649  exit_program(1);
1650  }
1651 }
1652 
1654 {
1655  AVStream *st;
1656  OutputStream *ost;
1657  AVCodecContext *video_enc;
1658  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1659 
1660  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1661  st = ost->st;
1662  video_enc = ost->enc_ctx;
1663 
1664  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1665  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1666  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1667  exit_program(1);
1668  }
1669  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1670  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1671 
1672  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1673  if (frame_aspect_ratio) {
1674  AVRational q;
1675  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1676  q.num <= 0 || q.den <= 0) {
1677  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1678  exit_program(1);
1679  }
1680  ost->frame_aspect_ratio = q;
1681  }
1682 
1683  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1684  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1685  if (o->nb_filters > 1)
1686  av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);
1687 
1688  if (!ost->stream_copy) {
1689  const char *p = NULL;
1690  char *frame_size = NULL;
1691  char *frame_pix_fmt = NULL;
1692  char *intra_matrix = NULL, *inter_matrix = NULL;
1693  char *chroma_intra_matrix = NULL;
1694  int do_pass = 0;
1695  int i;
1696 
1697  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1698  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1699  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1700  exit_program(1);
1701  }
1702 
1704  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1705  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1706  ost->keep_pix_fmt = 1;
1707  if (!*++frame_pix_fmt)
1708  frame_pix_fmt = NULL;
1709  }
1710  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1711  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1712  exit_program(1);
1713  }
1714  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1715 
1716  if (intra_only)
1717  video_enc->gop_size = 0;
1718  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1719  if (intra_matrix) {
1720  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1721  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1722  exit_program(1);
1723  }
1724  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1725  }
1726  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1727  if (chroma_intra_matrix) {
1728  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1729  if (!p) {
1730  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1731  exit_program(1);
1732  }
1733  video_enc->chroma_intra_matrix = p;
1734  parse_matrix_coeffs(p, chroma_intra_matrix);
1735  }
1736  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1737  if (inter_matrix) {
1738  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1739  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1740  exit_program(1);
1741  }
1742  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1743  }
1744 
1745  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1746  for (i = 0; p; i++) {
1747  int start, end, q;
1748  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1749  if (e != 3) {
1750  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1751  exit_program(1);
1752  }
1753  video_enc->rc_override =
1754  av_realloc_array(video_enc->rc_override,
1755  i + 1, sizeof(RcOverride));
1756  if (!video_enc->rc_override) {
1757  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1758  exit_program(1);
1759  }
1760  video_enc->rc_override[i].start_frame = start;
1761  video_enc->rc_override[i].end_frame = end;
1762  if (q > 0) {
1763  video_enc->rc_override[i].qscale = q;
1764  video_enc->rc_override[i].quality_factor = 1.0;
1765  }
1766  else {
1767  video_enc->rc_override[i].qscale = 0;
1768  video_enc->rc_override[i].quality_factor = -q/100.0;
1769  }
1770  p = strchr(p, '/');
1771  if (p) p++;
1772  }
1773  video_enc->rc_override_count = i;
1774 
1775  if (do_psnr)
1776  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1777 
1778  /* two pass mode */
1779  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1780  if (do_pass) {
1781  if (do_pass & 1) {
1782  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1783  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1784  }
1785  if (do_pass & 2) {
1786  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1787  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1788  }
1789  }
1790 
1791  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1792  if (ost->logfile_prefix &&
1793  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1794  exit_program(1);
1795 
1796  if (do_pass) {
1797  char logfilename[1024];
1798  FILE *f;
1799 
1800  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1801  ost->logfile_prefix ? ost->logfile_prefix :
1803  i);
1804  if (!strcmp(ost->enc->name, "libx264")) {
1805  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1806  } else {
1807  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1808  char *logbuffer = read_file(logfilename);
1809 
1810  if (!logbuffer) {
1811  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1812  logfilename);
1813  exit_program(1);
1814  }
1815  video_enc->stats_in = logbuffer;
1816  }
1817  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1818  f = av_fopen_utf8(logfilename, "wb");
1819  if (!f) {
1821  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1822  logfilename, strerror(errno));
1823  exit_program(1);
1824  }
1825  ost->logfile = f;
1826  }
1827  }
1828  }
1829 
1830  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1831  if (ost->forced_keyframes)
1833 
1834  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1835 
1836  ost->top_field_first = -1;
1837  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1838 
1839 
1840  ost->avfilter = get_ost_filters(o, oc, ost);
1841  if (!ost->avfilter)
1842  exit_program(1);
1843  } else {
1844  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1845  }
1846 
1847  if (ost->stream_copy)
1849 
1850  return ost;
1851 }
1852 
1854 {
1855  int n;
1856  AVStream *st;
1857  OutputStream *ost;
1858  AVCodecContext *audio_enc;
1859 
1860  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1861  st = ost->st;
1862 
1863  audio_enc = ost->enc_ctx;
1864  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1865 
1866  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1867  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1868  if (o->nb_filters > 1)
1869  av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);
1870 
1871  if (!ost->stream_copy) {
1872  char *sample_fmt = NULL;
1873 
1874  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1875 
1876  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1877  if (sample_fmt &&
1878  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1879  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1880  exit_program(1);
1881  }
1882 
1883  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1884 
1885  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1886  ost->apad = av_strdup(ost->apad);
1887 
1888  ost->avfilter = get_ost_filters(o, oc, ost);
1889  if (!ost->avfilter)
1890  exit_program(1);
1891 
1892  /* check for channel mapping for this audio stream */
1893  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1895  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1896  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1897  InputStream *ist;
1898 
1899  if (map->channel_idx == -1) {
1900  ist = NULL;
1901  } else if (ost->source_index < 0) {
1902  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1903  ost->file_index, ost->st->index);
1904  continue;
1905  } else {
1906  ist = input_streams[ost->source_index];
1907  }
1908 
1909  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1911  ost->audio_channels_mapped + 1,
1912  sizeof(*ost->audio_channels_map)
1913  ) < 0 )
1914  exit_program(1);
1915 
1917  }
1918  }
1919  }
1920  }
1921 
1922  if (ost->stream_copy)
1924 
1925  return ost;
1926 }
1927 
1929 {
1930  OutputStream *ost;
1931 
1932  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1933  if (!ost->stream_copy) {
1934  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1935  exit_program(1);
1936  }
1937 
1938  return ost;
1939 }
1940 
1942 {
1943  OutputStream *ost;
1944 
1945  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1946  if (!ost->stream_copy) {
1947  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1948  exit_program(1);
1949  }
1950 
1951  return ost;
1952 }
1953 
1955 {
1956  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1957  ost->stream_copy = 1;
1958  ost->finished = 1;
1959  return ost;
1960 }
1961 
1963 {
1964  AVStream *st;
1965  OutputStream *ost;
1966  AVCodecContext *subtitle_enc;
1967 
1968  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1969  st = ost->st;
1970  subtitle_enc = ost->enc_ctx;
1971 
1972  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1973 
1974  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1975 
1976  if (!ost->stream_copy) {
1977  char *frame_size = NULL;
1978 
1979  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1980  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1981  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1982  exit_program(1);
1983  }
1984  }
1985 
1986  return ost;
1987 }
1988 
1989 /* arg format is "output-stream-index:streamid-value". */
1990 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1991 {
1992  OptionsContext *o = optctx;
1993  int idx;
1994  char *p;
1995  char idx_str[16];
1996 
1997  av_strlcpy(idx_str, arg, sizeof(idx_str));
1998  p = strchr(idx_str, ':');
1999  if (!p) {
2001  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2002  arg, opt);
2003  exit_program(1);
2004  }
2005  *p++ = '\0';
2006  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2007  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2008  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2009  return 0;
2010 }
2011 
2013 {
2014  AVFormatContext *is = ifile->ctx;
2015  AVFormatContext *os = ofile->ctx;
2016  AVChapter **tmp;
2017  int i;
2018 
2019  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2020  if (!tmp)
2021  return AVERROR(ENOMEM);
2022  os->chapters = tmp;
2023 
2024  for (i = 0; i < is->nb_chapters; i++) {
2025  AVChapter *in_ch = is->chapters[i], *out_ch;
2026  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2027  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2028  AV_TIME_BASE_Q, in_ch->time_base);
2029  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2031 
2032 
2033  if (in_ch->end < ts_off)
2034  continue;
2035  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2036  break;
2037 
2038  out_ch = av_mallocz(sizeof(AVChapter));
2039  if (!out_ch)
2040  return AVERROR(ENOMEM);
2041 
2042  out_ch->id = in_ch->id;
2043  out_ch->time_base = in_ch->time_base;
2044  out_ch->start = FFMAX(0, in_ch->start - ts_off);
2045  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2046 
2047  if (copy_metadata)
2048  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2049 
2050  os->chapters[os->nb_chapters++] = out_ch;
2051  }
2052  return 0;
2053 }
2054 
2056  AVFormatContext *oc)
2057 {
2058  OutputStream *ost;
2059 
2060  switch (ofilter->type) {
2061  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2062  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2063  default:
2064  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2065  "currently.\n");
2066  exit_program(1);
2067  }
2068 
2069  ost->source_index = -1;
2070  ost->filter = ofilter;
2071 
2072  ofilter->ost = ost;
2073  ofilter->format = -1;
2074 
2075  if (ost->stream_copy) {
2076  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2077  "which is fed from a complex filtergraph. Filtering and streamcopy "
2078  "cannot be used together.\n", ost->file_index, ost->index);
2079  exit_program(1);
2080  }
2081 
2082  if (ost->avfilter && (ost->filters || ost->filters_script)) {
2083  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2085  "%s '%s' was specified through the %s option "
2086  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2087  "%s and -filter_complex cannot be used together for the same stream.\n",
2088  ost->filters ? "Filtergraph" : "Filtergraph script",
2089  ost->filters ? ost->filters : ost->filters_script,
2090  opt, ost->file_index, ost->index, opt);
2091  exit_program(1);
2092  }
2093 
2094  avfilter_inout_free(&ofilter->out_tmp);
2095 }
2096 
2097 static int init_complex_filters(void)
2098 {
2099  int i, ret = 0;
2100 
2101  for (i = 0; i < nb_filtergraphs; i++) {
2103  if (ret < 0)
2104  return ret;
2105  }
2106  return 0;
2107 }
2108 
2109 static int open_output_file(OptionsContext *o, const char *filename)
2110 {
2111  AVFormatContext *oc;
2112  int i, j, err;
2113  OutputFile *of;
2114  OutputStream *ost;
2115  InputStream *ist;
2116  AVDictionary *unused_opts = NULL;
2117  AVDictionaryEntry *e = NULL;
2118  int format_flags = 0;
2119 
2120  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2121  o->stop_time = INT64_MAX;
2122  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2123  }
2124 
2125  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2126  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2127  if (o->stop_time <= start_time) {
2128  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2129  exit_program(1);
2130  } else {
2132  }
2133  }
2134 
2136  of = av_mallocz(sizeof(*of));
2137  if (!of)
2138  exit_program(1);
2139  output_files[nb_output_files - 1] = of;
2140 
2142  of->recording_time = o->recording_time;
2143  of->start_time = o->start_time;
2144  of->limit_filesize = o->limit_filesize;
2145  of->shortest = o->shortest;
2146  av_dict_copy(&of->opts, o->g->format_opts, 0);
2147 
2148  if (!strcmp(filename, "-"))
2149  filename = "pipe:";
2150 
2151  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2152  if (!oc) {
2153  print_error(filename, err);
2154  exit_program(1);
2155  }
2156 
2157  of->ctx = oc;
2158  if (o->recording_time != INT64_MAX)
2159  oc->duration = o->recording_time;
2160 
2161  oc->interrupt_callback = int_cb;
2162 
2163  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2164  if (e) {
2165  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2166  av_opt_eval_flags(oc, o, e->value, &format_flags);
2167  }
2168  if (o->bitexact) {
2169  format_flags |= AVFMT_FLAG_BITEXACT;
2170  oc->flags |= AVFMT_FLAG_BITEXACT;
2171  }
2172 
2173  /* create streams for all unlabeled output pads */
2174  for (i = 0; i < nb_filtergraphs; i++) {
2175  FilterGraph *fg = filtergraphs[i];
2176  for (j = 0; j < fg->nb_outputs; j++) {
2177  OutputFilter *ofilter = fg->outputs[j];
2178 
2179  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2180  continue;
2181 
2182  switch (ofilter->type) {
2183  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2184  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2185  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2186  }
2187  init_output_filter(ofilter, o, oc);
2188  }
2189  }
2190 
2191  if (!o->nb_stream_maps) {
2192  char *subtitle_codec_name = NULL;
2193  /* pick the "best" stream of each type */
2194 
2195  /* video: highest resolution */
2197  int area = 0, idx = -1;
2198  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2199  for (i = 0; i < nb_input_streams; i++) {
2200  int new_area;
2201  ist = input_streams[i];
2202  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2203  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2204  if (ist->user_set_discard == AVDISCARD_ALL)
2205  continue;
2206  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2207  new_area = 1;
2208  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2209  new_area > area) {
2210  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2211  continue;
2212  area = new_area;
2213  idx = i;
2214  }
2215  }
2216  if (idx >= 0)
2217  new_video_stream(o, oc, idx);
2218  }
2219 
2220  /* audio: most channels */
2222  int best_score = 0, idx = -1;
2223  for (i = 0; i < nb_input_streams; i++) {
2224  int score;
2225  ist = input_streams[i];
2226  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2227  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2228  if (ist->user_set_discard == AVDISCARD_ALL)
2229  continue;
2230  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2231  score > best_score) {
2232  best_score = score;
2233  idx = i;
2234  }
2235  }
2236  if (idx >= 0)
2237  new_audio_stream(o, oc, idx);
2238  }
2239 
2240  /* subtitles: pick first */
2241  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2242  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2243  for (i = 0; i < nb_input_streams; i++)
2244  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2245  AVCodecDescriptor const *input_descriptor =
2246  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2247  AVCodecDescriptor const *output_descriptor = NULL;
2248  AVCodec const *output_codec =
2250  int input_props = 0, output_props = 0;
2251  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2252  continue;
2253  if (output_codec)
2254  output_descriptor = avcodec_descriptor_get(output_codec->id);
2255  if (input_descriptor)
2256  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2257  if (output_descriptor)
2258  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2259  if (subtitle_codec_name ||
2260  input_props & output_props ||
2261  // Map dvb teletext which has neither property to any output subtitle encoder
2262  input_descriptor && output_descriptor &&
2263  (!input_descriptor->props ||
2264  !output_descriptor->props)) {
2265  new_subtitle_stream(o, oc, i);
2266  break;
2267  }
2268  }
2269  }
2270  /* Data only if codec id match */
2271  if (!o->data_disable ) {
2273  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2274  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2275  continue;
2276  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2277  && input_streams[i]->st->codecpar->codec_id == codec_id )
2278  new_data_stream(o, oc, i);
2279  }
2280  }
2281  } else {
2282  for (i = 0; i < o->nb_stream_maps; i++) {
2283  StreamMap *map = &o->stream_maps[i];
2284 
2285  if (map->disabled)
2286  continue;
2287 
2288  if (map->linklabel) {
2289  FilterGraph *fg;
2290  OutputFilter *ofilter = NULL;
2291  int j, k;
2292 
2293  for (j = 0; j < nb_filtergraphs; j++) {
2294  fg = filtergraphs[j];
2295  for (k = 0; k < fg->nb_outputs; k++) {
2296  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2297  if (out && !strcmp(out->name, map->linklabel)) {
2298  ofilter = fg->outputs[k];
2299  goto loop_end;
2300  }
2301  }
2302  }
2303 loop_end:
2304  if (!ofilter) {
2305  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2306  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2307  exit_program(1);
2308  }
2309  init_output_filter(ofilter, o, oc);
2310  } else {
2311  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2312 
2314  if (ist->user_set_discard == AVDISCARD_ALL) {
2315  av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2316  map->file_index, map->stream_index);
2317  exit_program(1);
2318  }
2320  continue;
2322  continue;
2324  continue;
2325  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2326  continue;
2327 
2328  ost = NULL;
2329  switch (ist->st->codecpar->codec_type) {
2330  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2331  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2332  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2333  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2334  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2335  case AVMEDIA_TYPE_UNKNOWN:
2336  if (copy_unknown_streams) {
2337  ost = new_unknown_stream (o, oc, src_idx);
2338  break;
2339  }
2340  default:
2342  "Cannot map stream #%d:%d - unsupported type.\n",
2343  map->file_index, map->stream_index);
2344  if (!ignore_unknown_streams) {
2345  av_log(NULL, AV_LOG_FATAL,
2346  "If you want unsupported types ignored instead "
2347  "of failing, please use the -ignore_unknown option\n"
2348  "If you want them copied, please use -copy_unknown\n");
2349  exit_program(1);
2350  }
2351  }
2352  if (ost)
2353  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2354  + map->sync_stream_index];
2355  }
2356  }
2357  }
2358 
2359  /* handle attached files */
2360  for (i = 0; i < o->nb_attachments; i++) {
2361  AVIOContext *pb;
2362  uint8_t *attachment;
2363  const char *p;
2364  int64_t len;
2365 
2366  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2367  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2368  o->attachments[i]);
2369  exit_program(1);
2370  }
2371  if ((len = avio_size(pb)) <= 0) {
2372  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2373  o->attachments[i]);
2374  exit_program(1);
2375  }
2376  if (!(attachment = av_malloc(len))) {
2377  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2378  o->attachments[i]);
2379  exit_program(1);
2380  }
2381  avio_read(pb, attachment, len);
2382 
2383  ost = new_attachment_stream(o, oc, -1);
2384  ost->stream_copy = 0;
2385  ost->attachment_filename = o->attachments[i];
2386  ost->st->codecpar->extradata = attachment;
2387  ost->st->codecpar->extradata_size = len;
2388 
2389  p = strrchr(o->attachments[i], '/');
2390  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2391  avio_closep(&pb);
2392  }
2393 
2394 #if FF_API_LAVF_AVCTX
2395  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2396  AVDictionaryEntry *e;
2397  ost = output_streams[i];
2398 
2399  if ((ost->stream_copy || ost->attachment_filename)
2400  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2401  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2402  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2403  exit_program(1);
2404  }
2405 #endif
2406 
2407  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2408  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2409  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2410  exit_program(1);
2411  }
2412 
2413  /* check if all codec options have been used */
2414  unused_opts = strip_specifiers(o->g->codec_opts);
2415  for (i = of->ost_index; i < nb_output_streams; i++) {
2416  e = NULL;
2417  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2419  av_dict_set(&unused_opts, e->key, NULL, 0);
2420  }
2421 
2422  e = NULL;
2423  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2424  const AVClass *class = avcodec_get_class();
2425  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2427  const AVClass *fclass = avformat_get_class();
2428  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2430  if (!option || foption)
2431  continue;
2432 
2433 
2434  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2435  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2436  "output file #%d (%s) is not an encoding option.\n", e->key,
2437  option->help ? option->help : "", nb_output_files - 1,
2438  filename);
2439  exit_program(1);
2440  }
2441 
2442  // gop_timecode is injected by generic code but not always used
2443  if (!strcmp(e->key, "gop_timecode"))
2444  continue;
2445 
2446  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2447  "output file #%d (%s) has not been used for any stream. The most "
2448  "likely reason is either wrong type (e.g. a video option with "
2449  "no video streams) or that it is a private option of some encoder "
2450  "which was not actually used for any stream.\n", e->key,
2451  option->help ? option->help : "", nb_output_files - 1, filename);
2452  }
2453  av_dict_free(&unused_opts);
2454 
2455  /* set the decoding_needed flags and create simple filtergraphs */
2456  for (i = of->ost_index; i < nb_output_streams; i++) {
2457  OutputStream *ost = output_streams[i];
2458 
2459  if (ost->encoding_needed && ost->source_index >= 0) {
2460  InputStream *ist = input_streams[ost->source_index];
2462 
2463  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2465  err = init_simple_filtergraph(ist, ost);
2466  if (err < 0) {
2468  "Error initializing a simple filtergraph between streams "
2469  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2470  nb_output_files - 1, ost->st->index);
2471  exit_program(1);
2472  }
2473  }
2474  }
2475 
2476  /* set the filter output constraints */
2477  if (ost->filter) {
2478  OutputFilter *f = ost->filter;
2479  int count;
2480  switch (ost->enc_ctx->codec_type) {
2481  case AVMEDIA_TYPE_VIDEO:
2482  f->frame_rate = ost->frame_rate;
2483  f->width = ost->enc_ctx->width;
2484  f->height = ost->enc_ctx->height;
2485  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2486  f->format = ost->enc_ctx->pix_fmt;
2487  } else if (ost->enc->pix_fmts) {
2488  count = 0;
2489  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2490  count++;
2491  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2492  if (!f->formats)
2493  exit_program(1);
2494  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2495  }
2496  break;
2497  case AVMEDIA_TYPE_AUDIO:
2498  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2499  f->format = ost->enc_ctx->sample_fmt;
2500  } else if (ost->enc->sample_fmts) {
2501  count = 0;
2502  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2503  count++;
2504  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2505  if (!f->formats)
2506  exit_program(1);
2507  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2508  }
2509  if (ost->enc_ctx->sample_rate) {
2510  f->sample_rate = ost->enc_ctx->sample_rate;
2511  } else if (ost->enc->supported_samplerates) {
2512  count = 0;
2513  while (ost->enc->supported_samplerates[count])
2514  count++;
2515  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2516  if (!f->sample_rates)
2517  exit_program(1);
2518  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2519  (count + 1) * sizeof(*f->sample_rates));
2520  }
2521  if (ost->enc_ctx->channels) {
2523  } else if (ost->enc->channel_layouts) {
2524  count = 0;
2525  while (ost->enc->channel_layouts[count])
2526  count++;
2527  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2528  if (!f->channel_layouts)
2529  exit_program(1);
2530  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2531  (count + 1) * sizeof(*f->channel_layouts));
2532  }
2533  break;
2534  }
2535  }
2536  }
2537 
2538  /* check filename in case of an image number is expected */
2539  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2540  if (!av_filename_number_test(oc->url)) {
2541  print_error(oc->url, AVERROR(EINVAL));
2542  exit_program(1);
2543  }
2544  }
2545 
2548  "No input streams but output needs an input stream\n");
2549  exit_program(1);
2550  }
2551 
2552  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2553  /* test if it already exists to avoid losing precious files */
2554  assert_file_overwrite(filename);
2555 
2556  /* open the file */
2557  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2558  &oc->interrupt_callback,
2559  &of->opts)) < 0) {
2560  print_error(filename, err);
2561  exit_program(1);
2562  }
2563  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2564  assert_file_overwrite(filename);
2565 
2566  if (o->mux_preload) {
2567  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2568  }
2569  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2570 
2571  /* copy metadata */
2572  for (i = 0; i < o->nb_metadata_map; i++) {
2573  char *p;
2574  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2575 
2576  if (in_file_index >= nb_input_files) {
2577  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2578  exit_program(1);
2579  }
2580  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2581  in_file_index >= 0 ?
2582  input_files[in_file_index]->ctx : NULL, o);
2583  }
2584 
2585  /* copy chapters */
2586  if (o->chapters_input_file >= nb_input_files) {
2587  if (o->chapters_input_file == INT_MAX) {
2588  /* copy chapters from the first input file that has them*/
2589  o->chapters_input_file = -1;
2590  for (i = 0; i < nb_input_files; i++)
2591  if (input_files[i]->ctx->nb_chapters) {
2592  o->chapters_input_file = i;
2593  break;
2594  }
2595  } else {
2596  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2597  o->chapters_input_file);
2598  exit_program(1);
2599  }
2600  }
2601  if (o->chapters_input_file >= 0)
2604 
2605  /* copy global metadata by default */
2609  if(o->recording_time != INT64_MAX)
2610  av_dict_set(&oc->metadata, "duration", NULL, 0);
2611  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2612  }
2613  if (!o->metadata_streams_manual)
2614  for (i = of->ost_index; i < nb_output_streams; i++) {
2615  InputStream *ist;
2616  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2617  continue;
2619  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2620  if (!output_streams[i]->stream_copy) {
2621  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2622  }
2623  }
2624 
2625  /* process manually set programs */
2626  for (i = 0; i < o->nb_program; i++) {
2627  const char *p = o->program[i].u.str;
2628  int progid = i+1;
2629  AVProgram *program;
2630 
2631  while(*p) {
2632  const char *p2 = av_get_token(&p, ":");
2633  const char *to_dealloc = p2;
2634  char *key;
2635  if (!p2)
2636  break;
2637 
2638  if(*p) p++;
2639 
2640  key = av_get_token(&p2, "=");
2641  if (!key || !*p2) {
2642  av_freep(&to_dealloc);
2643  av_freep(&key);
2644  break;
2645  }
2646  p2++;
2647 
2648  if (!strcmp(key, "program_num"))
2649  progid = strtol(p2, NULL, 0);
2650  av_freep(&to_dealloc);
2651  av_freep(&key);
2652  }
2653 
2654  program = av_new_program(oc, progid);
2655 
2656  p = o->program[i].u.str;
2657  while(*p) {
2658  const char *p2 = av_get_token(&p, ":");
2659  const char *to_dealloc = p2;
2660  char *key;
2661  if (!p2)
2662  break;
2663  if(*p) p++;
2664 
2665  key = av_get_token(&p2, "=");
2666  if (!key) {
2668  "No '=' character in program string %s.\n",
2669  p2);
2670  exit_program(1);
2671  }
2672  if (!*p2)
2673  exit_program(1);
2674  p2++;
2675 
2676  if (!strcmp(key, "title")) {
2677  av_dict_set(&program->metadata, "title", p2, 0);
2678  } else if (!strcmp(key, "program_num")) {
2679  } else if (!strcmp(key, "st")) {
2680  int st_num = strtol(p2, NULL, 0);
2681  av_program_add_stream_index(oc, progid, st_num);
2682  } else {
2683  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2684  exit_program(1);
2685  }
2686  av_freep(&to_dealloc);
2687  av_freep(&key);
2688  }
2689  }
2690 
2691  /* process manually set metadata */
2692  for (i = 0; i < o->nb_metadata; i++) {
2693  AVDictionary **m;
2694  char type, *val;
2695  const char *stream_spec;
2696  int index = 0, j, ret = 0;
2697 
2698  val = strchr(o->metadata[i].u.str, '=');
2699  if (!val) {
2700  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2701  o->metadata[i].u.str);
2702  exit_program(1);
2703  }
2704  *val++ = 0;
2705 
2706  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2707  if (type == 's') {
2708  for (j = 0; j < oc->nb_streams; j++) {
2709  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2710  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2711  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2712  char *tail;
2713  double theta = av_strtod(val, &tail);
2714  if (!*tail) {
2715  ost->rotate_overridden = 1;
2716  ost->rotate_override_value = theta;
2717  }
2718  } else {
2719  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2720  }
2721  } else if (ret < 0)
2722  exit_program(1);
2723  }
2724  }
2725  else {
2726  switch (type) {
2727  case 'g':
2728  m = &oc->metadata;
2729  break;
2730  case 'c':
2731  if (index < 0 || index >= oc->nb_chapters) {
2732  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2733  exit_program(1);
2734  }
2735  m = &oc->chapters[index]->metadata;
2736  break;
2737  case 'p':
2738  if (index < 0 || index >= oc->nb_programs) {
2739  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2740  exit_program(1);
2741  }
2742  m = &oc->programs[index]->metadata;
2743  break;
2744  default:
2745  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2746  exit_program(1);
2747  }
2748  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2749  }
2750  }
2751 
2752  return 0;
2753 }
2754 
2755 static int opt_target(void *optctx, const char *opt, const char *arg)
2756 {
2757  OptionsContext *o = optctx;
2758  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2759  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2760 
2761  if (!strncmp(arg, "pal-", 4)) {
2762  norm = PAL;
2763  arg += 4;
2764  } else if (!strncmp(arg, "ntsc-", 5)) {
2765  norm = NTSC;
2766  arg += 5;
2767  } else if (!strncmp(arg, "film-", 5)) {
2768  norm = FILM;
2769  arg += 5;
2770  } else {
2771  /* Try to determine PAL/NTSC by peeking in the input files */
2772  if (nb_input_files) {
2773  int i, j;
2774  for (j = 0; j < nb_input_files; j++) {
2775  for (i = 0; i < input_files[j]->nb_streams; i++) {
2776  AVStream *st = input_files[j]->ctx->streams[i];
2777  int64_t fr;
2779  continue;
2780  fr = st->time_base.den * 1000LL / st->time_base.num;
2781  if (fr == 25000) {
2782  norm = PAL;
2783  break;
2784  } else if ((fr == 29970) || (fr == 23976)) {
2785  norm = NTSC;
2786  break;
2787  }
2788  }
2789  if (norm != UNKNOWN)
2790  break;
2791  }
2792  }
2793  if (norm != UNKNOWN)
2794  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2795  }
2796 
2797  if (norm == UNKNOWN) {
2798  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2799  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2800  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2801  exit_program(1);
2802  }
2803 
2804  if (!strcmp(arg, "vcd")) {
2805  opt_video_codec(o, "c:v", "mpeg1video");
2806  opt_audio_codec(o, "c:a", "mp2");
2807  parse_option(o, "f", "vcd", options);
2808 
2809  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2810  parse_option(o, "r", frame_rates[norm], options);
2811  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2812 
2813  opt_default(NULL, "b:v", "1150000");
2814  opt_default(NULL, "maxrate:v", "1150000");
2815  opt_default(NULL, "minrate:v", "1150000");
2816  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2817 
2818  opt_default(NULL, "b:a", "224000");
2819  parse_option(o, "ar", "44100", options);
2820  parse_option(o, "ac", "2", options);
2821 
2822  opt_default(NULL, "packetsize", "2324");
2823  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2824 
2825  /* We have to offset the PTS, so that it is consistent with the SCR.
2826  SCR starts at 36000, but the first two packs contain only padding
2827  and the first pack from the other stream, respectively, may also have
2828  been written before.
2829  So the real data starts at SCR 36000+3*1200. */
2830  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2831  } else if (!strcmp(arg, "svcd")) {
2832 
2833  opt_video_codec(o, "c:v", "mpeg2video");
2834  opt_audio_codec(o, "c:a", "mp2");
2835  parse_option(o, "f", "svcd", options);
2836 
2837  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2838  parse_option(o, "r", frame_rates[norm], options);
2839  parse_option(o, "pix_fmt", "yuv420p", options);
2840  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2841 
2842  opt_default(NULL, "b:v", "2040000");
2843  opt_default(NULL, "maxrate:v", "2516000");
2844  opt_default(NULL, "minrate:v", "0"); // 1145000;
2845  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2846  opt_default(NULL, "scan_offset", "1");
2847 
2848  opt_default(NULL, "b:a", "224000");
2849  parse_option(o, "ar", "44100", options);
2850 
2851  opt_default(NULL, "packetsize", "2324");
2852 
2853  } else if (!strcmp(arg, "dvd")) {
2854 
2855  opt_video_codec(o, "c:v", "mpeg2video");
2856  opt_audio_codec(o, "c:a", "ac3");
2857  parse_option(o, "f", "dvd", options);
2858 
2859  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2860  parse_option(o, "r", frame_rates[norm], options);
2861  parse_option(o, "pix_fmt", "yuv420p", options);
2862  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2863 
2864  opt_default(NULL, "b:v", "6000000");
2865  opt_default(NULL, "maxrate:v", "9000000");
2866  opt_default(NULL, "minrate:v", "0"); // 1500000;
2867  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2868 
2869  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2870  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2871 
2872  opt_default(NULL, "b:a", "448000");
2873  parse_option(o, "ar", "48000", options);
2874 
2875  } else if (!strncmp(arg, "dv", 2)) {
2876 
2877  parse_option(o, "f", "dv", options);
2878 
2879  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2880  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2881  norm == PAL ? "yuv420p" : "yuv411p", options);
2882  parse_option(o, "r", frame_rates[norm], options);
2883 
2884  parse_option(o, "ar", "48000", options);
2885  parse_option(o, "ac", "2", options);
2886 
2887  } else {
2888  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2889  return AVERROR(EINVAL);
2890  }
2891 
2894 
2895  return 0;
2896 }
2897 
2898 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2899 {
2901  vstats_filename = av_strdup (arg);
2902  return 0;
2903 }
2904 
2905 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2906 {
2907  char filename[40];
2908  time_t today2 = time(NULL);
2909  struct tm *today = localtime(&today2);
2910 
2911  if (!today) { // maybe tomorrow
2912  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2913  exit_program(1);
2914  }
2915 
2916  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2917  today->tm_sec);
2918  return opt_vstats_file(NULL, opt, filename);
2919 }
2920 
2921 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2922 {
2923  OptionsContext *o = optctx;
2924  return parse_option(o, "frames:v", arg, options);
2925 }
2926 
2927 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2928 {
2929  OptionsContext *o = optctx;
2930  return parse_option(o, "frames:a", arg, options);
2931 }
2932 
2933 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2934 {
2935  OptionsContext *o = optctx;
2936  return parse_option(o, "frames:d", arg, options);
2937 }
2938 
2939 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2940 {
2941  int ret;
2942  AVDictionary *cbak = codec_opts;
2943  AVDictionary *fbak = format_opts;
2944  codec_opts = NULL;
2945  format_opts = NULL;
2946 
2947  ret = opt_default(NULL, opt, arg);
2948 
2949  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2953  codec_opts = cbak;
2954  format_opts = fbak;
2955 
2956  return ret;
2957 }
2958 
2959 static int opt_preset(void *optctx, const char *opt, const char *arg)
2960 {
2961  OptionsContext *o = optctx;
2962  FILE *f=NULL;
2963  char filename[1000], line[1000], tmp_line[1000];
2964  const char *codec_name = NULL;
2965 
2966  tmp_line[0] = *opt;
2967  tmp_line[1] = 0;
2968  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2969 
2970  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2971  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2972  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2973  }else
2974  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2975  exit_program(1);
2976  }
2977 
2978  while (fgets(line, sizeof(line), f)) {
2979  char *key = tmp_line, *value, *endptr;
2980 
2981  if (strcspn(line, "#\n\r") == 0)
2982  continue;
2983  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2984  if (!av_strtok(key, "=", &value) ||
2985  !av_strtok(value, "\r\n", &endptr)) {
2986  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2987  exit_program(1);
2988  }
2989  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2990 
2991  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2992  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2993  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2994  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2995  else if (opt_default_new(o, key, value) < 0) {
2996  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2997  filename, line, key, value);
2998  exit_program(1);
2999  }
3000  }
3001 
3002  fclose(f);
3003 
3004  return 0;
3005 }
3006 
3007 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3008 {
3009  OptionsContext *o = optctx;
3010  int ret;
3011  char *s = av_asprintf("%s:%c", opt + 1, *opt);
3012  if (!s)
3013  return AVERROR(ENOMEM);
3014  ret = parse_option(o, s, arg, options);
3015  av_free(s);
3016  return ret;
3017 }
3018 
3019 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3020 {
3021  OptionsContext *o = optctx;
3022 
3023  if(!strcmp(opt, "ab")){
3024  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3025  return 0;
3026  } else if(!strcmp(opt, "b")){
3027  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3028  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3029  return 0;
3030  }
3031  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3032  return 0;
3033 }
3034 
3035 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3036 {
3037  OptionsContext *o = optctx;
3038  char *s;
3039  int ret;
3040  if(!strcmp(opt, "qscale")){
3041  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3042  return parse_option(o, "q:v", arg, options);
3043  }
3044  s = av_asprintf("q%s", opt + 6);
3045  if (!s)
3046  return AVERROR(ENOMEM);
3047  ret = parse_option(o, s, arg, options);
3048  av_free(s);
3049  return ret;
3050 }
3051 
3052 static int opt_profile(void *optctx, const char *opt, const char *arg)
3053 {
3054  OptionsContext *o = optctx;
3055  if(!strcmp(opt, "profile")){
3056  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3057  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3058  return 0;
3059  }
3060  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3061  return 0;
3062 }
3063 
3064 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3065 {
3066  OptionsContext *o = optctx;
3067  return parse_option(o, "filter:v", arg, options);
3068 }
3069 
3070 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3071 {
3072  OptionsContext *o = optctx;
3073  return parse_option(o, "filter:a", arg, options);
3074 }
3075 
3076 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3077 {
3078  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3079  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3080  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3081  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3082 
3085  return 0;
3086 }
3087 
3088 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3089 {
3090  OptionsContext *o = optctx;
3091  int ret;
3092  char *tcr = av_asprintf("timecode=%s", arg);
3093  if (!tcr)
3094  return AVERROR(ENOMEM);
3095  ret = parse_option(o, "metadata:g", tcr, options);
3096  if (ret >= 0)
3097  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3098  av_free(tcr);
3099  return ret;
3100 }
3101 
3102 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3103 {
3104  OptionsContext *o = optctx;
3105  char layout_str[32];
3106  char *stream_str;
3107  char *ac_str;
3108  int ret, channels, ac_str_size;
3109  uint64_t layout;
3110 
3111  layout = av_get_channel_layout(arg);
3112  if (!layout) {
3113  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3114  return AVERROR(EINVAL);
3115  }
3116  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3117  ret = opt_default_new(o, opt, layout_str);
3118  if (ret < 0)
3119  return ret;
3120 
3121  /* set 'ac' option based on channel layout */
3122  channels = av_get_channel_layout_nb_channels(layout);
3123  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3124  stream_str = strchr(opt, ':');
3125  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3126  ac_str = av_mallocz(ac_str_size);
3127  if (!ac_str)
3128  return AVERROR(ENOMEM);
3129  av_strlcpy(ac_str, "ac", 3);
3130  if (stream_str)
3131  av_strlcat(ac_str, stream_str, ac_str_size);
3132  ret = parse_option(o, ac_str, layout_str, options);
3133  av_free(ac_str);
3134 
3135  return ret;
3136 }
3137 
3138 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3139 {
3140  OptionsContext *o = optctx;
3141  return parse_option(o, "q:a", arg, options);
3142 }
3143 
3144 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3145 {
3147  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3148  return AVERROR(ENOMEM);
3151  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3152  return AVERROR(ENOMEM);
3153 
3155 
3156  return 0;
3157 }
3158 
3159 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3160 {
3161  uint8_t *graph_desc = read_file(arg);
3162  if (!graph_desc)
3163  return AVERROR(EINVAL);
3164 
3166  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3167  return AVERROR(ENOMEM);
3169  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3170 
3172 
3173  return 0;
3174 }
3175 
3176 void show_help_default(const char *opt, const char *arg)
3177 {
3178  /* per-file options have at least one of those set */
3179  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3180  int show_advanced = 0, show_avoptions = 0;
3181 
3182  if (opt && *opt) {
3183  if (!strcmp(opt, "long"))
3184  show_advanced = 1;
3185  else if (!strcmp(opt, "full"))
3186  show_advanced = show_avoptions = 1;
3187  else
3188  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3189  }
3190 
3191  show_usage();
3192 
3193  printf("Getting help:\n"
3194  " -h -- print basic options\n"
3195  " -h long -- print more options\n"
3196  " -h full -- print all options (including all format and codec specific options, very long)\n"
3197  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3198  " See man %s for detailed description of the options.\n"
3199  "\n", program_name);
3200 
3201  show_help_options(options, "Print help / information / capabilities:",
3202  OPT_EXIT, 0, 0);
3203 
3204  show_help_options(options, "Global options (affect whole program "
3205  "instead of just one file:",
3206  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3207  if (show_advanced)
3208  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3209  per_file | OPT_EXIT, 0);
3210 
3211  show_help_options(options, "Per-file main options:", 0,
3213  OPT_EXIT, per_file);
3214  if (show_advanced)
3215  show_help_options(options, "Advanced per-file options:",
3216  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3217 
3218  show_help_options(options, "Video options:",
3220  if (show_advanced)
3221  show_help_options(options, "Advanced Video options:",
3223 
3224  show_help_options(options, "Audio options:",
3226  if (show_advanced)
3227  show_help_options(options, "Advanced Audio options:",
3229  show_help_options(options, "Subtitle options:",
3230  OPT_SUBTITLE, 0, 0);
3231  printf("\n");
3232 
3233  if (show_avoptions) {
3237 #if CONFIG_SWSCALE
3239 #endif
3240 #if CONFIG_SWRESAMPLE
3242 #endif
3245  }
3246 }
3247 
3248 void show_usage(void)
3249 {
3250  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3251  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3252  av_log(NULL, AV_LOG_INFO, "\n");
3253 }
3254 
3255 enum OptGroup {
3258 };
3259 
3260 static const OptionGroupDef groups[] = {
3261  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3262  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3263 };
3264 
3265 static int open_files(OptionGroupList *l, const char *inout,
3266  int (*open_file)(OptionsContext*, const char*))
3267 {
3268  int i, ret;
3269 
3270  for (i = 0; i < l->nb_groups; i++) {
3271  OptionGroup *g = &l->groups[i];
3272  OptionsContext o;
3273 
3274  init_options(&o);
3275  o.g = g;
3276 
3277  ret = parse_optgroup(&o, g);
3278  if (ret < 0) {
3279  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3280  "%s.\n", inout, g->arg);
3281  return ret;
3282  }
3283 
3284  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3285  ret = open_file(&o, g->arg);
3286  uninit_options(&o);
3287  if (ret < 0) {
3288  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3289  inout, g->arg);
3290  return ret;
3291  }
3292  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3293  }
3294 
3295  return 0;
3296 }
3297 
3298 int ffmpeg_parse_options(int argc, char **argv)
3299 {
3300  OptionParseContext octx;
3301  uint8_t error[128];
3302  int ret;
3303 
3304  memset(&octx, 0, sizeof(octx));
3305 
3306  /* split the commandline into an internal representation */
3307  ret = split_commandline(&octx, argc, argv, options, groups,
3308  FF_ARRAY_ELEMS(groups));
3309  if (ret < 0) {
3310  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3311  goto fail;
3312  }
3313 
3314  /* apply global options */
3315  ret = parse_optgroup(NULL, &octx.global_opts);
3316  if (ret < 0) {
3317  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3318  goto fail;
3319  }
3320 
3321  /* configure terminal and setup signal handlers */
3322  term_init();
3323 
3324  /* open input files */
3325  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3326  if (ret < 0) {
3327  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3328  goto fail;
3329  }
3330 
3331  /* create the complex filtergraphs */
3332  ret = init_complex_filters();
3333  if (ret < 0) {
3334  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3335  goto fail;
3336  }
3337 
3338  /* open output files */
3339  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3340  if (ret < 0) {
3341  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3342  goto fail;
3343  }
3344 
3346 
3347 fail:
3348  uninit_parse_context(&octx);
3349  if (ret < 0) {
3350  av_strerror(ret, error, sizeof(error));
3351  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3352  }
3353  return ret;
3354 }
3355 
3356 static int opt_progress(void *optctx, const char *opt, const char *arg)
3357 {
3358  AVIOContext *avio = NULL;
3359  int ret;
3360 
3361  if (!strcmp(arg, "-"))
3362  arg = "pipe:";
3363  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3364  if (ret < 0) {
3365  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3366  arg, av_err2str(ret));
3367  return ret;
3368  }
3369  progress_avio = avio;
3370  return 0;
3371 }
3372 
3373 #define OFFSET(x) offsetof(OptionsContext, x)
3374 const OptionDef options[] = {
3375  /* main options */
3377  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3378  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3379  "force format", "fmt" },
3380  { "y", OPT_BOOL, { &file_overwrite },
3381  "overwrite output files" },
3382  { "n", OPT_BOOL, { &no_file_overwrite },
3383  "never overwrite output files" },
3384  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3385  "Ignore unknown stream types" },
3386  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3387  "Copy unknown stream types" },
3388  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3389  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3390  "codec name", "codec" },
3391  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3392  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3393  "codec name", "codec" },
3394  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3395  OPT_OUTPUT, { .off = OFFSET(presets) },
3396  "preset name", "preset" },
3397  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3398  OPT_OUTPUT, { .func_arg = opt_map },
3399  "set input stream mapping",
3400  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3401  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3402  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3403  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3404  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3405  "set metadata information of outfile from infile",
3406  "outfile[,metadata]:infile[,metadata]" },
3407  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3408  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3409  "set chapters mapping", "input_file_index" },
3410  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3411  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3412  "record or transcode \"duration\" seconds of audio/video",
3413  "duration" },
3414  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3415  "record or transcode stop time", "time_stop" },
3416  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3417  "set the limit file size in bytes", "limit_size" },
3418  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3419  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3420  "set the start time offset", "time_off" },
3421  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3422  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3423  "set the start time offset relative to EOF", "time_off" },
3424  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3425  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3426  "enable/disable seeking by timestamp with -ss" },
3427  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3428  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3429  "enable/disable accurate seeking with -ss" },
3430  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3431  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3432  "set the input ts offset", "time_off" },
3433  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3434  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3435  "set the input ts scale", "scale" },
3436  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3437  "set the recording timestamp ('now' to set the current time)", "time" },
3438  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3439  "add metadata", "string=string" },
3440  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3441  "add program with specified streams", "title=string:st=number..." },
3442  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3443  OPT_OUTPUT, { .func_arg = opt_data_frames },
3444  "set the number of data frames to output", "number" },
3445  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3446  "add timings for benchmarking" },
3447  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3448  "add timings for each task" },
3449  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3450  "write program-readable progress information", "url" },
3451  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3452  "enable or disable interaction on standard input" },
3453  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3454  "set max runtime in seconds in CPU user time", "limit" },
3455  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3456  "dump each input packet" },
3457  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3458  "when dumping packets, also dump the payload" },
3459  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3460  OPT_INPUT, { .off = OFFSET(rate_emu) },
3461  "read input at native frame rate", "" },
3462  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3463  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3464  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3465  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3466  "video sync method", "" },
3467  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3468  "frame drop threshold", "" },
3469  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3470  "audio sync method", "" },
3471  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3472  "audio drift threshold", "threshold" },
3473  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3474  "copy timestamps" },
3475  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3476  "shift input timestamps to start at 0 when using copyts" },
3477  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3478  "copy input stream time base when stream copying", "mode" },
3479  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3480  OPT_OUTPUT, { .off = OFFSET(shortest) },
3481  "finish encoding within shortest input" },
3482  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3483  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3484  "bitexact mode" },
3485  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3486  OPT_OUTPUT, { .off = OFFSET(apad) },
3487  "audio pad", "" },
3488  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3489  "timestamp discontinuity delta threshold", "threshold" },
3490  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3491  "timestamp error delta threshold", "threshold" },
3492  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3493  "exit on error", "error" },
3494  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3495  "abort on the specified condition flags", "flags" },
3496  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3497  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3498  "copy initial non-keyframes" },
3499  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3500  "copy or discard frames before start time" },
3501  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3502  "set the number of frames to output", "number" },
3503  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3504  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3505  "force codec tag/fourcc", "fourcc/tag" },
3506  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3507  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3508  "use fixed quality scale (VBR)", "q" },
3509  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3510  OPT_OUTPUT, { .func_arg = opt_qscale },
3511  "use fixed quality scale (VBR)", "q" },
3512  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3513  "set profile", "profile" },
3514  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3515  "set stream filtergraph", "filter_graph" },
3516  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3517  "number of non-complex filter threads" },
3518  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3519  "read stream filtergraph description from a file", "filename" },
3520  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3521  "reinit filtergraph on input parameter changes", "" },
3522  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3523  "create a complex filtergraph", "graph_description" },
3524  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3525  "number of threads for -filter_complex" },
3526  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3527  "create a complex filtergraph", "graph_description" },
3528  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3529  "read complex filtergraph description from a file", "filename" },
3530  { "stats", OPT_BOOL, { &print_stats },
3531  "print progress report during encoding", },
3532  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3533  OPT_OUTPUT, { .func_arg = opt_attach },
3534  "add an attachment to the output file", "filename" },
3535  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3536  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3537  "extract an attachment into a file", "filename" },
3538  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3539  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3540  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3541  "print timestamp debugging info" },
3542  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3543  "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3544  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3545  OPT_INPUT, { .off = OFFSET(discard) },
3546  "discard", "" },
3547  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3548  OPT_OUTPUT, { .off = OFFSET(disposition) },
3549  "disposition", "" },
3550  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3551  { .off = OFFSET(thread_queue_size) },
3552  "set the maximum number of queued packets from the demuxer" },
3553  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3554  "read and decode the streams to fill missing information with heuristics" },
3555 
3556  /* video options */
3557  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3558  "set the number of video frames to output", "number" },
3559  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3560  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3561  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3563  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3564  "set frame size (WxH or abbreviation)", "size" },
3565  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3566  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3567  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3568  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3569  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3570  "set pixel format", "format" },
3571  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3572  "set the number of bits per raw sample", "number" },
3573  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3574  "deprecated use -g 1" },
3576  "disable video" },
3577  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3578  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3579  "rate control override for specific intervals", "override" },
3580  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3581  OPT_OUTPUT, { .func_arg = opt_video_codec },
3582  "force video codec ('copy' to copy stream)", "codec" },
3583  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3584  "Removed" },
3585  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3586  "Removed" },
3587  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3588  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3589  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3590  "select the pass number (1 to 3)", "n" },
3591  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3592  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3593  "select two pass log file name prefix", "prefix" },
3594  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3595  "this option is deprecated, use the yadif filter instead" },
3596  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3597  "calculate PSNR of compressed frames" },
3598  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3599  "dump video coding statistics to file" },
3600  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3601  "dump video coding statistics to file", "file" },
3602  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3603  "Version of the vstats format to use."},
3604  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3605  "set video filters", "filter_graph" },
3606  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3607  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3608  "specify intra matrix coeffs", "matrix" },
3609  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3610  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3611  "specify inter matrix coeffs", "matrix" },
3612  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3613  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3614  "specify intra matrix coeffs", "matrix" },
3615  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3616  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3617  "top=1/bottom=0/auto=-1 field first", "" },
3618  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3619  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3620  "force video tag/fourcc", "fourcc/tag" },
3621  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3622  "show QP histogram" },
3623  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3624  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3625  "force the selected framerate, disable the best supported framerate selection" },
3626  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3627  OPT_OUTPUT, { .func_arg = opt_streamid },
3628  "set the value of an outfile streamid", "streamIndex:value" },
3629  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3630  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3631  "force key frames at specified timestamps", "timestamps" },
3632  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3633  "audio bitrate (please use -b:a)", "bitrate" },
3634  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3635  "video bitrate (please use -b:v)", "bitrate" },
3636  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3637  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3638  "use HW accelerated decoding", "hwaccel name" },
3639  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3640  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3641  "select a device for HW acceleration", "devicename" },
3642  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3643  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3644  "select output format used with HW accelerated decoding", "format" },
3645 #if CONFIG_VIDEOTOOLBOX
3646  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3647 #endif
3648  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3649  "show available HW acceleration methods" },
3650  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3651  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3652  "automatically insert correct rotate filters" },
3653 
3654  /* audio options */
3655  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3656  "set the number of audio frames to output", "number" },
3657  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3658  "set audio quality (codec-specific)", "quality", },
3659  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3660  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3661  "set audio sampling rate (in Hz)", "rate" },
3662  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3663  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3664  "set number of audio channels", "channels" },
3666  "disable audio" },
3667  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3668  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3669  "force audio codec ('copy' to copy stream)", "codec" },
3670  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3671  OPT_OUTPUT, { .func_arg = opt_old2new },
3672  "force audio tag/fourcc", "fourcc/tag" },
3673  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3674  "change audio volume (256=normal)" , "volume" },
3675  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3677  "set sample format", "format" },
3678  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3679  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3680  "set channel layout", "layout" },
3681  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3682  "set audio filters", "filter_graph" },
3683  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3684  "set the maximum number of channels to try to guess the channel layout" },
3685 
3686  /* subtitle options */
3688  "disable subtitle" },
3689  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3690  "force subtitle codec ('copy' to copy stream)", "codec" },
3691  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3692  , "force subtitle tag/fourcc", "fourcc/tag" },
3693  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3694  "fix subtitles duration" },
3695  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3696  "set canvas size (WxH or abbreviation)", "size" },
3697 
3698  /* grab options */
3699  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3700  "deprecated, use -channel", "channel" },
3701  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3702  "deprecated, use -standard", "standard" },
3703  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3704 
3705  /* muxer options */
3706  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3707  "set the maximum demux-decode delay", "seconds" },
3708  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3709  "set the initial demux-decode delay", "seconds" },
3710  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3711  "specify a file in which to print sdp information", "file" },
3712 
3713  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3714  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3715  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3716  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3717  "two special values are defined - "
3718  "0 = use frame rate (video) or sample rate (audio),"
3719  "-1 = match source time base", "ratio" },
3720 
3721  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3722  "A comma-separated list of bitstream filters", "bitstream_filters" },
3723  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3724  "deprecated", "audio bitstream_filters" },
3725  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3726  "deprecated", "video bitstream_filters" },
3727 
3728  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3729  "set the audio options to the indicated preset", "preset" },
3730  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3731  "set the video options to the indicated preset", "preset" },
3732  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3733  "set the subtitle options to the indicated preset", "preset" },
3734  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3735  "set options from indicated preset file", "filename" },
3736 
3737  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3738  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3739 
3740  /* data codec support */
3741  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3742  "force data codec ('copy' to copy stream)", "codec" },
3743  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3744  "disable data" },
3745 
3746 #if CONFIG_VAAPI
3747  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3748  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3749 #endif
3750 
3751 #if CONFIG_QSV
3752  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3753  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3754 #endif
3755 
3756  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3757  "initialise hardware device", "args" },
3758  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3759  "set hardware device used when filtering", "device" },
3760 
3761  { NULL, },
3762 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
int nb_bitstream_filters
Definition: ffmpeg.h:462
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:54
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1187
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:414
AVRational enc_timebase
Definition: ffmpeg.h:460
char * vstats_filename
Definition: ffmpeg_opt.c:84
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
int nb_dump_attachment
Definition: ffmpeg.h:127
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2070
void show_usage(void)
Definition: ffmpeg_opt.c:3248
int nb_metadata
Definition: ffmpeg.h:168
int nb_streamid_map
Definition: ffmpeg.h:165
#define NULL
Definition: coverity.c:32
int width
Definition: ffmpeg.h:270
AVRational framerate
Definition: avcodec.h:3108
const char const char void * val
Definition: avisynth_c.h:863
int audio_sync_method
Definition: ffmpeg_opt.c:92
AVDictionary * resample_opts
Definition: cmdutils.h:320
int keep_pix_fmt
Definition: ffmpeg.h:528
Bytestream IO Context.
Definition: avio.h:161
float mux_preload
Definition: ffmpeg.h:153
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:514
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5842
#define OPT_EXPERT
Definition: cmdutils.h:163
int start_at_zero
Definition: ffmpeg_opt.c:101
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:558
void term_init(void)
Definition: ffmpeg.c:387
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:339
int nb_outputs
Definition: ffmpeg.h:292
int copy_tb
Definition: ffmpeg_opt.c:102
char * qsv_device
Definition: ffmpeg_qsv.c:31
AVDictionary * swr_opts
Definition: ffmpeg.h:509
int qp_hist
Definition: ffmpeg_opt.c:107
AVDictionary * swr_opts
Definition: cmdutils.h:322
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
void term_exit(void)
Definition: ffmpeg.c:328
int stream_copy
Definition: ffmpeg.h:514
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:891
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2933
int do_benchmark
Definition: ffmpeg_opt.c:96
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1636
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1459
AVOption.
Definition: opt.h:246
AVRational frame_rate
Definition: ffmpeg.h:477
int audio_channels
Definition: rtp.c:40
int64_t start_time_eof
Definition: ffmpeg.h:100
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:148
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c:2055
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:504
static AVInputFormat * file_iformat
Definition: ffplay.c:310
#define OPT_VIDEO
Definition: cmdutils.h:165
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1756
int data_disable
Definition: ffmpeg.h:161
float mux_max_delay
Definition: ffmpeg.h:154
int accurate_seek
Definition: ffmpeg.h:413
int64_t forced_kf_ref_pts
Definition: ffmpeg.h:487
int * streamid_map
Definition: ffmpeg.h:164
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int video_sync_method
Definition: ffmpeg_opt.c:93
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:139
static void assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:923
int ostream_idx
Definition: ffmpeg.h:92
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static int input_sync
Definition: ffmpeg_opt.c:120
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:78
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:753
AVRational framerate
Definition: ffmpeg.h:333
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
enum AVCodecID video_codec
default video codec
Definition: avformat.h:516
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2078
channels
Definition: aptx.c:30
#define OPT_AUDIO
Definition: cmdutils.h:166
int64_t max_pts
Definition: ffmpeg.h:322
enum AVCodecID codec_id
Definition: qsv.c:77
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
AVFilterInOut * out_tmp
Definition: ffmpeg.h:266
int bitexact
Definition: ffmpeg.h:156
int decoding_needed
Definition: ffmpeg.h:300
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int qscale
Definition: avcodec.h:836
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int rotate_overridden
Definition: ffmpeg.h:481
int index
stream index in AVFormatContext
Definition: avformat.h:882
int max_muxing_queue_size
Definition: ffmpeg.h:542
int nb_frame_pix_fmts
Definition: ffmpeg.h:115
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int do_deinterlace
Definition: ffmpeg_opt.c:95
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3070
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1941
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1947
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:783
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
Convenience header that includes libavutil&#39;s core.
const char * arg
Definition: cmdutils.h:313
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3144
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:539
int cuvid_init(AVCodecContext *s)
Definition: ffmpeg_cuvid.c:30
#define OPT_DATA
Definition: cmdutils.h:172
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2595
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:2012
enum AVMediaType type
Definition: avcodec.h:3505
int nb_program
Definition: ffmpeg.h:228
const char * key
static int file_overwrite
Definition: ffmpeg_opt.c:117
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1352
discard all
Definition: avcodec.h:814
static int find_stream_info
Definition: ffmpeg_opt.c:124
int64_t input_ts_offset
Definition: ffmpeg.h:402
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2799
int nb_input_streams
Definition: ffmpeg.c:148
static int audio_disable
Definition: ffplay.c:319
const char * name
Definition: ffmpeg.h:68
AVDictionary * metadata
Definition: avformat.h:1319
static const char * audio_codec_name
Definition: ffplay.c:344
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1317
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5795
#define OPT_DOUBLE
Definition: cmdutils.h:180
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1556
#define OPT_FLOAT
Definition: cmdutils.h:168
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
AVCodec.
Definition: avcodec.h:3492
int framerate
Definition: h264_levels.c:65
#define VSYNC_VFR
Definition: ffmpeg.h:52
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:215
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2086
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3960
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:559
int index
Definition: ffmpeg.h:283
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2959
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:463
Definition: ftp.c:34
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:114
uint8_t base
Definition: vp3data.h:202
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:262
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:47
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:727
int encoding_needed
Definition: ffmpeg.h:447
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3138
Format I/O context.
Definition: avformat.h:1358
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:294
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:479
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:82
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1529
enum HWAccelID id
Definition: ffmpeg.h:70
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
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:72
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:119
const char * name
Definition: opt.h:247
char * logfile_prefix
Definition: ffmpeg.h:499
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1492
int user_set_discard
Definition: ffmpeg.h:299
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:122
static int64_t start_time
Definition: ffplay.c:331
int copy_initial_nonkeyframes
Definition: ffmpeg.h:524
int filter_nbthreads
Definition: ffmpeg_opt.c:111
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:524
uint8_t
static int nb_streams
Definition: ffprobe.c:280
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:508
Opaque data information usually continuous.
Definition: avutil.h:203
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:545
#define OPT_OUTPUT
Definition: cmdutils.h:182
int width
Video only.
Definition: avcodec.h:4034
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:668
#define HAS_ARG
Definition: cmdutils.h:161
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2019
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:998
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3260
FILE * logfile
Definition: ffmpeg.h:500
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:471
#define f(width, name)
Definition: cbs_vp9.c:255
AVDictionary * opts
Definition: ffmpeg.h:556
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:3207
int id
unique ID to identify the chapter
Definition: avformat.h:1316
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
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3076
int id
Format-specific stream ID.
Definition: avformat.h:888
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define OPT_OFFSET
Definition: cmdutils.h:175
int vstats_version
Definition: ffmpeg_opt.c:113
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4502
int nb_max_frames
Definition: ffmpeg.h:170
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
int shortest
Definition: ffmpeg.h:562
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2905
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2115
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
int channel_idx
Definition: ffmpeg.h:91
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:679
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:40
int nb_streams
Definition: ffmpeg.h:409
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
int sync_file_index
Definition: ffmpeg.h:85
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4601
AVDictionary * resample_opts
Definition: ffmpeg.h:510
int seek_timestamp
Definition: ffmpeg.h:101
uint32_t tag
Definition: movenc.c:1531
int * formats
Definition: ffmpeg.h:277
#define OPT_SPEC
Definition: cmdutils.h:176
int nb_input_files
Definition: ffmpeg.c:150
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2807
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:170
int init_complex_filtergraph(FilterGraph *fg)
int print_stats
Definition: ffmpeg_opt.c:106
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:177
AVCodec * dec
Definition: ffmpeg.h:305
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
const OptionDef options[]
Definition: ffmpeg_opt.c:3374
int top_field_first
Definition: ffmpeg.h:334
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
int nb_output_streams
Definition: ffmpeg.c:153
int file_index
Definition: ffmpeg.h:296
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1544
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:319
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:650
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:250
float quality_factor
Definition: avcodec.h:837
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3035
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2143
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:919
AVDictionary * format_opts
Definition: cmdutils.c:73
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1962
#define OPT_SUBTITLE
Definition: cmdutils.h:169
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
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, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:578
uint64_t channel_layout
Definition: ffmpeg.h:274
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:112
enum AVCodecID id
Definition: avcodec.h:3506
int rate_emu
Definition: ffmpeg.h:412
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3052
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
void check_filter_outputs(void)
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:374
FilterGraph ** filtergraphs
Definition: ffmpeg.c:157
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter