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