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