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