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