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