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