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