FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "ffmpeg.h"
24 #include "cmdutils.h"
25 
26 #include "libavformat/avformat.h"
27 
28 #include "libavcodec/avcodec.h"
29 
30 #include "libavfilter/avfilter.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
45 
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 {\
48  int i, ret;\
49  for (i = 0; i < o->nb_ ## name; i++) {\
50  char *spec = o->name[i].specifier;\
51  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52  outvar = o->name[i].u.type;\
53  else if (ret < 0)\
54  exit_program(1);\
55  }\
56 }
57 
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 {\
60  int i;\
61  for (i = 0; i < o->nb_ ## name; i++) {\
62  char *spec = o->name[i].specifier;\
63  if (!strcmp(spec, mediatype))\
64  outvar = o->name[i].u.type;\
65  }\
66 }
67 
68 const HWAccel hwaccels[] = {
69 #if CONFIG_VIDEOTOOLBOX
71 #endif
72 #if CONFIG_LIBMFX
73  { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
74 #endif
75 #if CONFIG_CUVID
77 #endif
78  { 0 },
79 };
82 
85 
88 float dts_error_threshold = 3600*30;
89 
90 int audio_volume = 256;
95 int do_benchmark = 0;
97 int do_hex_dump = 0;
98 int do_pkt_dump = 0;
99 int copy_ts = 0;
101 int copy_tb = -1;
102 int debug_ts = 0;
105 int print_stats = -1;
106 int qp_hist = 0;
109 float max_error_rate = 2.0/3;
113 
114 
115 static int intra_only = 0;
116 static int file_overwrite = 0;
117 static int no_file_overwrite = 0;
118 static int do_psnr = 0;
119 static int input_sync;
121 static int ignore_unknown_streams = 0;
122 static int copy_unknown_streams = 0;
123 static int find_stream_info = 1;
124 
126 {
127  const OptionDef *po = options;
128  int i;
129 
130  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
131  while (po->name) {
132  void *dst = (uint8_t*)o + po->u.off;
133 
134  if (po->flags & OPT_SPEC) {
135  SpecifierOpt **so = dst;
136  int i, *count = (int*)(so + 1);
137  for (i = 0; i < *count; i++) {
138  av_freep(&(*so)[i].specifier);
139  if (po->flags & OPT_STRING)
140  av_freep(&(*so)[i].u.str);
141  }
142  av_freep(so);
143  *count = 0;
144  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
145  av_freep(dst);
146  po++;
147  }
148 
149  for (i = 0; i < o->nb_stream_maps; i++)
151  av_freep(&o->stream_maps);
153  av_freep(&o->streamid_map);
154  av_freep(&o->attachments);
155 }
156 
158 {
159  memset(o, 0, sizeof(*o));
160 
161  o->stop_time = INT64_MAX;
162  o->mux_max_delay = 0.7;
165  o->recording_time = INT64_MAX;
166  o->limit_filesize = UINT64_MAX;
167  o->chapters_input_file = INT_MAX;
168  o->accurate_seek = 1;
169 }
170 
171 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
172 {
174  int i;
175 
176  printf("Hardware acceleration methods:\n");
177  while ((type = av_hwdevice_iterate_types(type)) !=
179  printf("%s\n", av_hwdevice_get_type_name(type));
180  for (i = 0; hwaccels[i].name; i++)
181  printf("%s\n", hwaccels[i].name);
182  printf("\n");
183  return 0;
184 }
185 
186 /* return a copy of the input with the stream specifiers removed from the keys */
188 {
189  AVDictionaryEntry *e = NULL;
190  AVDictionary *ret = NULL;
191 
192  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
193  char *p = strchr(e->key, ':');
194 
195  if (p)
196  *p = 0;
197  av_dict_set(&ret, e->key, e->value, 0);
198  if (p)
199  *p = ':';
200  }
201  return ret;
202 }
203 
204 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
205 {
206  static const AVOption opts[] = {
207  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
208  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
209  { NULL },
210  };
211  static const AVClass class = {
212  .class_name = "",
213  .item_name = av_default_item_name,
214  .option = opts,
215  .version = LIBAVUTIL_VERSION_INT,
216  };
217  const AVClass *pclass = &class;
218 
219  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
220 }
221 
222 static int opt_sameq(void *optctx, const char *opt, const char *arg)
223 {
224  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
225  "If you are looking for an option to preserve the quality (which is not "
226  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
227  opt, opt);
228  return AVERROR(EINVAL);
229 }
230 
231 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
232 {
233  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
234  return opt_default(optctx, "channel", arg);
235 }
236 
237 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
238 {
239  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
240  return opt_default(optctx, "standard", arg);
241 }
242 
243 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
244 {
245  OptionsContext *o = optctx;
246  return parse_option(o, "codec:a", arg, options);
247 }
248 
249 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
250 {
251  OptionsContext *o = optctx;
252  return parse_option(o, "codec:v", arg, options);
253 }
254 
255 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
256 {
257  OptionsContext *o = optctx;
258  return parse_option(o, "codec:s", arg, options);
259 }
260 
261 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
262 {
263  OptionsContext *o = optctx;
264  return parse_option(o, "codec:d", arg, options);
265 }
266 
267 static int opt_map(void *optctx, const char *opt, const char *arg)
268 {
269  OptionsContext *o = optctx;
270  StreamMap *m = NULL;
271  int i, negative = 0, file_idx, 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  if (ist->user_set_discard == AVDISCARD_ALL)
2203  continue;
2204  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2205  new_area = 1;
2206  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2207  new_area > area) {
2208  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2209  continue;
2210  area = new_area;
2211  idx = i;
2212  }
2213  }
2214  if (idx >= 0)
2215  new_video_stream(o, oc, idx);
2216  }
2217 
2218  /* audio: most channels */
2220  int best_score = 0, idx = -1;
2221  for (i = 0; i < nb_input_streams; i++) {
2222  int score;
2223  ist = input_streams[i];
2224  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2225  if (ist->user_set_discard == AVDISCARD_ALL)
2226  continue;
2227  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2228  score > best_score) {
2229  best_score = score;
2230  idx = i;
2231  }
2232  }
2233  if (idx >= 0)
2234  new_audio_stream(o, oc, idx);
2235  }
2236 
2237  /* subtitles: pick first */
2238  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2239  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2240  for (i = 0; i < nb_input_streams; i++)
2241  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2242  AVCodecDescriptor const *input_descriptor =
2243  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2244  AVCodecDescriptor const *output_descriptor = NULL;
2245  AVCodec const *output_codec =
2247  int input_props = 0, output_props = 0;
2248  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2249  continue;
2250  if (output_codec)
2251  output_descriptor = avcodec_descriptor_get(output_codec->id);
2252  if (input_descriptor)
2253  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2254  if (output_descriptor)
2255  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2256  if (subtitle_codec_name ||
2257  input_props & output_props ||
2258  // Map dvb teletext which has neither property to any output subtitle encoder
2259  input_descriptor && output_descriptor &&
2260  (!input_descriptor->props ||
2261  !output_descriptor->props)) {
2262  new_subtitle_stream(o, oc, i);
2263  break;
2264  }
2265  }
2266  }
2267  /* Data only if codec id match */
2268  if (!o->data_disable ) {
2270  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2271  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2272  continue;
2273  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2274  && input_streams[i]->st->codecpar->codec_id == codec_id )
2275  new_data_stream(o, oc, i);
2276  }
2277  }
2278  } else {
2279  for (i = 0; i < o->nb_stream_maps; i++) {
2280  StreamMap *map = &o->stream_maps[i];
2281 
2282  if (map->disabled)
2283  continue;
2284 
2285  if (map->linklabel) {
2286  FilterGraph *fg;
2287  OutputFilter *ofilter = NULL;
2288  int j, k;
2289 
2290  for (j = 0; j < nb_filtergraphs; j++) {
2291  fg = filtergraphs[j];
2292  for (k = 0; k < fg->nb_outputs; k++) {
2293  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2294  if (out && !strcmp(out->name, map->linklabel)) {
2295  ofilter = fg->outputs[k];
2296  goto loop_end;
2297  }
2298  }
2299  }
2300 loop_end:
2301  if (!ofilter) {
2302  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2303  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2304  exit_program(1);
2305  }
2306  init_output_filter(ofilter, o, oc);
2307  } else {
2308  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2309 
2311  if (ist->user_set_discard == AVDISCARD_ALL) {
2312  av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2313  map->file_index, map->stream_index);
2314  exit_program(1);
2315  }
2317  continue;
2319  continue;
2321  continue;
2322  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2323  continue;
2324 
2325  ost = NULL;
2326  switch (ist->st->codecpar->codec_type) {
2327  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2328  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2329  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2330  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2331  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2332  case AVMEDIA_TYPE_UNKNOWN:
2333  if (copy_unknown_streams) {
2334  ost = new_unknown_stream (o, oc, src_idx);
2335  break;
2336  }
2337  default:
2339  "Cannot map stream #%d:%d - unsupported type.\n",
2340  map->file_index, map->stream_index);
2341  if (!ignore_unknown_streams) {
2342  av_log(NULL, AV_LOG_FATAL,
2343  "If you want unsupported types ignored instead "
2344  "of failing, please use the -ignore_unknown option\n"
2345  "If you want them copied, please use -copy_unknown\n");
2346  exit_program(1);
2347  }
2348  }
2349  if (ost)
2350  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2351  + map->sync_stream_index];
2352  }
2353  }
2354  }
2355 
2356  /* handle attached files */
2357  for (i = 0; i < o->nb_attachments; i++) {
2358  AVIOContext *pb;
2359  uint8_t *attachment;
2360  const char *p;
2361  int64_t len;
2362 
2363  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2364  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2365  o->attachments[i]);
2366  exit_program(1);
2367  }
2368  if ((len = avio_size(pb)) <= 0) {
2369  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2370  o->attachments[i]);
2371  exit_program(1);
2372  }
2373  if (!(attachment = av_malloc(len))) {
2374  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2375  o->attachments[i]);
2376  exit_program(1);
2377  }
2378  avio_read(pb, attachment, len);
2379 
2380  ost = new_attachment_stream(o, oc, -1);
2381  ost->stream_copy = 0;
2382  ost->attachment_filename = o->attachments[i];
2383  ost->st->codecpar->extradata = attachment;
2384  ost->st->codecpar->extradata_size = len;
2385 
2386  p = strrchr(o->attachments[i], '/');
2387  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2388  avio_closep(&pb);
2389  }
2390 
2391 #if FF_API_LAVF_AVCTX
2392  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2393  AVDictionaryEntry *e;
2394  ost = output_streams[i];
2395 
2396  if ((ost->stream_copy || ost->attachment_filename)
2397  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2398  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2399  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2400  exit_program(1);
2401  }
2402 #endif
2403 
2404  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2405  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2406  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2407  exit_program(1);
2408  }
2409 
2410  /* check if all codec options have been used */
2411  unused_opts = strip_specifiers(o->g->codec_opts);
2412  for (i = of->ost_index; i < nb_output_streams; i++) {
2413  e = NULL;
2414  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2416  av_dict_set(&unused_opts, e->key, NULL, 0);
2417  }
2418 
2419  e = NULL;
2420  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2421  const AVClass *class = avcodec_get_class();
2422  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2424  const AVClass *fclass = avformat_get_class();
2425  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2427  if (!option || foption)
2428  continue;
2429 
2430 
2431  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2432  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2433  "output file #%d (%s) is not an encoding option.\n", e->key,
2434  option->help ? option->help : "", nb_output_files - 1,
2435  filename);
2436  exit_program(1);
2437  }
2438 
2439  // gop_timecode is injected by generic code but not always used
2440  if (!strcmp(e->key, "gop_timecode"))
2441  continue;
2442 
2443  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2444  "output file #%d (%s) has not been used for any stream. The most "
2445  "likely reason is either wrong type (e.g. a video option with "
2446  "no video streams) or that it is a private option of some encoder "
2447  "which was not actually used for any stream.\n", e->key,
2448  option->help ? option->help : "", nb_output_files - 1, filename);
2449  }
2450  av_dict_free(&unused_opts);
2451 
2452  /* set the decoding_needed flags and create simple filtergraphs */
2453  for (i = of->ost_index; i < nb_output_streams; i++) {
2454  OutputStream *ost = output_streams[i];
2455 
2456  if (ost->encoding_needed && ost->source_index >= 0) {
2457  InputStream *ist = input_streams[ost->source_index];
2459 
2460  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2462  err = init_simple_filtergraph(ist, ost);
2463  if (err < 0) {
2465  "Error initializing a simple filtergraph between streams "
2466  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2467  nb_output_files - 1, ost->st->index);
2468  exit_program(1);
2469  }
2470  }
2471  }
2472 
2473  /* set the filter output constraints */
2474  if (ost->filter) {
2475  OutputFilter *f = ost->filter;
2476  int count;
2477  switch (ost->enc_ctx->codec_type) {
2478  case AVMEDIA_TYPE_VIDEO:
2479  f->frame_rate = ost->frame_rate;
2480  f->width = ost->enc_ctx->width;
2481  f->height = ost->enc_ctx->height;
2482  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2483  f->format = ost->enc_ctx->pix_fmt;
2484  } else if (ost->enc->pix_fmts) {
2485  count = 0;
2486  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2487  count++;
2488  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2489  if (!f->formats)
2490  exit_program(1);
2491  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2492  }
2493  break;
2494  case AVMEDIA_TYPE_AUDIO:
2495  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2496  f->format = ost->enc_ctx->sample_fmt;
2497  } else if (ost->enc->sample_fmts) {
2498  count = 0;
2499  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2500  count++;
2501  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2502  if (!f->formats)
2503  exit_program(1);
2504  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2505  }
2506  if (ost->enc_ctx->sample_rate) {
2507  f->sample_rate = ost->enc_ctx->sample_rate;
2508  } else if (ost->enc->supported_samplerates) {
2509  count = 0;
2510  while (ost->enc->supported_samplerates[count])
2511  count++;
2512  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2513  if (!f->sample_rates)
2514  exit_program(1);
2515  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2516  (count + 1) * sizeof(*f->sample_rates));
2517  }
2518  if (ost->enc_ctx->channels) {
2520  } else if (ost->enc->channel_layouts) {
2521  count = 0;
2522  while (ost->enc->channel_layouts[count])
2523  count++;
2524  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2525  if (!f->channel_layouts)
2526  exit_program(1);
2527  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2528  (count + 1) * sizeof(*f->channel_layouts));
2529  }
2530  break;
2531  }
2532  }
2533  }
2534 
2535  /* check filename in case of an image number is expected */
2536  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2537  if (!av_filename_number_test(oc->url)) {
2538  print_error(oc->url, AVERROR(EINVAL));
2539  exit_program(1);
2540  }
2541  }
2542 
2545  "No input streams but output needs an input stream\n");
2546  exit_program(1);
2547  }
2548 
2549  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2550  /* test if it already exists to avoid losing precious files */
2551  assert_file_overwrite(filename);
2552 
2553  /* open the file */
2554  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2555  &oc->interrupt_callback,
2556  &of->opts)) < 0) {
2557  print_error(filename, err);
2558  exit_program(1);
2559  }
2560  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2561  assert_file_overwrite(filename);
2562 
2563  if (o->mux_preload) {
2564  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2565  }
2566  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2567 
2568  /* copy metadata */
2569  for (i = 0; i < o->nb_metadata_map; i++) {
2570  char *p;
2571  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2572 
2573  if (in_file_index >= nb_input_files) {
2574  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2575  exit_program(1);
2576  }
2577  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2578  in_file_index >= 0 ?
2579  input_files[in_file_index]->ctx : NULL, o);
2580  }
2581 
2582  /* copy chapters */
2583  if (o->chapters_input_file >= nb_input_files) {
2584  if (o->chapters_input_file == INT_MAX) {
2585  /* copy chapters from the first input file that has them*/
2586  o->chapters_input_file = -1;
2587  for (i = 0; i < nb_input_files; i++)
2588  if (input_files[i]->ctx->nb_chapters) {
2589  o->chapters_input_file = i;
2590  break;
2591  }
2592  } else {
2593  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2594  o->chapters_input_file);
2595  exit_program(1);
2596  }
2597  }
2598  if (o->chapters_input_file >= 0)
2601 
2602  /* copy global metadata by default */
2606  if(o->recording_time != INT64_MAX)
2607  av_dict_set(&oc->metadata, "duration", NULL, 0);
2608  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2609  }
2610  if (!o->metadata_streams_manual)
2611  for (i = of->ost_index; i < nb_output_streams; i++) {
2612  InputStream *ist;
2613  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2614  continue;
2616  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2617  if (!output_streams[i]->stream_copy) {
2618  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2619  }
2620  }
2621 
2622  /* process manually set programs */
2623  for (i = 0; i < o->nb_program; i++) {
2624  const char *p = o->program[i].u.str;
2625  int progid = i+1;
2626  AVProgram *program;
2627 
2628  while(*p) {
2629  const char *p2 = av_get_token(&p, ":");
2630  const char *to_dealloc = p2;
2631  char *key;
2632  if (!p2)
2633  break;
2634 
2635  if(*p) p++;
2636 
2637  key = av_get_token(&p2, "=");
2638  if (!key || !*p2) {
2639  av_freep(&to_dealloc);
2640  av_freep(&key);
2641  break;
2642  }
2643  p2++;
2644 
2645  if (!strcmp(key, "program_num"))
2646  progid = strtol(p2, NULL, 0);
2647  av_freep(&to_dealloc);
2648  av_freep(&key);
2649  }
2650 
2651  program = av_new_program(oc, progid);
2652 
2653  p = o->program[i].u.str;
2654  while(*p) {
2655  const char *p2 = av_get_token(&p, ":");
2656  const char *to_dealloc = p2;
2657  char *key;
2658  if (!p2)
2659  break;
2660  if(*p) p++;
2661 
2662  key = av_get_token(&p2, "=");
2663  if (!key) {
2665  "No '=' character in program string %s.\n",
2666  p2);
2667  exit_program(1);
2668  }
2669  if (!*p2)
2670  exit_program(1);
2671  p2++;
2672 
2673  if (!strcmp(key, "title")) {
2674  av_dict_set(&program->metadata, "title", p2, 0);
2675  } else if (!strcmp(key, "program_num")) {
2676  } else if (!strcmp(key, "st")) {
2677  int st_num = strtol(p2, NULL, 0);
2678  av_program_add_stream_index(oc, progid, st_num);
2679  } else {
2680  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2681  exit_program(1);
2682  }
2683  av_freep(&to_dealloc);
2684  av_freep(&key);
2685  }
2686  }
2687 
2688  /* process manually set metadata */
2689  for (i = 0; i < o->nb_metadata; i++) {
2690  AVDictionary **m;
2691  char type, *val;
2692  const char *stream_spec;
2693  int index = 0, j, ret = 0;
2694 
2695  val = strchr(o->metadata[i].u.str, '=');
2696  if (!val) {
2697  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2698  o->metadata[i].u.str);
2699  exit_program(1);
2700  }
2701  *val++ = 0;
2702 
2703  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2704  if (type == 's') {
2705  for (j = 0; j < oc->nb_streams; j++) {
2706  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2707  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2708  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2709  char *tail;
2710  double theta = av_strtod(val, &tail);
2711  if (!*tail) {
2712  ost->rotate_overridden = 1;
2713  ost->rotate_override_value = theta;
2714  }
2715  } else {
2716  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2717  }
2718  } else if (ret < 0)
2719  exit_program(1);
2720  }
2721  }
2722  else {
2723  switch (type) {
2724  case 'g':
2725  m = &oc->metadata;
2726  break;
2727  case 'c':
2728  if (index < 0 || index >= oc->nb_chapters) {
2729  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2730  exit_program(1);
2731  }
2732  m = &oc->chapters[index]->metadata;
2733  break;
2734  case 'p':
2735  if (index < 0 || index >= oc->nb_programs) {
2736  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2737  exit_program(1);
2738  }
2739  m = &oc->programs[index]->metadata;
2740  break;
2741  default:
2742  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2743  exit_program(1);
2744  }
2745  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2746  }
2747  }
2748 
2749  return 0;
2750 }
2751 
2752 static int opt_target(void *optctx, const char *opt, const char *arg)
2753 {
2754  OptionsContext *o = optctx;
2755  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2756  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2757 
2758  if (!strncmp(arg, "pal-", 4)) {
2759  norm = PAL;
2760  arg += 4;
2761  } else if (!strncmp(arg, "ntsc-", 5)) {
2762  norm = NTSC;
2763  arg += 5;
2764  } else if (!strncmp(arg, "film-", 5)) {
2765  norm = FILM;
2766  arg += 5;
2767  } else {
2768  /* Try to determine PAL/NTSC by peeking in the input files */
2769  if (nb_input_files) {
2770  int i, j, fr;
2771  for (j = 0; j < nb_input_files; j++) {
2772  for (i = 0; i < input_files[j]->nb_streams; i++) {
2773  AVStream *st = input_files[j]->ctx->streams[i];
2775  continue;
2776  fr = st->time_base.den * 1000 / st->time_base.num;
2777  if (fr == 25000) {
2778  norm = PAL;
2779  break;
2780  } else if ((fr == 29970) || (fr == 23976)) {
2781  norm = NTSC;
2782  break;
2783  }
2784  }
2785  if (norm != UNKNOWN)
2786  break;
2787  }
2788  }
2789  if (norm != UNKNOWN)
2790  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2791  }
2792 
2793  if (norm == UNKNOWN) {
2794  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2795  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2796  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2797  exit_program(1);
2798  }
2799 
2800  if (!strcmp(arg, "vcd")) {
2801  opt_video_codec(o, "c:v", "mpeg1video");
2802  opt_audio_codec(o, "c:a", "mp2");
2803  parse_option(o, "f", "vcd", options);
2804 
2805  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2806  parse_option(o, "r", frame_rates[norm], options);
2807  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2808 
2809  opt_default(NULL, "b:v", "1150000");
2810  opt_default(NULL, "maxrate:v", "1150000");
2811  opt_default(NULL, "minrate:v", "1150000");
2812  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2813 
2814  opt_default(NULL, "b:a", "224000");
2815  parse_option(o, "ar", "44100", options);
2816  parse_option(o, "ac", "2", options);
2817 
2818  opt_default(NULL, "packetsize", "2324");
2819  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2820 
2821  /* We have to offset the PTS, so that it is consistent with the SCR.
2822  SCR starts at 36000, but the first two packs contain only padding
2823  and the first pack from the other stream, respectively, may also have
2824  been written before.
2825  So the real data starts at SCR 36000+3*1200. */
2826  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2827  } else if (!strcmp(arg, "svcd")) {
2828 
2829  opt_video_codec(o, "c:v", "mpeg2video");
2830  opt_audio_codec(o, "c:a", "mp2");
2831  parse_option(o, "f", "svcd", options);
2832 
2833  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2834  parse_option(o, "r", frame_rates[norm], options);
2835  parse_option(o, "pix_fmt", "yuv420p", options);
2836  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2837 
2838  opt_default(NULL, "b:v", "2040000");
2839  opt_default(NULL, "maxrate:v", "2516000");
2840  opt_default(NULL, "minrate:v", "0"); // 1145000;
2841  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2842  opt_default(NULL, "scan_offset", "1");
2843 
2844  opt_default(NULL, "b:a", "224000");
2845  parse_option(o, "ar", "44100", options);
2846 
2847  opt_default(NULL, "packetsize", "2324");
2848 
2849  } else if (!strcmp(arg, "dvd")) {
2850 
2851  opt_video_codec(o, "c:v", "mpeg2video");
2852  opt_audio_codec(o, "c:a", "ac3");
2853  parse_option(o, "f", "dvd", options);
2854 
2855  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2856  parse_option(o, "r", frame_rates[norm], options);
2857  parse_option(o, "pix_fmt", "yuv420p", options);
2858  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2859 
2860  opt_default(NULL, "b:v", "6000000");
2861  opt_default(NULL, "maxrate:v", "9000000");
2862  opt_default(NULL, "minrate:v", "0"); // 1500000;
2863  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2864 
2865  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2866  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2867 
2868  opt_default(NULL, "b:a", "448000");
2869  parse_option(o, "ar", "48000", options);
2870 
2871  } else if (!strncmp(arg, "dv", 2)) {
2872 
2873  parse_option(o, "f", "dv", options);
2874 
2875  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2876  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2877  norm == PAL ? "yuv420p" : "yuv411p", options);
2878  parse_option(o, "r", frame_rates[norm], options);
2879 
2880  parse_option(o, "ar", "48000", options);
2881  parse_option(o, "ac", "2", options);
2882 
2883  } else {
2884  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2885  return AVERROR(EINVAL);
2886  }
2887 
2890 
2891  return 0;
2892 }
2893 
2894 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2895 {
2897  vstats_filename = av_strdup (arg);
2898  return 0;
2899 }
2900 
2901 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2902 {
2903  char filename[40];
2904  time_t today2 = time(NULL);
2905  struct tm *today = localtime(&today2);
2906 
2907  if (!today) { // maybe tomorrow
2908  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2909  exit_program(1);
2910  }
2911 
2912  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2913  today->tm_sec);
2914  return opt_vstats_file(NULL, opt, filename);
2915 }
2916 
2917 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2918 {
2919  OptionsContext *o = optctx;
2920  return parse_option(o, "frames:v", arg, options);
2921 }
2922 
2923 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2924 {
2925  OptionsContext *o = optctx;
2926  return parse_option(o, "frames:a", arg, options);
2927 }
2928 
2929 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2930 {
2931  OptionsContext *o = optctx;
2932  return parse_option(o, "frames:d", arg, options);
2933 }
2934 
2935 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2936 {
2937  int ret;
2938  AVDictionary *cbak = codec_opts;
2939  AVDictionary *fbak = format_opts;
2940  codec_opts = NULL;
2941  format_opts = NULL;
2942 
2943  ret = opt_default(NULL, opt, arg);
2944 
2945  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2949  codec_opts = cbak;
2950  format_opts = fbak;
2951 
2952  return ret;
2953 }
2954 
2955 static int opt_preset(void *optctx, const char *opt, const char *arg)
2956 {
2957  OptionsContext *o = optctx;
2958  FILE *f=NULL;
2959  char filename[1000], line[1000], tmp_line[1000];
2960  const char *codec_name = NULL;
2961 
2962  tmp_line[0] = *opt;
2963  tmp_line[1] = 0;
2964  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2965 
2966  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2967  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2968  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2969  }else
2970  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2971  exit_program(1);
2972  }
2973 
2974  while (fgets(line, sizeof(line), f)) {
2975  char *key = tmp_line, *value, *endptr;
2976 
2977  if (strcspn(line, "#\n\r") == 0)
2978  continue;
2979  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2980  if (!av_strtok(key, "=", &value) ||
2981  !av_strtok(value, "\r\n", &endptr)) {
2982  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2983  exit_program(1);
2984  }
2985  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2986 
2987  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2988  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2989  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2990  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2991  else if (opt_default_new(o, key, value) < 0) {
2992  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2993  filename, line, key, value);
2994  exit_program(1);
2995  }
2996  }
2997 
2998  fclose(f);
2999 
3000  return 0;
3001 }
3002 
3003 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3004 {
3005  OptionsContext *o = optctx;
3006  char *s = av_asprintf("%s:%c", opt + 1, *opt);
3007  int ret = parse_option(o, s, arg, options);
3008  av_free(s);
3009  return ret;
3010 }
3011 
3012 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3013 {
3014  OptionsContext *o = optctx;
3015 
3016  if(!strcmp(opt, "ab")){
3017  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3018  return 0;
3019  } else if(!strcmp(opt, "b")){
3020  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3021  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3022  return 0;
3023  }
3024  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3025  return 0;
3026 }
3027 
3028 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3029 {
3030  OptionsContext *o = optctx;
3031  char *s;
3032  int ret;
3033  if(!strcmp(opt, "qscale")){
3034  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3035  return parse_option(o, "q:v", arg, options);
3036  }
3037  s = av_asprintf("q%s", opt + 6);
3038  ret = parse_option(o, s, arg, options);
3039  av_free(s);
3040  return ret;
3041 }
3042 
3043 static int opt_profile(void *optctx, const char *opt, const char *arg)
3044 {
3045  OptionsContext *o = optctx;
3046  if(!strcmp(opt, "profile")){
3047  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3048  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3049  return 0;
3050  }
3051  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3052  return 0;
3053 }
3054 
3055 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3056 {
3057  OptionsContext *o = optctx;
3058  return parse_option(o, "filter:v", arg, options);
3059 }
3060 
3061 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3062 {
3063  OptionsContext *o = optctx;
3064  return parse_option(o, "filter:a", arg, options);
3065 }
3066 
3067 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3068 {
3069  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3070  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3071  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3072  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3073 
3076  return 0;
3077 }
3078 
3079 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3080 {
3081  OptionsContext *o = optctx;
3082  char *tcr = av_asprintf("timecode=%s", arg);
3083  int ret = parse_option(o, "metadata:g", tcr, options);
3084  if (ret >= 0)
3085  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3086  av_free(tcr);
3087  return ret;
3088 }
3089 
3090 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3091 {
3092  OptionsContext *o = optctx;
3093  char layout_str[32];
3094  char *stream_str;
3095  char *ac_str;
3096  int ret, channels, ac_str_size;
3097  uint64_t layout;
3098 
3099  layout = av_get_channel_layout(arg);
3100  if (!layout) {
3101  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3102  return AVERROR(EINVAL);
3103  }
3104  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3105  ret = opt_default_new(o, opt, layout_str);
3106  if (ret < 0)
3107  return ret;
3108 
3109  /* set 'ac' option based on channel layout */
3110  channels = av_get_channel_layout_nb_channels(layout);
3111  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3112  stream_str = strchr(opt, ':');
3113  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3114  ac_str = av_mallocz(ac_str_size);
3115  if (!ac_str)
3116  return AVERROR(ENOMEM);
3117  av_strlcpy(ac_str, "ac", 3);
3118  if (stream_str)
3119  av_strlcat(ac_str, stream_str, ac_str_size);
3120  ret = parse_option(o, ac_str, layout_str, options);
3121  av_free(ac_str);
3122 
3123  return ret;
3124 }
3125 
3126 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3127 {
3128  OptionsContext *o = optctx;
3129  return parse_option(o, "q:a", arg, options);
3130 }
3131 
3132 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3133 {
3135  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3136  return AVERROR(ENOMEM);
3139  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3140  return AVERROR(ENOMEM);
3141 
3143 
3144  return 0;
3145 }
3146 
3147 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3148 {
3149  uint8_t *graph_desc = read_file(arg);
3150  if (!graph_desc)
3151  return AVERROR(EINVAL);
3152 
3154  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3155  return AVERROR(ENOMEM);
3157  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3158 
3160 
3161  return 0;
3162 }
3163 
3164 void show_help_default(const char *opt, const char *arg)
3165 {
3166  /* per-file options have at least one of those set */
3167  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3168  int show_advanced = 0, show_avoptions = 0;
3169 
3170  if (opt && *opt) {
3171  if (!strcmp(opt, "long"))
3172  show_advanced = 1;
3173  else if (!strcmp(opt, "full"))
3174  show_advanced = show_avoptions = 1;
3175  else
3176  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3177  }
3178 
3179  show_usage();
3180 
3181  printf("Getting help:\n"
3182  " -h -- print basic options\n"
3183  " -h long -- print more options\n"
3184  " -h full -- print all options (including all format and codec specific options, very long)\n"
3185  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3186  " See man %s for detailed description of the options.\n"
3187  "\n", program_name);
3188 
3189  show_help_options(options, "Print help / information / capabilities:",
3190  OPT_EXIT, 0, 0);
3191 
3192  show_help_options(options, "Global options (affect whole program "
3193  "instead of just one file:",
3194  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3195  if (show_advanced)
3196  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3197  per_file | OPT_EXIT, 0);
3198 
3199  show_help_options(options, "Per-file main options:", 0,
3201  OPT_EXIT, per_file);
3202  if (show_advanced)
3203  show_help_options(options, "Advanced per-file options:",
3204  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3205 
3206  show_help_options(options, "Video options:",
3208  if (show_advanced)
3209  show_help_options(options, "Advanced Video options:",
3211 
3212  show_help_options(options, "Audio options:",
3214  if (show_advanced)
3215  show_help_options(options, "Advanced Audio options:",
3217  show_help_options(options, "Subtitle options:",
3218  OPT_SUBTITLE, 0, 0);
3219  printf("\n");
3220 
3221  if (show_avoptions) {
3225 #if CONFIG_SWSCALE
3227 #endif
3228 #if CONFIG_SWRESAMPLE
3230 #endif
3233  }
3234 }
3235 
3236 void show_usage(void)
3237 {
3238  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3239  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3240  av_log(NULL, AV_LOG_INFO, "\n");
3241 }
3242 
3243 enum OptGroup {
3246 };
3247 
3248 static const OptionGroupDef groups[] = {
3249  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3250  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3251 };
3252 
3253 static int open_files(OptionGroupList *l, const char *inout,
3254  int (*open_file)(OptionsContext*, const char*))
3255 {
3256  int i, ret;
3257 
3258  for (i = 0; i < l->nb_groups; i++) {
3259  OptionGroup *g = &l->groups[i];
3260  OptionsContext o;
3261 
3262  init_options(&o);
3263  o.g = g;
3264 
3265  ret = parse_optgroup(&o, g);
3266  if (ret < 0) {
3267  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3268  "%s.\n", inout, g->arg);
3269  return ret;
3270  }
3271 
3272  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3273  ret = open_file(&o, g->arg);
3274  uninit_options(&o);
3275  if (ret < 0) {
3276  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3277  inout, g->arg);
3278  return ret;
3279  }
3280  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3281  }
3282 
3283  return 0;
3284 }
3285 
3286 int ffmpeg_parse_options(int argc, char **argv)
3287 {
3288  OptionParseContext octx;
3289  uint8_t error[128];
3290  int ret;
3291 
3292  memset(&octx, 0, sizeof(octx));
3293 
3294  /* split the commandline into an internal representation */
3295  ret = split_commandline(&octx, argc, argv, options, groups,
3296  FF_ARRAY_ELEMS(groups));
3297  if (ret < 0) {
3298  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3299  goto fail;
3300  }
3301 
3302  /* apply global options */
3303  ret = parse_optgroup(NULL, &octx.global_opts);
3304  if (ret < 0) {
3305  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3306  goto fail;
3307  }
3308 
3309  /* configure terminal and setup signal handlers */
3310  term_init();
3311 
3312  /* open input files */
3313  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3314  if (ret < 0) {
3315  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3316  goto fail;
3317  }
3318 
3319  /* create the complex filtergraphs */
3320  ret = init_complex_filters();
3321  if (ret < 0) {
3322  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3323  goto fail;
3324  }
3325 
3326  /* open output files */
3327  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3328  if (ret < 0) {
3329  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3330  goto fail;
3331  }
3332 
3334 
3335 fail:
3336  uninit_parse_context(&octx);
3337  if (ret < 0) {
3338  av_strerror(ret, error, sizeof(error));
3339  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3340  }
3341  return ret;
3342 }
3343 
3344 static int opt_progress(void *optctx, const char *opt, const char *arg)
3345 {
3346  AVIOContext *avio = NULL;
3347  int ret;
3348 
3349  if (!strcmp(arg, "-"))
3350  arg = "pipe:";
3351  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3352  if (ret < 0) {
3353  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3354  arg, av_err2str(ret));
3355  return ret;
3356  }
3357  progress_avio = avio;
3358  return 0;
3359 }
3360 
3361 #define OFFSET(x) offsetof(OptionsContext, x)
3362 const OptionDef options[] = {
3363  /* main options */
3365  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3366  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3367  "force format", "fmt" },
3368  { "y", OPT_BOOL, { &file_overwrite },
3369  "overwrite output files" },
3370  { "n", OPT_BOOL, { &no_file_overwrite },
3371  "never overwrite output files" },
3372  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3373  "Ignore unknown stream types" },
3374  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3375  "Copy unknown stream types" },
3376  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3377  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3378  "codec name", "codec" },
3379  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3380  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3381  "codec name", "codec" },
3382  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3383  OPT_OUTPUT, { .off = OFFSET(presets) },
3384  "preset name", "preset" },
3385  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3386  OPT_OUTPUT, { .func_arg = opt_map },
3387  "set input stream mapping",
3388  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3389  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3390  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3391  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3392  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3393  "set metadata information of outfile from infile",
3394  "outfile[,metadata]:infile[,metadata]" },
3395  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3396  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3397  "set chapters mapping", "input_file_index" },
3398  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3399  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3400  "record or transcode \"duration\" seconds of audio/video",
3401  "duration" },
3402  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3403  "record or transcode stop time", "time_stop" },
3404  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3405  "set the limit file size in bytes", "limit_size" },
3406  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3407  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3408  "set the start time offset", "time_off" },
3409  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3410  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3411  "set the start time offset relative to EOF", "time_off" },
3412  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3413  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3414  "enable/disable seeking by timestamp with -ss" },
3415  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3416  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3417  "enable/disable accurate seeking with -ss" },
3418  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3419  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3420  "set the input ts offset", "time_off" },
3421  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3422  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3423  "set the input ts scale", "scale" },
3424  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3425  "set the recording timestamp ('now' to set the current time)", "time" },
3426  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3427  "add metadata", "string=string" },
3428  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3429  "add program with specified streams", "title=string:st=number..." },
3430  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3431  OPT_OUTPUT, { .func_arg = opt_data_frames },
3432  "set the number of data frames to output", "number" },
3433  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3434  "add timings for benchmarking" },
3435  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3436  "add timings for each task" },
3437  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3438  "write program-readable progress information", "url" },
3439  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3440  "enable or disable interaction on standard input" },
3441  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3442  "set max runtime in seconds", "limit" },
3443  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3444  "dump each input packet" },
3445  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3446  "when dumping packets, also dump the payload" },
3447  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3448  OPT_INPUT, { .off = OFFSET(rate_emu) },
3449  "read input at native frame rate", "" },
3450  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3451  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3452  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3453  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3454  "video sync method", "" },
3455  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3456  "frame drop threshold", "" },
3457  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3458  "audio sync method", "" },
3459  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3460  "audio drift threshold", "threshold" },
3461  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3462  "copy timestamps" },
3463  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3464  "shift input timestamps to start at 0 when using copyts" },
3465  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3466  "copy input stream time base when stream copying", "mode" },
3467  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3468  OPT_OUTPUT, { .off = OFFSET(shortest) },
3469  "finish encoding within shortest input" },
3470  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3471  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3472  "bitexact mode" },
3473  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3474  OPT_OUTPUT, { .off = OFFSET(apad) },
3475  "audio pad", "" },
3476  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3477  "timestamp discontinuity delta threshold", "threshold" },
3478  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3479  "timestamp error delta threshold", "threshold" },
3480  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3481  "exit on error", "error" },
3482  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3483  "abort on the specified condition flags", "flags" },
3484  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3485  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3486  "copy initial non-keyframes" },
3487  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3488  "copy or discard frames before start time" },
3489  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3490  "set the number of frames to output", "number" },
3491  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3492  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3493  "force codec tag/fourcc", "fourcc/tag" },
3494  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3495  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3496  "use fixed quality scale (VBR)", "q" },
3497  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3498  OPT_OUTPUT, { .func_arg = opt_qscale },
3499  "use fixed quality scale (VBR)", "q" },
3500  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3501  "set profile", "profile" },
3502  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3503  "set stream filtergraph", "filter_graph" },
3504  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3505  "number of non-complex filter threads" },
3506  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3507  "read stream filtergraph description from a file", "filename" },
3508  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3509  "reinit filtergraph on input parameter changes", "" },
3510  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3511  "create a complex filtergraph", "graph_description" },
3512  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3513  "number of threads for -filter_complex" },
3514  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3515  "create a complex filtergraph", "graph_description" },
3516  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3517  "read complex filtergraph description from a file", "filename" },
3518  { "stats", OPT_BOOL, { &print_stats },
3519  "print progress report during encoding", },
3520  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3521  OPT_OUTPUT, { .func_arg = opt_attach },
3522  "add an attachment to the output file", "filename" },
3523  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3524  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3525  "extract an attachment into a file", "filename" },
3526  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3527  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3528  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3529  "print timestamp debugging info" },
3530  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3531  "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3532  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3533  OPT_INPUT, { .off = OFFSET(discard) },
3534  "discard", "" },
3535  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3536  OPT_OUTPUT, { .off = OFFSET(disposition) },
3537  "disposition", "" },
3538  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3539  { .off = OFFSET(thread_queue_size) },
3540  "set the maximum number of queued packets from the demuxer" },
3541  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3542  "read and decode the streams to fill missing information with heuristics" },
3543 
3544  /* video options */
3545  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3546  "set the number of video frames to output", "number" },
3547  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3548  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3549  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3551  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3552  "set frame size (WxH or abbreviation)", "size" },
3553  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3554  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3555  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3556  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3557  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3558  "set pixel format", "format" },
3559  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3560  "set the number of bits per raw sample", "number" },
3561  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3562  "deprecated use -g 1" },
3564  "disable video" },
3565  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3566  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3567  "rate control override for specific intervals", "override" },
3568  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3569  OPT_OUTPUT, { .func_arg = opt_video_codec },
3570  "force video codec ('copy' to copy stream)", "codec" },
3571  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3572  "Removed" },
3573  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3574  "Removed" },
3575  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3576  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3577  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3578  "select the pass number (1 to 3)", "n" },
3579  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3580  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3581  "select two pass log file name prefix", "prefix" },
3582  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3583  "this option is deprecated, use the yadif filter instead" },
3584  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3585  "calculate PSNR of compressed frames" },
3586  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3587  "dump video coding statistics to file" },
3588  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3589  "dump video coding statistics to file", "file" },
3590  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3591  "Version of the vstats format to use."},
3592  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3593  "set video filters", "filter_graph" },
3594  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3595  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3596  "specify intra matrix coeffs", "matrix" },
3597  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3598  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3599  "specify inter matrix coeffs", "matrix" },
3600  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3601  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3602  "specify intra matrix coeffs", "matrix" },
3603  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3604  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3605  "top=1/bottom=0/auto=-1 field first", "" },
3606  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3607  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3608  "force video tag/fourcc", "fourcc/tag" },
3609  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3610  "show QP histogram" },
3611  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3612  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3613  "force the selected framerate, disable the best supported framerate selection" },
3614  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3615  OPT_OUTPUT, { .func_arg = opt_streamid },
3616  "set the value of an outfile streamid", "streamIndex:value" },
3617  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3618  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3619  "force key frames at specified timestamps", "timestamps" },
3620  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3621  "audio bitrate (please use -b:a)", "bitrate" },
3622  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3623  "video bitrate (please use -b:v)", "bitrate" },
3624  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3625  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3626  "use HW accelerated decoding", "hwaccel name" },
3627  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3628  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3629  "select a device for HW acceleration", "devicename" },
3630  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3631  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3632  "select output format used with HW accelerated decoding", "format" },
3633 #if CONFIG_VIDEOTOOLBOX
3634  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3635 #endif
3636  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3637  "show available HW acceleration methods" },
3638  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3639  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3640  "automatically insert correct rotate filters" },
3641 
3642  /* audio options */
3643  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3644  "set the number of audio frames to output", "number" },
3645  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3646  "set audio quality (codec-specific)", "quality", },
3647  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3648  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3649  "set audio sampling rate (in Hz)", "rate" },
3650  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3651  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3652  "set number of audio channels", "channels" },
3654  "disable audio" },
3655  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3656  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3657  "force audio codec ('copy' to copy stream)", "codec" },
3658  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3659  OPT_OUTPUT, { .func_arg = opt_old2new },
3660  "force audio tag/fourcc", "fourcc/tag" },
3661  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3662  "change audio volume (256=normal)" , "volume" },
3663  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3665  "set sample format", "format" },
3666  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3667  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3668  "set channel layout", "layout" },
3669  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3670  "set audio filters", "filter_graph" },
3671  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3672  "set the maximum number of channels to try to guess the channel layout" },
3673 
3674  /* subtitle options */
3676  "disable subtitle" },
3677  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3678  "force subtitle codec ('copy' to copy stream)", "codec" },
3679  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3680  , "force subtitle tag/fourcc", "fourcc/tag" },
3681  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3682  "fix subtitles duration" },
3683  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3684  "set canvas size (WxH or abbreviation)", "size" },
3685 
3686  /* grab options */
3687  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3688  "deprecated, use -channel", "channel" },
3689  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3690  "deprecated, use -standard", "standard" },
3691  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3692 
3693  /* muxer options */
3694  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3695  "set the maximum demux-decode delay", "seconds" },
3696  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3697  "set the initial demux-decode delay", "seconds" },
3698  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3699  "specify a file in which to print sdp information", "file" },
3700 
3701  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3702  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3703  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3704  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3705  "two special values are defined - "
3706  "0 = use frame rate (video) or sample rate (audio),"
3707  "-1 = match source time base", "ratio" },
3708 
3709  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3710  "A comma-separated list of bitstream filters", "bitstream_filters" },
3711  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3712  "deprecated", "audio bitstream_filters" },
3713  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3714  "deprecated", "video bitstream_filters" },
3715 
3716  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3717  "set the audio options to the indicated preset", "preset" },
3718  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3719  "set the video options to the indicated preset", "preset" },
3720  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3721  "set the subtitle options to the indicated preset", "preset" },
3722  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723  "set options from indicated preset file", "filename" },
3724 
3725  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3726  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3727 
3728  /* data codec support */
3729  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3730  "force data codec ('copy' to copy stream)", "codec" },
3731  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3732  "disable data" },
3733 
3734 #if CONFIG_VAAPI
3735  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3736  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3737 #endif
3738 
3739 #if CONFIG_QSV
3740  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3741  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3742 #endif
3743 
3744  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3745  "initialise hardware device", "args" },
3746  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3747  "set hardware device used when filtering", "device" },
3748 
3749  { NULL, },
3750 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1580
int nb_bitstream_filters
Definition: ffmpeg.h:462
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:54
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1154
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:414
AVRational enc_timebase
Definition: ffmpeg.h:460
char * vstats_filename
Definition: ffmpeg_opt.c:83
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:45
int nb_dump_attachment
Definition: ffmpeg.h:127
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2078
void show_usage(void)
Definition: ffmpeg_opt.c:3236
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:3087
const char const char void * val
Definition: avisynth_c.h:771
int audio_sync_method
Definition: ffmpeg_opt.c:91
AVDictionary * resample_opts
Definition: cmdutils.h:320
int keep_pix_fmt
Definition: ffmpeg.h:528
Bytestream IO Context.
Definition: avio.h:161
float mux_preload
Definition: ffmpeg.h:153
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:513
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5802
#define OPT_EXPERT
Definition: cmdutils.h:163
int start_at_zero
Definition: ffmpeg_opt.c:100
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:558
void term_init(void)
Definition: ffmpeg.c:387
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
int nb_outputs
Definition: ffmpeg.h:292
int copy_tb
Definition: ffmpeg_opt.c:101
static const char * format[]
Definition: af_aiir.c:331
char * qsv_device
Definition: ffmpeg_qsv.c:31
AVDictionary * swr_opts
Definition: ffmpeg.h:509
int qp_hist
Definition: ffmpeg_opt.c:106
AVDictionary * swr_opts
Definition: cmdutils.h:322
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
void term_exit(void)
Definition: ffmpeg.c:328
int stream_copy
Definition: ffmpeg.h:514
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:879
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2929
int do_benchmark
Definition: ffmpeg_opt.c:95
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1629
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1420
AVOption.
Definition: opt.h:246
AVRational frame_rate
Definition: ffmpeg.h:477
int audio_channels
Definition: rtp.c:40
int64_t start_time_eof
Definition: ffmpeg.h:100
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:148
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c: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:1742
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't overwrite existing entries.
Definition: dict.h:79
static int input_sync
Definition: ffmpeg_opt.c:119
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:78
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:753
AVRational framerate
Definition: ffmpeg.h:333
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
enum AVCodecID video_codec
default video codec
Definition: avformat.h:518
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2071
channels
Definition: aptx.c:30
#define OPT_AUDIO
Definition: cmdutils.h:166
int64_t max_pts
Definition: ffmpeg.h:322
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
AVFilterInOut * out_tmp
Definition: ffmpeg.h:266
int bitexact
Definition: ffmpeg.h:156
int decoding_needed
Definition: ffmpeg.h:300
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3931
int qscale
Definition: avcodec.h:827
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:936
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int rotate_overridden
Definition: ffmpeg.h:481
int index
stream index in AVFormatContext
Definition: avformat.h:875
int max_muxing_queue_size
Definition: ffmpeg.h:542
int nb_frame_pix_fmts
Definition: ffmpeg.h:115
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int do_deinterlace
Definition: ffmpeg_opt.c:94
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3061
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:655
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1933
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:774
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1764
Convenience header that includes libavutil's core.
const char * arg
Definition: cmdutils.h:313
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3132
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
int cuvid_init(AVCodecContext *s)
Definition: ffmpeg_cuvid.c:30
#define OPT_DATA
Definition: cmdutils.h:172
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2577
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:2011
enum AVMediaType type
Definition: avcodec.h:3468
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:805
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:2781
int nb_input_streams
Definition: ffmpeg.c:148
static int audio_disable
Definition: ffplay.c:319
const char * name
Definition: ffmpeg.h:68
AVDictionary * metadata
Definition: avformat.h:1312
static const char * audio_codec_name
Definition: ffplay.c:343
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1316
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5755
#define OPT_DOUBLE
Definition: cmdutils.h:180
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1549
#define OPT_FLOAT
Definition: cmdutils.h:168
AVCodec.
Definition: avcodec.h:3455
#define VSYNC_VFR
Definition: ffmpeg.h:52
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1391
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:215
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2079
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3923
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:2955
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:463
Definition: ftp.c:34
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:114
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:261
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:46
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:727
int encoding_needed
Definition: ffmpeg.h:447
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3126
Format I/O context.
Definition: avformat.h:1351
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:294
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:480
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:81
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1506
enum HWAccelID id
Definition: ffmpeg.h:70
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:118
const char * name
Definition: opt.h:247
char * logfile_prefix
Definition: ffmpeg.h:499
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1485
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
int user_set_discard
Definition: ffmpeg.h:299
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:121
static int64_t start_time
Definition: ffplay.c:330
int copy_initial_nonkeyframes
Definition: ffmpeg.h:524
int filter_nbthreads
Definition: ffmpeg_opt.c:110
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2218
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:526
uint8_t
static int nb_streams
Definition: ffprobe.c:276
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:508
Opaque data information usually continuous.
Definition: avutil.h:203
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:545
#define OPT_OUTPUT
Definition: cmdutils.h:182
int width
Video only.
Definition: avcodec.h:3997
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:661
#define HAS_ARG
Definition: cmdutils.h:161
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:1994
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:997
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3248
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:3186
int id
unique ID to identify the chapter
Definition: avformat.h:1309
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3067
int id
Format-specific stream ID.
Definition: avformat.h:881
#define OPT_OFFSET
Definition: cmdutils.h:175
int vstats_version
Definition: ffmpeg_opt.c:112
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4455
int nb_max_frames
Definition: ffmpeg.h:170
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
int shortest
Definition: ffmpeg.h:562
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2901
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:2090
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
int channel_idx
Definition: ffmpeg.h:91
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:672
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int nb_streams
Definition: ffmpeg.h:409
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
int sync_file_index
Definition: ffmpeg.h:85
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4554
AVDictionary * resample_opts
Definition: ffmpeg.h:510
int seek_timestamp
Definition: ffmpeg.h:101
list ifile
Definition: normalize.py:6
uint32_t tag
Definition: movenc.c:1486
int * formats
Definition: ffmpeg.h:277
#define OPT_SPEC
Definition: cmdutils.h:176
int nb_input_files
Definition: ffmpeg.c:150
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2789
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:3362
int top_field_first
Definition: ffmpeg.h:334
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1499
int nb_output_streams
Definition: ffmpeg.c:153
int file_index
Definition: ffmpeg.h:296
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1537
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:319
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:648
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:249
float quality_factor
Definition: avcodec.h:828
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3028
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1370
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2136
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:907
AVDictionary * format_opts
Definition: cmdutils.c:73
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1961
int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:148
#define OPT_SUBTITLE
Definition: cmdutils.h:169
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:563
uint64_t channel_layout
Definition: ffmpeg.h:274
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:111
enum AVCodecID id
Definition: avcodec.h:3469
int rate_emu
Definition: ffmpeg.h:412
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3043
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
void check_filter_outputs(void)
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:374
FilterGraph ** filtergraphs
Definition: ffmpeg.c:157
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:481
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:3253
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
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:291
int64_t start_time
Definition: ffmpeg.h:99
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:231
int loop
Definition: ffmpeg.h:398
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:457
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:651
int ofile_idx
Definition: ffmpeg.h:92
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1190
char * url
input or output URL.
Definition: avformat.h:1447
int video_delay
Video only.
Definition: avcodec.h:4026
static int autorotate
Definition: ffplay.c:354
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1530
AudioChannelMap * audio_channel_maps
Definition: ffmpeg.h:140
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int debug_ts
Definition: ffmpeg_opt.c:102
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3927
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1634
const char * name
Definition: cmdutils.h:159
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3012
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:350
AVChapter ** chapters
Definition: avformat.h:1581
Definition: graph2dot.c:48
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
Definition: ffmpeg_opt.c:534
simple assert() macros that are a bit more flexible than ISO C assert().
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
const char * name
Name of the codec implementation.
Definition: avcodec.h:3462
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3003
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:636
int video_disable
Definition: ffmpeg.h:158
static int opt_sameq(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:222
int flags
Definition: cmdutils.h:160