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 
1106  if (o->start_time_eof != AV_NOPTS_VALUE) {
1107  if (ic->duration>0) {
1108  o->start_time = o->start_time_eof + ic->duration;
1109  } else
1110  av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1111  }
1112  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1113  /* add the stream start time */
1114  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1115  timestamp += ic->start_time;
1116 
1117  /* if seeking requested, we execute it */
1118  if (o->start_time != AV_NOPTS_VALUE) {
1119  int64_t seek_timestamp = timestamp;
1120 
1121  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1122  int dts_heuristic = 0;
1123  for (i=0; i<ic->nb_streams; i++) {
1124  const AVCodecParameters *par = ic->streams[i]->codecpar;
1125  if (par->video_delay)
1126  dts_heuristic = 1;
1127  }
1128  if (dts_heuristic) {
1129  seek_timestamp -= 3*AV_TIME_BASE / 23;
1130  }
1131  }
1132  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1133  if (ret < 0) {
1134  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1135  filename, (double)timestamp / AV_TIME_BASE);
1136  }
1137  }
1138 
1139  /* update the current parameters so that they match the one of the input stream */
1140  add_input_streams(o, ic);
1141 
1142  /* dump the file content */
1143  av_dump_format(ic, nb_input_files, filename, 0);
1144 
1146  f = av_mallocz(sizeof(*f));
1147  if (!f)
1148  exit_program(1);
1149  input_files[nb_input_files - 1] = f;
1150 
1151  f->ctx = ic;
1153  f->start_time = o->start_time;
1156  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1157  f->nb_streams = ic->nb_streams;
1158  f->rate_emu = o->rate_emu;
1159  f->accurate_seek = o->accurate_seek;
1160  f->loop = o->loop;
1161  f->duration = 0;
1162  f->time_base = (AVRational){ 1, 1 };
1163 #if HAVE_THREADS
1164  f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1165 #endif
1166 
1167  /* check if all codec options have been used */
1168  unused_opts = strip_specifiers(o->g->codec_opts);
1169  for (i = f->ist_index; i < nb_input_streams; i++) {
1170  e = NULL;
1171  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1173  av_dict_set(&unused_opts, e->key, NULL, 0);
1174  }
1175 
1176  e = NULL;
1177  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1178  const AVClass *class = avcodec_get_class();
1179  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1181  const AVClass *fclass = avformat_get_class();
1182  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1184  if (!option || foption)
1185  continue;
1186 
1187 
1188  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1189  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1190  "input file #%d (%s) is not a decoding option.\n", e->key,
1191  option->help ? option->help : "", nb_input_files - 1,
1192  filename);
1193  exit_program(1);
1194  }
1195 
1196  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1197  "input file #%d (%s) has not been used for any stream. The most "
1198  "likely reason is either wrong type (e.g. a video option with "
1199  "no video streams) or that it is a private option of some decoder "
1200  "which was not actually used for any stream.\n", e->key,
1201  option->help ? option->help : "", nb_input_files - 1, filename);
1202  }
1203  av_dict_free(&unused_opts);
1204 
1205  for (i = 0; i < o->nb_dump_attachment; i++) {
1206  int j;
1207 
1208  for (j = 0; j < ic->nb_streams; j++) {
1209  AVStream *st = ic->streams[j];
1210 
1211  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1212  dump_attachment(st, o->dump_attachment[i].u.str);
1213  }
1214  }
1215 
1217 
1218  return 0;
1219 }
1220 
1222 {
1223  AVIOContext *line;
1224  uint8_t *buf;
1225  char c;
1226 
1227  if (avio_open_dyn_buf(&line) < 0) {
1228  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1229  exit_program(1);
1230  }
1231 
1232  while ((c = avio_r8(s)) && c != '\n')
1233  avio_w8(line, c);
1234  avio_w8(line, 0);
1235  avio_close_dyn_buf(line, &buf);
1236 
1237  return buf;
1238 }
1239 
1240 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1241 {
1242  int i, ret = -1;
1243  char filename[1000];
1244  const char *base[3] = { getenv("AVCONV_DATADIR"),
1245  getenv("HOME"),
1246  AVCONV_DATADIR,
1247  };
1248 
1249  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1250  if (!base[i])
1251  continue;
1252  if (codec_name) {
1253  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1254  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1255  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1256  }
1257  if (ret < 0) {
1258  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1259  i != 1 ? "" : "/.avconv", preset_name);
1260  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1261  }
1262  }
1263  return ret;
1264 }
1265 
1267 {
1268  enum AVMediaType type = ost->st->codecpar->codec_type;
1269  char *codec_name = NULL;
1270 
1271  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1272  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1273  if (!codec_name) {
1274  ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1275  NULL, ost->st->codecpar->codec_type);
1276  ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1277  if (!ost->enc) {
1278  av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1279  "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1280  "probably disabled. Please choose an encoder manually.\n",
1281  ost->file_index, ost->index, s->oformat->name,
1284  }
1285  } else if (!strcmp(codec_name, "copy"))
1286  ost->stream_copy = 1;
1287  else {
1288  ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1289  ost->st->codecpar->codec_id = ost->enc->id;
1290  }
1291  ost->encoding_needed = !ost->stream_copy;
1292  } else {
1293  /* no encoding supported for other media types */
1294  ost->stream_copy = 1;
1295  ost->encoding_needed = 0;
1296  }
1297 
1298  return 0;
1299 }
1300 
1302 {
1303  OutputStream *ost;
1304  AVStream *st = avformat_new_stream(oc, NULL);
1305  int idx = oc->nb_streams - 1, ret = 0;
1306  const char *bsfs = NULL, *time_base = NULL;
1307  char *next, *codec_tag = NULL;
1308  double qscale = -1;
1309  int i;
1310 
1311  if (!st) {
1312  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1313  exit_program(1);
1314  }
1315 
1316  if (oc->nb_streams - 1 < o->nb_streamid_map)
1317  st->id = o->streamid_map[oc->nb_streams - 1];
1318 
1320  if (!(ost = av_mallocz(sizeof(*ost))))
1321  exit_program(1);
1323 
1324  ost->file_index = nb_output_files - 1;
1325  ost->index = idx;
1326  ost->st = st;
1328  st->codecpar->codec_type = type;
1329 
1330  ret = choose_encoder(o, oc, ost);
1331  if (ret < 0) {
1332  av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1333  "%d:%d\n", ost->file_index, ost->index);
1334  exit_program(1);
1335  }
1336 
1337  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1338  if (!ost->enc_ctx) {
1339  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1340  exit_program(1);
1341  }
1342  ost->enc_ctx->codec_type = type;
1343 
1345  if (!ost->ref_par) {
1346  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1347  exit_program(1);
1348  }
1349 
1350  if (ost->enc) {
1351  AVIOContext *s = NULL;
1352  char *buf = NULL, *arg = NULL, *preset = NULL;
1353 
1354  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1355 
1356  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1357  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1358  do {
1359  buf = get_line(s);
1360  if (!buf[0] || buf[0] == '#') {
1361  av_free(buf);
1362  continue;
1363  }
1364  if (!(arg = strchr(buf, '='))) {
1365  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1366  exit_program(1);
1367  }
1368  *arg++ = 0;
1370  av_free(buf);
1371  } while (!s->eof_reached);
1372  avio_closep(&s);
1373  }
1374  if (ret) {
1376  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1377  preset, ost->file_index, ost->index);
1378  exit_program(1);
1379  }
1380  } else {
1382  }
1383 
1384 
1385  if (o->bitexact)
1387 
1388  MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1389  if (time_base) {
1390  AVRational q;
1391  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1392  q.num <= 0 || q.den <= 0) {
1393  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1394  exit_program(1);
1395  }
1396  st->time_base = q;
1397  }
1398 
1399  MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1400  if (time_base) {
1401  AVRational q;
1402  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1403  q.den <= 0) {
1404  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1405  exit_program(1);
1406  }
1407  ost->enc_timebase = q;
1408  }
1409 
1410  ost->max_frames = INT64_MAX;
1411  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1412  for (i = 0; i<o->nb_max_frames; i++) {
1413  char *p = o->max_frames[i].specifier;
1414  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1415  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1416  break;
1417  }
1418  }
1419 
1420  ost->copy_prior_start = -1;
1421  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1422 
1423  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1424  while (bsfs && *bsfs) {
1425  const AVBitStreamFilter *filter;
1426  char *bsf, *bsf_options_str, *bsf_name;
1427 
1428  bsf = av_get_token(&bsfs, ",");
1429  if (!bsf)
1430  exit_program(1);
1431  bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1432  if (!bsf_name)
1433  exit_program(1);
1434 
1435  filter = av_bsf_get_by_name(bsf_name);
1436  if (!filter) {
1437  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1438  exit_program(1);
1439  }
1440 
1441  ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1442  ost->nb_bitstream_filters + 1,
1443  sizeof(*ost->bsf_ctx));
1444  if (!ost->bsf_ctx)
1445  exit_program(1);
1446 
1447  ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1448  if (ret < 0) {
1449  av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1450  exit_program(1);
1451  }
1452 
1453  ost->nb_bitstream_filters++;
1454 
1455  if (bsf_options_str && filter->priv_class) {
1456  const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1457  const char * shorthand[2] = {NULL};
1458 
1459  if (opt)
1460  shorthand[0] = opt->name;
1461 
1462  ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1463  if (ret < 0) {
1464  av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1465  exit_program(1);
1466  }
1467  }
1468  av_freep(&bsf);
1469 
1470  if (*bsfs)
1471  bsfs++;
1472  }
1473 
1474  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1475  if (codec_tag) {
1476  uint32_t tag = strtol(codec_tag, &next, 0);
1477  if (*next)
1478  tag = AV_RL32(codec_tag);
1479  ost->st->codecpar->codec_tag =
1480  ost->enc_ctx->codec_tag = tag;
1481  }
1482 
1483  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1484  if (qscale >= 0) {
1486  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1487  }
1488 
1489  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1490  ost->disposition = av_strdup(ost->disposition);
1491 
1492  ost->max_muxing_queue_size = 128;
1493  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1494  ost->max_muxing_queue_size *= sizeof(AVPacket);
1495 
1496  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1498 
1499  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1500 
1501  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1502  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1503  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1504 
1505  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1506 
1507  ost->source_index = source_index;
1508  if (source_index >= 0) {
1509  ost->sync_ist = input_streams[source_index];
1510  input_streams[source_index]->discard = 0;
1511  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1512  }
1514 
1515  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1516  if (!ost->muxing_queue)
1517  exit_program(1);
1518 
1519  return ost;
1520 }
1521 
1522 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1523 {
1524  int i;
1525  const char *p = str;
1526  for (i = 0;; i++) {
1527  dest[i] = atoi(p);
1528  if (i == 63)
1529  break;
1530  p = strchr(p, ',');
1531  if (!p) {
1532  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1533  exit_program(1);
1534  }
1535  p++;
1536  }
1537 }
1538 
1539 /* read file contents into a string */
1540 static uint8_t *read_file(const char *filename)
1541 {
1542  AVIOContext *pb = NULL;
1543  AVIOContext *dyn_buf = NULL;
1544  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1545  uint8_t buf[1024], *str;
1546 
1547  if (ret < 0) {
1548  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1549  return NULL;
1550  }
1551 
1552  ret = avio_open_dyn_buf(&dyn_buf);
1553  if (ret < 0) {
1554  avio_closep(&pb);
1555  return NULL;
1556  }
1557  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1558  avio_write(dyn_buf, buf, ret);
1559  avio_w8(dyn_buf, 0);
1560  avio_closep(&pb);
1561 
1562  ret = avio_close_dyn_buf(dyn_buf, &str);
1563  if (ret < 0)
1564  return NULL;
1565  return str;
1566 }
1567 
1569  OutputStream *ost)
1570 {
1571  AVStream *st = ost->st;
1572 
1573  if (ost->filters_script && ost->filters) {
1574  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1575  "output stream #%d:%d.\n", nb_output_files, st->index);
1576  exit_program(1);
1577  }
1578 
1579  if (ost->filters_script)
1580  return read_file(ost->filters_script);
1581  else if (ost->filters)
1582  return av_strdup(ost->filters);
1583 
1585  "null" : "anull");
1586 }
1587 
1589  const OutputStream *ost, enum AVMediaType type)
1590 {
1591  if (ost->filters_script || ost->filters) {
1593  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1594  "Filtering and streamcopy cannot be used together.\n",
1595  ost->filters ? "Filtergraph" : "Filtergraph script",
1596  ost->filters ? ost->filters : ost->filters_script,
1597  av_get_media_type_string(type), ost->file_index, ost->index);
1598  exit_program(1);
1599  }
1600 }
1601 
1603 {
1604  AVStream *st;
1605  OutputStream *ost;
1606  AVCodecContext *video_enc;
1607  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1608 
1609  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1610  st = ost->st;
1611  video_enc = ost->enc_ctx;
1612 
1613  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1614  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1615  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1616  exit_program(1);
1617  }
1618  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1619  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1620 
1621  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1622  if (frame_aspect_ratio) {
1623  AVRational q;
1624  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1625  q.num <= 0 || q.den <= 0) {
1626  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1627  exit_program(1);
1628  }
1629  ost->frame_aspect_ratio = q;
1630  }
1631 
1632  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1633  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1634 
1635  if (!ost->stream_copy) {
1636  const char *p = NULL;
1637  char *frame_size = NULL;
1638  char *frame_pix_fmt = NULL;
1639  char *intra_matrix = NULL, *inter_matrix = NULL;
1640  char *chroma_intra_matrix = NULL;
1641  int do_pass = 0;
1642  int i;
1643 
1644  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1645  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1646  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1647  exit_program(1);
1648  }
1649 
1651  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1652  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1653  ost->keep_pix_fmt = 1;
1654  if (!*++frame_pix_fmt)
1655  frame_pix_fmt = NULL;
1656  }
1657  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1658  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1659  exit_program(1);
1660  }
1661  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1662 
1663  if (intra_only)
1664  video_enc->gop_size = 0;
1665  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1666  if (intra_matrix) {
1667  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1668  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1669  exit_program(1);
1670  }
1671  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1672  }
1673  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1674  if (chroma_intra_matrix) {
1675  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1676  if (!p) {
1677  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1678  exit_program(1);
1679  }
1680  video_enc->chroma_intra_matrix = p;
1681  parse_matrix_coeffs(p, chroma_intra_matrix);
1682  }
1683  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1684  if (inter_matrix) {
1685  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1686  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1687  exit_program(1);
1688  }
1689  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1690  }
1691 
1692  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1693  for (i = 0; p; i++) {
1694  int start, end, q;
1695  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1696  if (e != 3) {
1697  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1698  exit_program(1);
1699  }
1700  video_enc->rc_override =
1701  av_realloc_array(video_enc->rc_override,
1702  i + 1, sizeof(RcOverride));
1703  if (!video_enc->rc_override) {
1704  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1705  exit_program(1);
1706  }
1707  video_enc->rc_override[i].start_frame = start;
1708  video_enc->rc_override[i].end_frame = end;
1709  if (q > 0) {
1710  video_enc->rc_override[i].qscale = q;
1711  video_enc->rc_override[i].quality_factor = 1.0;
1712  }
1713  else {
1714  video_enc->rc_override[i].qscale = 0;
1715  video_enc->rc_override[i].quality_factor = -q/100.0;
1716  }
1717  p = strchr(p, '/');
1718  if (p) p++;
1719  }
1720  video_enc->rc_override_count = i;
1721 
1722  if (do_psnr)
1723  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1724 
1725  /* two pass mode */
1726  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1727  if (do_pass) {
1728  if (do_pass & 1) {
1729  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1730  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1731  }
1732  if (do_pass & 2) {
1733  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1734  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1735  }
1736  }
1737 
1738  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1739  if (ost->logfile_prefix &&
1740  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1741  exit_program(1);
1742 
1743  if (do_pass) {
1744  char logfilename[1024];
1745  FILE *f;
1746 
1747  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1748  ost->logfile_prefix ? ost->logfile_prefix :
1750  i);
1751  if (!strcmp(ost->enc->name, "libx264")) {
1752  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1753  } else {
1754  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1755  char *logbuffer = read_file(logfilename);
1756 
1757  if (!logbuffer) {
1758  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1759  logfilename);
1760  exit_program(1);
1761  }
1762  video_enc->stats_in = logbuffer;
1763  }
1764  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1765  f = av_fopen_utf8(logfilename, "wb");
1766  if (!f) {
1768  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1769  logfilename, strerror(errno));
1770  exit_program(1);
1771  }
1772  ost->logfile = f;
1773  }
1774  }
1775  }
1776 
1777  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1778  if (ost->forced_keyframes)
1780 
1781  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1782 
1783  ost->top_field_first = -1;
1784  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1785 
1786 
1787  ost->avfilter = get_ost_filters(o, oc, ost);
1788  if (!ost->avfilter)
1789  exit_program(1);
1790  } else {
1791  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1792  }
1793 
1794  if (ost->stream_copy)
1796 
1797  return ost;
1798 }
1799 
1801 {
1802  int n;
1803  AVStream *st;
1804  OutputStream *ost;
1805  AVCodecContext *audio_enc;
1806 
1807  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1808  st = ost->st;
1809 
1810  audio_enc = ost->enc_ctx;
1811  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1812 
1813  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1814  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1815 
1816  if (!ost->stream_copy) {
1817  char *sample_fmt = NULL;
1818 
1819  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1820 
1821  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1822  if (sample_fmt &&
1823  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1824  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1825  exit_program(1);
1826  }
1827 
1828  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1829 
1830  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1831  ost->apad = av_strdup(ost->apad);
1832 
1833  ost->avfilter = get_ost_filters(o, oc, ost);
1834  if (!ost->avfilter)
1835  exit_program(1);
1836 
1837  /* check for channel mapping for this audio stream */
1838  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1840  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1841  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1842  InputStream *ist;
1843 
1844  if (map->channel_idx == -1) {
1845  ist = NULL;
1846  } else if (ost->source_index < 0) {
1847  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1848  ost->file_index, ost->st->index);
1849  continue;
1850  } else {
1851  ist = input_streams[ost->source_index];
1852  }
1853 
1854  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1856  ost->audio_channels_mapped + 1,
1857  sizeof(*ost->audio_channels_map)
1858  ) < 0 )
1859  exit_program(1);
1860 
1862  }
1863  }
1864  }
1865  }
1866 
1867  if (ost->stream_copy)
1869 
1870  return ost;
1871 }
1872 
1874 {
1875  OutputStream *ost;
1876 
1877  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1878  if (!ost->stream_copy) {
1879  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1880  exit_program(1);
1881  }
1882 
1883  return ost;
1884 }
1885 
1887 {
1888  OutputStream *ost;
1889 
1890  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1891  if (!ost->stream_copy) {
1892  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1893  exit_program(1);
1894  }
1895 
1896  return ost;
1897 }
1898 
1900 {
1901  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1902  ost->stream_copy = 1;
1903  ost->finished = 1;
1904  return ost;
1905 }
1906 
1908 {
1909  AVStream *st;
1910  OutputStream *ost;
1911  AVCodecContext *subtitle_enc;
1912 
1913  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1914  st = ost->st;
1915  subtitle_enc = ost->enc_ctx;
1916 
1917  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1918 
1919  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1920 
1921  if (!ost->stream_copy) {
1922  char *frame_size = NULL;
1923 
1924  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1925  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1926  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1927  exit_program(1);
1928  }
1929  }
1930 
1931  return ost;
1932 }
1933 
1934 /* arg format is "output-stream-index:streamid-value". */
1935 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1936 {
1937  OptionsContext *o = optctx;
1938  int idx;
1939  char *p;
1940  char idx_str[16];
1941 
1942  av_strlcpy(idx_str, arg, sizeof(idx_str));
1943  p = strchr(idx_str, ':');
1944  if (!p) {
1946  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1947  arg, opt);
1948  exit_program(1);
1949  }
1950  *p++ = '\0';
1951  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1952  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1953  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1954  return 0;
1955 }
1956 
1958 {
1959  AVFormatContext *is = ifile->ctx;
1960  AVFormatContext *os = ofile->ctx;
1961  AVChapter **tmp;
1962  int i;
1963 
1964  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1965  if (!tmp)
1966  return AVERROR(ENOMEM);
1967  os->chapters = tmp;
1968 
1969  for (i = 0; i < is->nb_chapters; i++) {
1970  AVChapter *in_ch = is->chapters[i], *out_ch;
1971  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1972  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1973  AV_TIME_BASE_Q, in_ch->time_base);
1974  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1976 
1977 
1978  if (in_ch->end < ts_off)
1979  continue;
1980  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1981  break;
1982 
1983  out_ch = av_mallocz(sizeof(AVChapter));
1984  if (!out_ch)
1985  return AVERROR(ENOMEM);
1986 
1987  out_ch->id = in_ch->id;
1988  out_ch->time_base = in_ch->time_base;
1989  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1990  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1991 
1992  if (copy_metadata)
1993  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1994 
1995  os->chapters[os->nb_chapters++] = out_ch;
1996  }
1997  return 0;
1998 }
1999 
2001  AVFormatContext *oc)
2002 {
2003  OutputStream *ost;
2004 
2005  switch (ofilter->type) {
2006  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2007  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2008  default:
2009  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2010  "currently.\n");
2011  exit_program(1);
2012  }
2013 
2014  ost->source_index = -1;
2015  ost->filter = ofilter;
2016 
2017  ofilter->ost = ost;
2018  ofilter->format = -1;
2019 
2020  if (ost->stream_copy) {
2021  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2022  "which is fed from a complex filtergraph. Filtering and streamcopy "
2023  "cannot be used together.\n", ost->file_index, ost->index);
2024  exit_program(1);
2025  }
2026 
2027  if (ost->avfilter && (ost->filters || ost->filters_script)) {
2028  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2030  "%s '%s' was specified through the %s option "
2031  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2032  "%s and -filter_complex cannot be used together for the same stream.\n",
2033  ost->filters ? "Filtergraph" : "Filtergraph script",
2034  ost->filters ? ost->filters : ost->filters_script,
2035  opt, ost->file_index, ost->index, opt);
2036  exit_program(1);
2037  }
2038 
2039  avfilter_inout_free(&ofilter->out_tmp);
2040 }
2041 
2042 static int init_complex_filters(void)
2043 {
2044  int i, ret = 0;
2045 
2046  for (i = 0; i < nb_filtergraphs; i++) {
2048  if (ret < 0)
2049  return ret;
2050  }
2051  return 0;
2052 }
2053 
2054 static int open_output_file(OptionsContext *o, const char *filename)
2055 {
2056  AVFormatContext *oc;
2057  int i, j, err;
2058  OutputFile *of;
2059  OutputStream *ost;
2060  InputStream *ist;
2061  AVDictionary *unused_opts = NULL;
2062  AVDictionaryEntry *e = NULL;
2063  int format_flags = 0;
2064 
2065  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2066  o->stop_time = INT64_MAX;
2067  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2068  }
2069 
2070  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2071  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2072  if (o->stop_time <= start_time) {
2073  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2074  exit_program(1);
2075  } else {
2077  }
2078  }
2079 
2081  of = av_mallocz(sizeof(*of));
2082  if (!of)
2083  exit_program(1);
2084  output_files[nb_output_files - 1] = of;
2085 
2087  of->recording_time = o->recording_time;
2088  of->start_time = o->start_time;
2089  of->limit_filesize = o->limit_filesize;
2090  of->shortest = o->shortest;
2091  av_dict_copy(&of->opts, o->g->format_opts, 0);
2092 
2093  if (!strcmp(filename, "-"))
2094  filename = "pipe:";
2095 
2096  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2097  if (!oc) {
2098  print_error(filename, err);
2099  exit_program(1);
2100  }
2101 
2102  of->ctx = oc;
2103  if (o->recording_time != INT64_MAX)
2104  oc->duration = o->recording_time;
2105 
2106  oc->interrupt_callback = int_cb;
2107 
2108  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2109  if (e) {
2110  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2111  av_opt_eval_flags(oc, o, e->value, &format_flags);
2112  }
2113  if (o->bitexact) {
2114  format_flags |= AVFMT_FLAG_BITEXACT;
2115  oc->flags |= AVFMT_FLAG_BITEXACT;
2116  }
2117 
2118  /* create streams for all unlabeled output pads */
2119  for (i = 0; i < nb_filtergraphs; i++) {
2120  FilterGraph *fg = filtergraphs[i];
2121  for (j = 0; j < fg->nb_outputs; j++) {
2122  OutputFilter *ofilter = fg->outputs[j];
2123 
2124  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2125  continue;
2126 
2127  switch (ofilter->type) {
2128  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2129  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2130  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2131  }
2132  init_output_filter(ofilter, o, oc);
2133  }
2134  }
2135 
2136  if (!o->nb_stream_maps) {
2137  char *subtitle_codec_name = NULL;
2138  /* pick the "best" stream of each type */
2139 
2140  /* video: highest resolution */
2142  int area = 0, idx = -1;
2143  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2144  for (i = 0; i < nb_input_streams; i++) {
2145  int new_area;
2146  ist = input_streams[i];
2147  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2148  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2149  new_area = 1;
2150  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2151  new_area > area) {
2152  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2153  continue;
2154  area = new_area;
2155  idx = i;
2156  }
2157  }
2158  if (idx >= 0)
2159  new_video_stream(o, oc, idx);
2160  }
2161 
2162  /* audio: most channels */
2164  int best_score = 0, idx = -1;
2165  for (i = 0; i < nb_input_streams; i++) {
2166  int score;
2167  ist = input_streams[i];
2168  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2169  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2170  score > best_score) {
2171  best_score = score;
2172  idx = i;
2173  }
2174  }
2175  if (idx >= 0)
2176  new_audio_stream(o, oc, idx);
2177  }
2178 
2179  /* subtitles: pick first */
2180  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2181  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2182  for (i = 0; i < nb_input_streams; i++)
2183  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2184  AVCodecDescriptor const *input_descriptor =
2185  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2186  AVCodecDescriptor const *output_descriptor = NULL;
2187  AVCodec const *output_codec =
2189  int input_props = 0, output_props = 0;
2190  if (output_codec)
2191  output_descriptor = avcodec_descriptor_get(output_codec->id);
2192  if (input_descriptor)
2193  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2194  if (output_descriptor)
2195  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2196  if (subtitle_codec_name ||
2197  input_props & output_props ||
2198  // Map dvb teletext which has neither property to any output subtitle encoder
2199  input_descriptor && output_descriptor &&
2200  (!input_descriptor->props ||
2201  !output_descriptor->props)) {
2202  new_subtitle_stream(o, oc, i);
2203  break;
2204  }
2205  }
2206  }
2207  /* Data only if codec id match */
2208  if (!o->data_disable ) {
2210  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2211  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2212  && input_streams[i]->st->codecpar->codec_id == codec_id )
2213  new_data_stream(o, oc, i);
2214  }
2215  }
2216  } else {
2217  for (i = 0; i < o->nb_stream_maps; i++) {
2218  StreamMap *map = &o->stream_maps[i];
2219 
2220  if (map->disabled)
2221  continue;
2222 
2223  if (map->linklabel) {
2224  FilterGraph *fg;
2225  OutputFilter *ofilter = NULL;
2226  int j, k;
2227 
2228  for (j = 0; j < nb_filtergraphs; j++) {
2229  fg = filtergraphs[j];
2230  for (k = 0; k < fg->nb_outputs; k++) {
2231  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2232  if (out && !strcmp(out->name, map->linklabel)) {
2233  ofilter = fg->outputs[k];
2234  goto loop_end;
2235  }
2236  }
2237  }
2238 loop_end:
2239  if (!ofilter) {
2240  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2241  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2242  exit_program(1);
2243  }
2244  init_output_filter(ofilter, o, oc);
2245  } else {
2246  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2247 
2250  continue;
2252  continue;
2254  continue;
2255  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2256  continue;
2257 
2258  ost = NULL;
2259  switch (ist->st->codecpar->codec_type) {
2260  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2261  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2262  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2263  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2264  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2265  case AVMEDIA_TYPE_UNKNOWN:
2266  if (copy_unknown_streams) {
2267  ost = new_unknown_stream (o, oc, src_idx);
2268  break;
2269  }
2270  default:
2272  "Cannot map stream #%d:%d - unsupported type.\n",
2273  map->file_index, map->stream_index);
2274  if (!ignore_unknown_streams) {
2275  av_log(NULL, AV_LOG_FATAL,
2276  "If you want unsupported types ignored instead "
2277  "of failing, please use the -ignore_unknown option\n"
2278  "If you want them copied, please use -copy_unknown\n");
2279  exit_program(1);
2280  }
2281  }
2282  if (ost)
2283  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2284  + map->sync_stream_index];
2285  }
2286  }
2287  }
2288 
2289  /* handle attached files */
2290  for (i = 0; i < o->nb_attachments; i++) {
2291  AVIOContext *pb;
2292  uint8_t *attachment;
2293  const char *p;
2294  int64_t len;
2295 
2296  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2297  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2298  o->attachments[i]);
2299  exit_program(1);
2300  }
2301  if ((len = avio_size(pb)) <= 0) {
2302  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2303  o->attachments[i]);
2304  exit_program(1);
2305  }
2306  if (!(attachment = av_malloc(len))) {
2307  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2308  o->attachments[i]);
2309  exit_program(1);
2310  }
2311  avio_read(pb, attachment, len);
2312 
2313  ost = new_attachment_stream(o, oc, -1);
2314  ost->stream_copy = 0;
2315  ost->attachment_filename = o->attachments[i];
2316  ost->st->codecpar->extradata = attachment;
2317  ost->st->codecpar->extradata_size = len;
2318 
2319  p = strrchr(o->attachments[i], '/');
2320  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2321  avio_closep(&pb);
2322  }
2323 
2324 #if FF_API_LAVF_AVCTX
2325  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2326  AVDictionaryEntry *e;
2327  ost = output_streams[i];
2328 
2329  if ((ost->stream_copy || ost->attachment_filename)
2330  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2331  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2332  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2333  exit_program(1);
2334  }
2335 #endif
2336 
2337  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2338  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2339  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2340  exit_program(1);
2341  }
2342 
2343  /* check if all codec options have been used */
2344  unused_opts = strip_specifiers(o->g->codec_opts);
2345  for (i = of->ost_index; i < nb_output_streams; i++) {
2346  e = NULL;
2347  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2349  av_dict_set(&unused_opts, e->key, NULL, 0);
2350  }
2351 
2352  e = NULL;
2353  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2354  const AVClass *class = avcodec_get_class();
2355  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2357  const AVClass *fclass = avformat_get_class();
2358  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2360  if (!option || foption)
2361  continue;
2362 
2363 
2364  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2365  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2366  "output file #%d (%s) is not an encoding option.\n", e->key,
2367  option->help ? option->help : "", nb_output_files - 1,
2368  filename);
2369  exit_program(1);
2370  }
2371 
2372  // gop_timecode is injected by generic code but not always used
2373  if (!strcmp(e->key, "gop_timecode"))
2374  continue;
2375 
2376  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2377  "output file #%d (%s) has not been used for any stream. The most "
2378  "likely reason is either wrong type (e.g. a video option with "
2379  "no video streams) or that it is a private option of some encoder "
2380  "which was not actually used for any stream.\n", e->key,
2381  option->help ? option->help : "", nb_output_files - 1, filename);
2382  }
2383  av_dict_free(&unused_opts);
2384 
2385  /* set the decoding_needed flags and create simple filtergraphs */
2386  for (i = of->ost_index; i < nb_output_streams; i++) {
2387  OutputStream *ost = output_streams[i];
2388 
2389  if (ost->encoding_needed && ost->source_index >= 0) {
2390  InputStream *ist = input_streams[ost->source_index];
2392 
2393  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2395  err = init_simple_filtergraph(ist, ost);
2396  if (err < 0) {
2398  "Error initializing a simple filtergraph between streams "
2399  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2400  nb_output_files - 1, ost->st->index);
2401  exit_program(1);
2402  }
2403  }
2404  }
2405 
2406  /* set the filter output constraints */
2407  if (ost->filter) {
2408  OutputFilter *f = ost->filter;
2409  int count;
2410  switch (ost->enc_ctx->codec_type) {
2411  case AVMEDIA_TYPE_VIDEO:
2412  f->frame_rate = ost->frame_rate;
2413  f->width = ost->enc_ctx->width;
2414  f->height = ost->enc_ctx->height;
2415  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2416  f->format = ost->enc_ctx->pix_fmt;
2417  } else if (ost->enc->pix_fmts) {
2418  count = 0;
2419  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2420  count++;
2421  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2422  if (!f->formats)
2423  exit_program(1);
2424  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2425  }
2426  break;
2427  case AVMEDIA_TYPE_AUDIO:
2428  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2429  f->format = ost->enc_ctx->sample_fmt;
2430  } else if (ost->enc->sample_fmts) {
2431  count = 0;
2432  while (ost->enc->sample_fmts[count] != AV_SAMPLE_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->sample_fmts, (count + 1) * sizeof(*f->formats));
2438  }
2439  if (ost->enc_ctx->sample_rate) {
2440  f->sample_rate = ost->enc_ctx->sample_rate;
2441  } else if (ost->enc->supported_samplerates) {
2442  count = 0;
2443  while (ost->enc->supported_samplerates[count])
2444  count++;
2445  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2446  if (!f->sample_rates)
2447  exit_program(1);
2448  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2449  (count + 1) * sizeof(*f->sample_rates));
2450  }
2451  if (ost->enc_ctx->channels) {
2453  } else if (ost->enc->channel_layouts) {
2454  count = 0;
2455  while (ost->enc->channel_layouts[count])
2456  count++;
2457  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2458  if (!f->channel_layouts)
2459  exit_program(1);
2460  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2461  (count + 1) * sizeof(*f->channel_layouts));
2462  }
2463  break;
2464  }
2465  }
2466  }
2467 
2468  /* check filename in case of an image number is expected */
2469  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2470  if (!av_filename_number_test(oc->url)) {
2471  print_error(oc->url, AVERROR(EINVAL));
2472  exit_program(1);
2473  }
2474  }
2475 
2478  "No input streams but output needs an input stream\n");
2479  exit_program(1);
2480  }
2481 
2482  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2483  /* test if it already exists to avoid losing precious files */
2484  assert_file_overwrite(filename);
2485 
2486  /* open the file */
2487  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2488  &oc->interrupt_callback,
2489  &of->opts)) < 0) {
2490  print_error(filename, err);
2491  exit_program(1);
2492  }
2493  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2494  assert_file_overwrite(filename);
2495 
2496  if (o->mux_preload) {
2497  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2498  }
2499  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2500 
2501  /* copy metadata */
2502  for (i = 0; i < o->nb_metadata_map; i++) {
2503  char *p;
2504  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2505 
2506  if (in_file_index >= nb_input_files) {
2507  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2508  exit_program(1);
2509  }
2510  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2511  in_file_index >= 0 ?
2512  input_files[in_file_index]->ctx : NULL, o);
2513  }
2514 
2515  /* copy chapters */
2516  if (o->chapters_input_file >= nb_input_files) {
2517  if (o->chapters_input_file == INT_MAX) {
2518  /* copy chapters from the first input file that has them*/
2519  o->chapters_input_file = -1;
2520  for (i = 0; i < nb_input_files; i++)
2521  if (input_files[i]->ctx->nb_chapters) {
2522  o->chapters_input_file = i;
2523  break;
2524  }
2525  } else {
2526  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2527  o->chapters_input_file);
2528  exit_program(1);
2529  }
2530  }
2531  if (o->chapters_input_file >= 0)
2534 
2535  /* copy global metadata by default */
2539  if(o->recording_time != INT64_MAX)
2540  av_dict_set(&oc->metadata, "duration", NULL, 0);
2541  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2542  }
2543  if (!o->metadata_streams_manual)
2544  for (i = of->ost_index; i < nb_output_streams; i++) {
2545  InputStream *ist;
2546  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2547  continue;
2549  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2550  if (!output_streams[i]->stream_copy) {
2551  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2552  }
2553  }
2554 
2555  /* process manually set programs */
2556  for (i = 0; i < o->nb_program; i++) {
2557  const char *p = o->program[i].u.str;
2558  int progid = i+1;
2559  AVProgram *program;
2560 
2561  while(*p) {
2562  const char *p2 = av_get_token(&p, ":");
2563  const char *to_dealloc = p2;
2564  char *key;
2565  if (!p2)
2566  break;
2567 
2568  if(*p) p++;
2569 
2570  key = av_get_token(&p2, "=");
2571  if (!key || !*p2) {
2572  av_freep(&to_dealloc);
2573  av_freep(&key);
2574  break;
2575  }
2576  p2++;
2577 
2578  if (!strcmp(key, "program_num"))
2579  progid = strtol(p2, NULL, 0);
2580  av_freep(&to_dealloc);
2581  av_freep(&key);
2582  }
2583 
2584  program = av_new_program(oc, progid);
2585 
2586  p = o->program[i].u.str;
2587  while(*p) {
2588  const char *p2 = av_get_token(&p, ":");
2589  const char *to_dealloc = p2;
2590  char *key;
2591  if (!p2)
2592  break;
2593  if(*p) p++;
2594 
2595  key = av_get_token(&p2, "=");
2596  if (!key) {
2598  "No '=' character in program string %s.\n",
2599  p2);
2600  exit_program(1);
2601  }
2602  if (!*p2)
2603  exit_program(1);
2604  p2++;
2605 
2606  if (!strcmp(key, "title")) {
2607  av_dict_set(&program->metadata, "title", p2, 0);
2608  } else if (!strcmp(key, "program_num")) {
2609  } else if (!strcmp(key, "st")) {
2610  int st_num = strtol(p2, NULL, 0);
2611  av_program_add_stream_index(oc, progid, st_num);
2612  } else {
2613  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2614  exit_program(1);
2615  }
2616  av_freep(&to_dealloc);
2617  av_freep(&key);
2618  }
2619  }
2620 
2621  /* process manually set metadata */
2622  for (i = 0; i < o->nb_metadata; i++) {
2623  AVDictionary **m;
2624  char type, *val;
2625  const char *stream_spec;
2626  int index = 0, j, ret = 0;
2627 
2628  val = strchr(o->metadata[i].u.str, '=');
2629  if (!val) {
2630  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2631  o->metadata[i].u.str);
2632  exit_program(1);
2633  }
2634  *val++ = 0;
2635 
2636  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2637  if (type == 's') {
2638  for (j = 0; j < oc->nb_streams; j++) {
2639  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2640  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2641  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2642  char *tail;
2643  double theta = av_strtod(val, &tail);
2644  if (!*tail) {
2645  ost->rotate_overridden = 1;
2646  ost->rotate_override_value = theta;
2647  }
2648  } else {
2649  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2650  }
2651  } else if (ret < 0)
2652  exit_program(1);
2653  }
2654  }
2655  else {
2656  switch (type) {
2657  case 'g':
2658  m = &oc->metadata;
2659  break;
2660  case 'c':
2661  if (index < 0 || index >= oc->nb_chapters) {
2662  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2663  exit_program(1);
2664  }
2665  m = &oc->chapters[index]->metadata;
2666  break;
2667  case 'p':
2668  if (index < 0 || index >= oc->nb_programs) {
2669  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2670  exit_program(1);
2671  }
2672  m = &oc->programs[index]->metadata;
2673  break;
2674  default:
2675  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2676  exit_program(1);
2677  }
2678  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2679  }
2680  }
2681 
2682  return 0;
2683 }
2684 
2685 static int opt_target(void *optctx, const char *opt, const char *arg)
2686 {
2687  OptionsContext *o = optctx;
2688  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2689  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2690 
2691  if (!strncmp(arg, "pal-", 4)) {
2692  norm = PAL;
2693  arg += 4;
2694  } else if (!strncmp(arg, "ntsc-", 5)) {
2695  norm = NTSC;
2696  arg += 5;
2697  } else if (!strncmp(arg, "film-", 5)) {
2698  norm = FILM;
2699  arg += 5;
2700  } else {
2701  /* Try to determine PAL/NTSC by peeking in the input files */
2702  if (nb_input_files) {
2703  int i, j, fr;
2704  for (j = 0; j < nb_input_files; j++) {
2705  for (i = 0; i < input_files[j]->nb_streams; i++) {
2706  AVStream *st = input_files[j]->ctx->streams[i];
2708  continue;
2709  fr = st->time_base.den * 1000 / st->time_base.num;
2710  if (fr == 25000) {
2711  norm = PAL;
2712  break;
2713  } else if ((fr == 29970) || (fr == 23976)) {
2714  norm = NTSC;
2715  break;
2716  }
2717  }
2718  if (norm != UNKNOWN)
2719  break;
2720  }
2721  }
2722  if (norm != UNKNOWN)
2723  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2724  }
2725 
2726  if (norm == UNKNOWN) {
2727  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2728  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2729  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2730  exit_program(1);
2731  }
2732 
2733  if (!strcmp(arg, "vcd")) {
2734  opt_video_codec(o, "c:v", "mpeg1video");
2735  opt_audio_codec(o, "c:a", "mp2");
2736  parse_option(o, "f", "vcd", options);
2737 
2738  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2739  parse_option(o, "r", frame_rates[norm], options);
2740  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2741 
2742  opt_default(NULL, "b:v", "1150000");
2743  opt_default(NULL, "maxrate:v", "1150000");
2744  opt_default(NULL, "minrate:v", "1150000");
2745  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2746 
2747  opt_default(NULL, "b:a", "224000");
2748  parse_option(o, "ar", "44100", options);
2749  parse_option(o, "ac", "2", options);
2750 
2751  opt_default(NULL, "packetsize", "2324");
2752  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2753 
2754  /* We have to offset the PTS, so that it is consistent with the SCR.
2755  SCR starts at 36000, but the first two packs contain only padding
2756  and the first pack from the other stream, respectively, may also have
2757  been written before.
2758  So the real data starts at SCR 36000+3*1200. */
2759  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2760  } else if (!strcmp(arg, "svcd")) {
2761 
2762  opt_video_codec(o, "c:v", "mpeg2video");
2763  opt_audio_codec(o, "c:a", "mp2");
2764  parse_option(o, "f", "svcd", options);
2765 
2766  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2767  parse_option(o, "r", frame_rates[norm], options);
2768  parse_option(o, "pix_fmt", "yuv420p", options);
2769  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2770 
2771  opt_default(NULL, "b:v", "2040000");
2772  opt_default(NULL, "maxrate:v", "2516000");
2773  opt_default(NULL, "minrate:v", "0"); // 1145000;
2774  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2775  opt_default(NULL, "scan_offset", "1");
2776 
2777  opt_default(NULL, "b:a", "224000");
2778  parse_option(o, "ar", "44100", options);
2779 
2780  opt_default(NULL, "packetsize", "2324");
2781 
2782  } else if (!strcmp(arg, "dvd")) {
2783 
2784  opt_video_codec(o, "c:v", "mpeg2video");
2785  opt_audio_codec(o, "c:a", "ac3");
2786  parse_option(o, "f", "dvd", options);
2787 
2788  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2789  parse_option(o, "r", frame_rates[norm], options);
2790  parse_option(o, "pix_fmt", "yuv420p", options);
2791  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2792 
2793  opt_default(NULL, "b:v", "6000000");
2794  opt_default(NULL, "maxrate:v", "9000000");
2795  opt_default(NULL, "minrate:v", "0"); // 1500000;
2796  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2797 
2798  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2799  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2800 
2801  opt_default(NULL, "b:a", "448000");
2802  parse_option(o, "ar", "48000", options);
2803 
2804  } else if (!strncmp(arg, "dv", 2)) {
2805 
2806  parse_option(o, "f", "dv", options);
2807 
2808  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2809  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2810  norm == PAL ? "yuv420p" : "yuv411p", options);
2811  parse_option(o, "r", frame_rates[norm], options);
2812 
2813  parse_option(o, "ar", "48000", options);
2814  parse_option(o, "ac", "2", options);
2815 
2816  } else {
2817  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2818  return AVERROR(EINVAL);
2819  }
2820 
2823 
2824  return 0;
2825 }
2826 
2827 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2828 {
2830  vstats_filename = av_strdup (arg);
2831  return 0;
2832 }
2833 
2834 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2835 {
2836  char filename[40];
2837  time_t today2 = time(NULL);
2838  struct tm *today = localtime(&today2);
2839 
2840  if (!today) { // maybe tomorrow
2841  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2842  exit_program(1);
2843  }
2844 
2845  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2846  today->tm_sec);
2847  return opt_vstats_file(NULL, opt, filename);
2848 }
2849 
2850 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2851 {
2852  OptionsContext *o = optctx;
2853  return parse_option(o, "frames:v", arg, options);
2854 }
2855 
2856 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2857 {
2858  OptionsContext *o = optctx;
2859  return parse_option(o, "frames:a", arg, options);
2860 }
2861 
2862 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2863 {
2864  OptionsContext *o = optctx;
2865  return parse_option(o, "frames:d", arg, options);
2866 }
2867 
2868 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2869 {
2870  int ret;
2871  AVDictionary *cbak = codec_opts;
2872  AVDictionary *fbak = format_opts;
2873  codec_opts = NULL;
2874  format_opts = NULL;
2875 
2876  ret = opt_default(NULL, opt, arg);
2877 
2878  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2882  codec_opts = cbak;
2883  format_opts = fbak;
2884 
2885  return ret;
2886 }
2887 
2888 static int opt_preset(void *optctx, const char *opt, const char *arg)
2889 {
2890  OptionsContext *o = optctx;
2891  FILE *f=NULL;
2892  char filename[1000], line[1000], tmp_line[1000];
2893  const char *codec_name = NULL;
2894 
2895  tmp_line[0] = *opt;
2896  tmp_line[1] = 0;
2897  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2898 
2899  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2900  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2901  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2902  }else
2903  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2904  exit_program(1);
2905  }
2906 
2907  while (fgets(line, sizeof(line), f)) {
2908  char *key = tmp_line, *value, *endptr;
2909 
2910  if (strcspn(line, "#\n\r") == 0)
2911  continue;
2912  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2913  if (!av_strtok(key, "=", &value) ||
2914  !av_strtok(value, "\r\n", &endptr)) {
2915  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2916  exit_program(1);
2917  }
2918  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2919 
2920  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2921  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2922  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2923  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2924  else if (opt_default_new(o, key, value) < 0) {
2925  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2926  filename, line, key, value);
2927  exit_program(1);
2928  }
2929  }
2930 
2931  fclose(f);
2932 
2933  return 0;
2934 }
2935 
2936 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2937 {
2938  OptionsContext *o = optctx;
2939  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2940  int ret = parse_option(o, s, arg, options);
2941  av_free(s);
2942  return ret;
2943 }
2944 
2945 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2946 {
2947  OptionsContext *o = optctx;
2948 
2949  if(!strcmp(opt, "ab")){
2950  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2951  return 0;
2952  } else if(!strcmp(opt, "b")){
2953  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2954  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2955  return 0;
2956  }
2957  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2958  return 0;
2959 }
2960 
2961 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2962 {
2963  OptionsContext *o = optctx;
2964  char *s;
2965  int ret;
2966  if(!strcmp(opt, "qscale")){
2967  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2968  return parse_option(o, "q:v", arg, options);
2969  }
2970  s = av_asprintf("q%s", opt + 6);
2971  ret = parse_option(o, s, arg, options);
2972  av_free(s);
2973  return ret;
2974 }
2975 
2976 static int opt_profile(void *optctx, const char *opt, const char *arg)
2977 {
2978  OptionsContext *o = optctx;
2979  if(!strcmp(opt, "profile")){
2980  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2981  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2982  return 0;
2983  }
2984  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2985  return 0;
2986 }
2987 
2988 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2989 {
2990  OptionsContext *o = optctx;
2991  return parse_option(o, "filter:v", arg, options);
2992 }
2993 
2994 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2995 {
2996  OptionsContext *o = optctx;
2997  return parse_option(o, "filter:a", arg, options);
2998 }
2999 
3000 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3001 {
3002  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3003  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3004  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3005  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3006 
3009  return 0;
3010 }
3011 
3012 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3013 {
3014  OptionsContext *o = optctx;
3015  char *tcr = av_asprintf("timecode=%s", arg);
3016  int ret = parse_option(o, "metadata:g", tcr, options);
3017  if (ret >= 0)
3018  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3019  av_free(tcr);
3020  return ret;
3021 }
3022 
3023 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3024 {
3025  OptionsContext *o = optctx;
3026  char layout_str[32];
3027  char *stream_str;
3028  char *ac_str;
3029  int ret, channels, ac_str_size;
3030  uint64_t layout;
3031 
3032  layout = av_get_channel_layout(arg);
3033  if (!layout) {
3034  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3035  return AVERROR(EINVAL);
3036  }
3037  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3038  ret = opt_default_new(o, opt, layout_str);
3039  if (ret < 0)
3040  return ret;
3041 
3042  /* set 'ac' option based on channel layout */
3043  channels = av_get_channel_layout_nb_channels(layout);
3044  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3045  stream_str = strchr(opt, ':');
3046  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3047  ac_str = av_mallocz(ac_str_size);
3048  if (!ac_str)
3049  return AVERROR(ENOMEM);
3050  av_strlcpy(ac_str, "ac", 3);
3051  if (stream_str)
3052  av_strlcat(ac_str, stream_str, ac_str_size);
3053  ret = parse_option(o, ac_str, layout_str, options);
3054  av_free(ac_str);
3055 
3056  return ret;
3057 }
3058 
3059 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3060 {
3061  OptionsContext *o = optctx;
3062  return parse_option(o, "q:a", arg, options);
3063 }
3064 
3065 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3066 {
3068  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3069  return AVERROR(ENOMEM);
3072  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3073  return AVERROR(ENOMEM);
3074 
3076 
3077  return 0;
3078 }
3079 
3080 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3081 {
3082  uint8_t *graph_desc = read_file(arg);
3083  if (!graph_desc)
3084  return AVERROR(EINVAL);
3085 
3087  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3088  return AVERROR(ENOMEM);
3090  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3091 
3093 
3094  return 0;
3095 }
3096 
3097 void show_help_default(const char *opt, const char *arg)
3098 {
3099  /* per-file options have at least one of those set */
3100  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3101  int show_advanced = 0, show_avoptions = 0;
3102 
3103  if (opt && *opt) {
3104  if (!strcmp(opt, "long"))
3105  show_advanced = 1;
3106  else if (!strcmp(opt, "full"))
3107  show_advanced = show_avoptions = 1;
3108  else
3109  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3110  }
3111 
3112  show_usage();
3113 
3114  printf("Getting help:\n"
3115  " -h -- print basic options\n"
3116  " -h long -- print more options\n"
3117  " -h full -- print all options (including all format and codec specific options, very long)\n"
3118  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3119  " See man %s for detailed description of the options.\n"
3120  "\n", program_name);
3121 
3122  show_help_options(options, "Print help / information / capabilities:",
3123  OPT_EXIT, 0, 0);
3124 
3125  show_help_options(options, "Global options (affect whole program "
3126  "instead of just one file:",
3127  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3128  if (show_advanced)
3129  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3130  per_file | OPT_EXIT, 0);
3131 
3132  show_help_options(options, "Per-file main options:", 0,
3134  OPT_EXIT, per_file);
3135  if (show_advanced)
3136  show_help_options(options, "Advanced per-file options:",
3137  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3138 
3139  show_help_options(options, "Video options:",
3141  if (show_advanced)
3142  show_help_options(options, "Advanced Video options:",
3144 
3145  show_help_options(options, "Audio options:",
3147  if (show_advanced)
3148  show_help_options(options, "Advanced Audio options:",
3150  show_help_options(options, "Subtitle options:",
3151  OPT_SUBTITLE, 0, 0);
3152  printf("\n");
3153 
3154  if (show_avoptions) {
3158 #if CONFIG_SWSCALE
3160 #endif
3161 #if CONFIG_SWRESAMPLE
3163 #endif
3166  }
3167 }
3168 
3169 void show_usage(void)
3170 {
3171  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3172  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3173  av_log(NULL, AV_LOG_INFO, "\n");
3174 }
3175 
3176 enum OptGroup {
3179 };
3180 
3181 static const OptionGroupDef groups[] = {
3182  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3183  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3184 };
3185 
3186 static int open_files(OptionGroupList *l, const char *inout,
3187  int (*open_file)(OptionsContext*, const char*))
3188 {
3189  int i, ret;
3190 
3191  for (i = 0; i < l->nb_groups; i++) {
3192  OptionGroup *g = &l->groups[i];
3193  OptionsContext o;
3194 
3195  init_options(&o);
3196  o.g = g;
3197 
3198  ret = parse_optgroup(&o, g);
3199  if (ret < 0) {
3200  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3201  "%s.\n", inout, g->arg);
3202  return ret;
3203  }
3204 
3205  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3206  ret = open_file(&o, g->arg);
3207  uninit_options(&o);
3208  if (ret < 0) {
3209  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3210  inout, g->arg);
3211  return ret;
3212  }
3213  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3214  }
3215 
3216  return 0;
3217 }
3218 
3219 int ffmpeg_parse_options(int argc, char **argv)
3220 {
3221  OptionParseContext octx;
3222  uint8_t error[128];
3223  int ret;
3224 
3225  memset(&octx, 0, sizeof(octx));
3226 
3227  /* split the commandline into an internal representation */
3228  ret = split_commandline(&octx, argc, argv, options, groups,
3229  FF_ARRAY_ELEMS(groups));
3230  if (ret < 0) {
3231  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3232  goto fail;
3233  }
3234 
3235  /* apply global options */
3236  ret = parse_optgroup(NULL, &octx.global_opts);
3237  if (ret < 0) {
3238  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3239  goto fail;
3240  }
3241 
3242  /* configure terminal and setup signal handlers */
3243  term_init();
3244 
3245  /* open input files */
3246  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3247  if (ret < 0) {
3248  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3249  goto fail;
3250  }
3251 
3252  /* create the complex filtergraphs */
3253  ret = init_complex_filters();
3254  if (ret < 0) {
3255  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3256  goto fail;
3257  }
3258 
3259  /* open output files */
3260  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3261  if (ret < 0) {
3262  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3263  goto fail;
3264  }
3265 
3267 
3268 fail:
3269  uninit_parse_context(&octx);
3270  if (ret < 0) {
3271  av_strerror(ret, error, sizeof(error));
3272  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3273  }
3274  return ret;
3275 }
3276 
3277 static int opt_progress(void *optctx, const char *opt, const char *arg)
3278 {
3279  AVIOContext *avio = NULL;
3280  int ret;
3281 
3282  if (!strcmp(arg, "-"))
3283  arg = "pipe:";
3284  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3285  if (ret < 0) {
3286  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3287  arg, av_err2str(ret));
3288  return ret;
3289  }
3290  progress_avio = avio;
3291  return 0;
3292 }
3293 
3294 #define OFFSET(x) offsetof(OptionsContext, x)
3295 const OptionDef options[] = {
3296  /* main options */
3298  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3299  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3300  "force format", "fmt" },
3301  { "y", OPT_BOOL, { &file_overwrite },
3302  "overwrite output files" },
3303  { "n", OPT_BOOL, { &no_file_overwrite },
3304  "never overwrite output files" },
3305  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3306  "Ignore unknown stream types" },
3307  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3308  "Copy unknown stream types" },
3309  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3310  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3311  "codec name", "codec" },
3312  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3313  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3314  "codec name", "codec" },
3315  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3316  OPT_OUTPUT, { .off = OFFSET(presets) },
3317  "preset name", "preset" },
3318  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3319  OPT_OUTPUT, { .func_arg = opt_map },
3320  "set input stream mapping",
3321  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3322  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3323  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3324  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3325  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3326  "set metadata information of outfile from infile",
3327  "outfile[,metadata]:infile[,metadata]" },
3328  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3329  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3330  "set chapters mapping", "input_file_index" },
3331  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3332  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3333  "record or transcode \"duration\" seconds of audio/video",
3334  "duration" },
3335  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3336  "record or transcode stop time", "time_stop" },
3337  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3338  "set the limit file size in bytes", "limit_size" },
3339  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3340  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3341  "set the start time offset", "time_off" },
3342  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3343  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3344  "set the start time offset relative to EOF", "time_off" },
3345  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3346  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3347  "enable/disable seeking by timestamp with -ss" },
3348  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3349  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3350  "enable/disable accurate seeking with -ss" },
3351  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3352  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3353  "set the input ts offset", "time_off" },
3354  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3355  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3356  "set the input ts scale", "scale" },
3357  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3358  "set the recording timestamp ('now' to set the current time)", "time" },
3359  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3360  "add metadata", "string=string" },
3361  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3362  "add program with specified streams", "title=string:st=number..." },
3363  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3364  OPT_OUTPUT, { .func_arg = opt_data_frames },
3365  "set the number of data frames to output", "number" },
3366  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3367  "add timings for benchmarking" },
3368  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3369  "add timings for each task" },
3370  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3371  "write program-readable progress information", "url" },
3372  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3373  "enable or disable interaction on standard input" },
3374  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3375  "set max runtime in seconds", "limit" },
3376  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3377  "dump each input packet" },
3378  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3379  "when dumping packets, also dump the payload" },
3380  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3381  OPT_INPUT, { .off = OFFSET(rate_emu) },
3382  "read input at native frame rate", "" },
3383  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3384  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3385  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3386  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3387  "video sync method", "" },
3388  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3389  "frame drop threshold", "" },
3390  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3391  "audio sync method", "" },
3392  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3393  "audio drift threshold", "threshold" },
3394  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3395  "copy timestamps" },
3396  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3397  "shift input timestamps to start at 0 when using copyts" },
3398  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3399  "copy input stream time base when stream copying", "mode" },
3400  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3401  OPT_OUTPUT, { .off = OFFSET(shortest) },
3402  "finish encoding within shortest input" },
3403  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3404  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3405  "bitexact mode" },
3406  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3407  OPT_OUTPUT, { .off = OFFSET(apad) },
3408  "audio pad", "" },
3409  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3410  "timestamp discontinuity delta threshold", "threshold" },
3411  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3412  "timestamp error delta threshold", "threshold" },
3413  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3414  "exit on error", "error" },
3415  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3416  "abort on the specified condition flags", "flags" },
3417  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3418  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3419  "copy initial non-keyframes" },
3420  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3421  "copy or discard frames before start time" },
3422  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3423  "set the number of frames to output", "number" },
3424  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3425  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3426  "force codec tag/fourcc", "fourcc/tag" },
3427  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3428  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3429  "use fixed quality scale (VBR)", "q" },
3430  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3431  OPT_OUTPUT, { .func_arg = opt_qscale },
3432  "use fixed quality scale (VBR)", "q" },
3433  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3434  "set profile", "profile" },
3435  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3436  "set stream filtergraph", "filter_graph" },
3437  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3438  "number of non-complex filter threads" },
3439  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3440  "read stream filtergraph description from a file", "filename" },
3441  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3442  "reinit filtergraph on input parameter changes", "" },
3443  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3444  "create a complex filtergraph", "graph_description" },
3445  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3446  "number of threads for -filter_complex" },
3447  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3448  "create a complex filtergraph", "graph_description" },
3449  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3450  "read complex filtergraph description from a file", "filename" },
3451  { "stats", OPT_BOOL, { &print_stats },
3452  "print progress report during encoding", },
3453  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3454  OPT_OUTPUT, { .func_arg = opt_attach },
3455  "add an attachment to the output file", "filename" },
3456  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3457  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3458  "extract an attachment into a file", "filename" },
3459  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3460  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3461  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3462  "print timestamp debugging info" },
3463  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3464  "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3465  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3466  OPT_INPUT, { .off = OFFSET(discard) },
3467  "discard", "" },
3468  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3469  OPT_OUTPUT, { .off = OFFSET(disposition) },
3470  "disposition", "" },
3471  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3472  { .off = OFFSET(thread_queue_size) },
3473  "set the maximum number of queued packets from the demuxer" },
3474  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3475  "read and decode the streams to fill missing information with heuristics" },
3476 
3477  /* video options */
3478  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3479  "set the number of video frames to output", "number" },
3480  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3481  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3482  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3484  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3485  "set frame size (WxH or abbreviation)", "size" },
3486  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3487  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3488  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3489  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3490  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3491  "set pixel format", "format" },
3492  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3493  "set the number of bits per raw sample", "number" },
3494  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3495  "deprecated use -g 1" },
3497  "disable video" },
3498  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3499  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3500  "rate control override for specific intervals", "override" },
3501  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3502  OPT_OUTPUT, { .func_arg = opt_video_codec },
3503  "force video codec ('copy' to copy stream)", "codec" },
3504  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3505  "Removed" },
3506  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3507  "Removed" },
3508  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3509  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3510  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3511  "select the pass number (1 to 3)", "n" },
3512  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3513  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3514  "select two pass log file name prefix", "prefix" },
3515  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3516  "this option is deprecated, use the yadif filter instead" },
3517  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3518  "calculate PSNR of compressed frames" },
3519  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3520  "dump video coding statistics to file" },
3521  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3522  "dump video coding statistics to file", "file" },
3523  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3524  "Version of the vstats format to use."},
3525  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3526  "set video filters", "filter_graph" },
3527  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3528  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3529  "specify intra matrix coeffs", "matrix" },
3530  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3531  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3532  "specify inter matrix coeffs", "matrix" },
3533  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3534  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3535  "specify intra matrix coeffs", "matrix" },
3536  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3537  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3538  "top=1/bottom=0/auto=-1 field first", "" },
3539  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3540  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3541  "force video tag/fourcc", "fourcc/tag" },
3542  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3543  "show QP histogram" },
3544  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3545  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3546  "force the selected framerate, disable the best supported framerate selection" },
3547  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3548  OPT_OUTPUT, { .func_arg = opt_streamid },
3549  "set the value of an outfile streamid", "streamIndex:value" },
3550  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3551  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3552  "force key frames at specified timestamps", "timestamps" },
3553  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3554  "audio bitrate (please use -b:a)", "bitrate" },
3555  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3556  "video bitrate (please use -b:v)", "bitrate" },
3557  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3558  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3559  "use HW accelerated decoding", "hwaccel name" },
3560  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3561  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3562  "select a device for HW acceleration", "devicename" },
3563  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3564  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3565  "select output format used with HW accelerated decoding", "format" },
3566 #if CONFIG_VIDEOTOOLBOX
3567  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3568 #endif
3569  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3570  "show available HW acceleration methods" },
3571  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3572  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3573  "automatically insert correct rotate filters" },
3574 
3575  /* audio options */
3576  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3577  "set the number of audio frames to output", "number" },
3578  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3579  "set audio quality (codec-specific)", "quality", },
3580  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3581  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3582  "set audio sampling rate (in Hz)", "rate" },
3583  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3584  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3585  "set number of audio channels", "channels" },
3587  "disable audio" },
3588  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3589  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3590  "force audio codec ('copy' to copy stream)", "codec" },
3591  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3592  OPT_OUTPUT, { .func_arg = opt_old2new },
3593  "force audio tag/fourcc", "fourcc/tag" },
3594  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3595  "change audio volume (256=normal)" , "volume" },
3596  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3598  "set sample format", "format" },
3599  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3600  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3601  "set channel layout", "layout" },
3602  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3603  "set audio filters", "filter_graph" },
3604  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3605  "set the maximum number of channels to try to guess the channel layout" },
3606 
3607  /* subtitle options */
3609  "disable subtitle" },
3610  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3611  "force subtitle codec ('copy' to copy stream)", "codec" },
3612  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3613  , "force subtitle tag/fourcc", "fourcc/tag" },
3614  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3615  "fix subtitles duration" },
3616  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3617  "set canvas size (WxH or abbreviation)", "size" },
3618 
3619  /* grab options */
3620  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3621  "deprecated, use -channel", "channel" },
3622  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3623  "deprecated, use -standard", "standard" },
3624  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3625 
3626  /* muxer options */
3627  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3628  "set the maximum demux-decode delay", "seconds" },
3629  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3630  "set the initial demux-decode delay", "seconds" },
3631  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3632  "specify a file in which to print sdp information", "file" },
3633 
3634  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3635  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3636  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3637  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3638  "two special values are defined - "
3639  "0 = use frame rate (video) or sample rate (audio),"
3640  "-1 = match source time base", "ratio" },
3641 
3642  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3643  "A comma-separated list of bitstream filters", "bitstream_filters" },
3644  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3645  "deprecated", "audio bitstream_filters" },
3646  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3647  "deprecated", "video bitstream_filters" },
3648 
3649  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3650  "set the audio options to the indicated preset", "preset" },
3651  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3652  "set the video options to the indicated preset", "preset" },
3653  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3654  "set the subtitle options to the indicated preset", "preset" },
3655  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3656  "set options from indicated preset file", "filename" },
3657 
3658  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3659  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3660 
3661  /* data codec support */
3662  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3663  "force data codec ('copy' to copy stream)", "codec" },
3664  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3665  "disable data" },
3666 
3667 #if CONFIG_VAAPI
3668  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3669  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3670 #endif
3671 
3672 #if CONFIG_QSV
3673  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3674  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3675 #endif
3676 
3677  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3678  "initialise hardware device", "args" },
3679  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3680  "set hardware device used when filtering", "device" },
3681 
3682  { NULL, },
3683 };
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:3169
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:3041
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:5756
#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:864
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2862
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:2000
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:1706
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:278
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:2068
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:3885
int qscale
Definition: avcodec.h:817
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:2994
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1886
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:1897
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:764
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1728
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:3065
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:2541
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1957
enum AVMediaType type
Definition: avcodec.h:3422
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:1301
discard all
Definition: avcodec.h:795
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:2742
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:1266
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5709
#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:3409
#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:2076
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3877
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:2888
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:3059
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:2182
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:3951
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:1982
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:962
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3181
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:3140
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:3000
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:2834
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:2078
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:1465
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:2750
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:3295
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:818
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2961
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:2133
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:892
AVDictionary * format_opts
Definition: cmdutils.c:73
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1907
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:3423
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:2976
#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:3186
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:3980
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:3881
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1599
const char * name
Definition: cmdutils.h:159
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2945
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:3416
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2936
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:3143
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3903
#define pass
Definition: fft_template.c:593
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:3219
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:716
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:2988
int nb_output_files
Definition: ffmpeg.c:155
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2384
size_t off
Definition: cmdutils.h:186
char * linklabel
Definition: ffmpeg.h:87
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:76
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:887
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:834
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
#define FFMIN(a, b)
Definition: common.h:96
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1543