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