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  ost->max_frames = INT64_MAX;
1315  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1316  for (i = 0; i<o->nb_max_frames; i++) {
1317  char *p = o->max_frames[i].specifier;
1318  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1319  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1320  break;
1321  }
1322  }
1323 
1324  ost->copy_prior_start = -1;
1325  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1326 
1327  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1328  while (bsfs && *bsfs) {
1329  const AVBitStreamFilter *filter;
1330  char *bsf, *bsf_options_str, *bsf_name;
1331 
1332  bsf = av_get_token(&bsfs, ",");
1333  if (!bsf)
1334  exit_program(1);
1335  bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1336  if (!bsf_name)
1337  exit_program(1);
1338 
1339  filter = av_bsf_get_by_name(bsf_name);
1340  if (!filter) {
1341  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1342  exit_program(1);
1343  }
1344 
1345  ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1346  ost->nb_bitstream_filters + 1,
1347  sizeof(*ost->bsf_ctx));
1348  if (!ost->bsf_ctx)
1349  exit_program(1);
1350 
1351  ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1352  if (ret < 0) {
1353  av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1354  exit_program(1);
1355  }
1356 
1357  ost->nb_bitstream_filters++;
1358 
1359  if (bsf_options_str && filter->priv_class) {
1360  const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1361  const char * shorthand[2] = {NULL};
1362 
1363  if (opt)
1364  shorthand[0] = opt->name;
1365 
1366  ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1367  if (ret < 0) {
1368  av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1369  exit_program(1);
1370  }
1371  }
1372  av_freep(&bsf);
1373 
1374  if (*bsfs)
1375  bsfs++;
1376  }
1377  if (ost->nb_bitstream_filters) {
1379  if (!ost->bsf_extradata_updated) {
1380  av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1381  exit_program(1);
1382  }
1383  }
1384 
1385  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1386  if (codec_tag) {
1387  uint32_t tag = strtol(codec_tag, &next, 0);
1388  if (*next)
1389  tag = AV_RL32(codec_tag);
1390  ost->st->codecpar->codec_tag =
1391  ost->enc_ctx->codec_tag = tag;
1392  }
1393 
1394  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1395  if (qscale >= 0) {
1397  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1398  }
1399 
1400  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1401  ost->disposition = av_strdup(ost->disposition);
1402 
1403  ost->max_muxing_queue_size = 128;
1404  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1405  ost->max_muxing_queue_size *= sizeof(AVPacket);
1406 
1407  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1409 
1410  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1411 
1412  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1413  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1414  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1415 
1416  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1417 
1418  ost->source_index = source_index;
1419  if (source_index >= 0) {
1420  ost->sync_ist = input_streams[source_index];
1421  input_streams[source_index]->discard = 0;
1422  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1423  }
1425 
1426  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1427  if (!ost->muxing_queue)
1428  exit_program(1);
1429 
1430  return ost;
1431 }
1432 
1433 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1434 {
1435  int i;
1436  const char *p = str;
1437  for (i = 0;; i++) {
1438  dest[i] = atoi(p);
1439  if (i == 63)
1440  break;
1441  p = strchr(p, ',');
1442  if (!p) {
1443  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1444  exit_program(1);
1445  }
1446  p++;
1447  }
1448 }
1449 
1450 /* read file contents into a string */
1451 static uint8_t *read_file(const char *filename)
1452 {
1453  AVIOContext *pb = NULL;
1454  AVIOContext *dyn_buf = NULL;
1455  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1456  uint8_t buf[1024], *str;
1457 
1458  if (ret < 0) {
1459  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1460  return NULL;
1461  }
1462 
1463  ret = avio_open_dyn_buf(&dyn_buf);
1464  if (ret < 0) {
1465  avio_closep(&pb);
1466  return NULL;
1467  }
1468  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1469  avio_write(dyn_buf, buf, ret);
1470  avio_w8(dyn_buf, 0);
1471  avio_closep(&pb);
1472 
1473  ret = avio_close_dyn_buf(dyn_buf, &str);
1474  if (ret < 0)
1475  return NULL;
1476  return str;
1477 }
1478 
1480  OutputStream *ost)
1481 {
1482  AVStream *st = ost->st;
1483 
1484  if (ost->filters_script && ost->filters) {
1485  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1486  "output stream #%d:%d.\n", nb_output_files, st->index);
1487  exit_program(1);
1488  }
1489 
1490  if (ost->filters_script)
1491  return read_file(ost->filters_script);
1492  else if (ost->filters)
1493  return av_strdup(ost->filters);
1494 
1496  "null" : "anull");
1497 }
1498 
1500  const OutputStream *ost, enum AVMediaType type)
1501 {
1502  if (ost->filters_script || ost->filters) {
1504  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1505  "Filtering and streamcopy cannot be used together.\n",
1506  ost->filters ? "Filtergraph" : "Filtergraph script",
1507  ost->filters ? ost->filters : ost->filters_script,
1508  av_get_media_type_string(type), ost->file_index, ost->index);
1509  exit_program(1);
1510  }
1511 }
1512 
1514 {
1515  AVStream *st;
1516  OutputStream *ost;
1517  AVCodecContext *video_enc;
1518  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1519 
1520  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1521  st = ost->st;
1522  video_enc = ost->enc_ctx;
1523 
1524  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1525  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1526  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1527  exit_program(1);
1528  }
1529  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1530  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1531 
1532  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1533  if (frame_aspect_ratio) {
1534  AVRational q;
1535  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1536  q.num <= 0 || q.den <= 0) {
1537  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1538  exit_program(1);
1539  }
1540  ost->frame_aspect_ratio = q;
1541  }
1542 
1543  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1544  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1545 
1546  if (!ost->stream_copy) {
1547  const char *p = NULL;
1548  char *frame_size = NULL;
1549  char *frame_pix_fmt = NULL;
1550  char *intra_matrix = NULL, *inter_matrix = NULL;
1551  char *chroma_intra_matrix = NULL;
1552  int do_pass = 0;
1553  int i;
1554 
1555  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1556  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1557  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1558  exit_program(1);
1559  }
1560 
1562  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1563  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1564  ost->keep_pix_fmt = 1;
1565  if (!*++frame_pix_fmt)
1566  frame_pix_fmt = NULL;
1567  }
1568  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1569  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1570  exit_program(1);
1571  }
1572  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1573 
1574  if (intra_only)
1575  video_enc->gop_size = 0;
1576  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1577  if (intra_matrix) {
1578  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1579  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1580  exit_program(1);
1581  }
1582  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1583  }
1584  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1585  if (chroma_intra_matrix) {
1586  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1587  if (!p) {
1588  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1589  exit_program(1);
1590  }
1591  av_codec_set_chroma_intra_matrix(video_enc, p);
1592  parse_matrix_coeffs(p, chroma_intra_matrix);
1593  }
1594  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1595  if (inter_matrix) {
1596  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1597  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1598  exit_program(1);
1599  }
1600  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1601  }
1602 
1603  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1604  for (i = 0; p; i++) {
1605  int start, end, q;
1606  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1607  if (e != 3) {
1608  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1609  exit_program(1);
1610  }
1611  video_enc->rc_override =
1612  av_realloc_array(video_enc->rc_override,
1613  i + 1, sizeof(RcOverride));
1614  if (!video_enc->rc_override) {
1615  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1616  exit_program(1);
1617  }
1618  video_enc->rc_override[i].start_frame = start;
1619  video_enc->rc_override[i].end_frame = end;
1620  if (q > 0) {
1621  video_enc->rc_override[i].qscale = q;
1622  video_enc->rc_override[i].quality_factor = 1.0;
1623  }
1624  else {
1625  video_enc->rc_override[i].qscale = 0;
1626  video_enc->rc_override[i].quality_factor = -q/100.0;
1627  }
1628  p = strchr(p, '/');
1629  if (p) p++;
1630  }
1631  video_enc->rc_override_count = i;
1632 
1633  if (do_psnr)
1634  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1635 
1636  /* two pass mode */
1637  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1638  if (do_pass) {
1639  if (do_pass & 1) {
1640  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1641  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1642  }
1643  if (do_pass & 2) {
1644  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1645  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1646  }
1647  }
1648 
1649  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1650  if (ost->logfile_prefix &&
1651  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1652  exit_program(1);
1653 
1654  if (do_pass) {
1655  char logfilename[1024];
1656  FILE *f;
1657 
1658  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1659  ost->logfile_prefix ? ost->logfile_prefix :
1661  i);
1662  if (!strcmp(ost->enc->name, "libx264")) {
1663  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1664  } else {
1665  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1666  char *logbuffer = read_file(logfilename);
1667 
1668  if (!logbuffer) {
1669  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1670  logfilename);
1671  exit_program(1);
1672  }
1673  video_enc->stats_in = logbuffer;
1674  }
1675  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1676  f = av_fopen_utf8(logfilename, "wb");
1677  if (!f) {
1679  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1680  logfilename, strerror(errno));
1681  exit_program(1);
1682  }
1683  ost->logfile = f;
1684  }
1685  }
1686  }
1687 
1688  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1689  if (ost->forced_keyframes)
1691 
1692  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1693 
1694  ost->top_field_first = -1;
1695  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1696 
1697 
1698  ost->avfilter = get_ost_filters(o, oc, ost);
1699  if (!ost->avfilter)
1700  exit_program(1);
1701  } else {
1702  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1703  }
1704 
1705  if (ost->stream_copy)
1707 
1708  return ost;
1709 }
1710 
1712 {
1713  int n;
1714  AVStream *st;
1715  OutputStream *ost;
1716  AVCodecContext *audio_enc;
1717 
1718  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1719  st = ost->st;
1720 
1721  audio_enc = ost->enc_ctx;
1722  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1723 
1724  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1725  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1726 
1727  if (!ost->stream_copy) {
1728  char *sample_fmt = NULL;
1729 
1730  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1731 
1732  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1733  if (sample_fmt &&
1734  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1735  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1736  exit_program(1);
1737  }
1738 
1739  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1740 
1741  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1742  ost->apad = av_strdup(ost->apad);
1743 
1744  ost->avfilter = get_ost_filters(o, oc, ost);
1745  if (!ost->avfilter)
1746  exit_program(1);
1747 
1748  /* check for channel mapping for this audio stream */
1749  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1751  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1752  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1753  InputStream *ist;
1754 
1755  if (map->channel_idx == -1) {
1756  ist = NULL;
1757  } else if (ost->source_index < 0) {
1758  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1759  ost->file_index, ost->st->index);
1760  continue;
1761  } else {
1762  ist = input_streams[ost->source_index];
1763  }
1764 
1765  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1767  ost->audio_channels_mapped + 1,
1768  sizeof(*ost->audio_channels_map)
1769  ) < 0 )
1770  exit_program(1);
1771 
1773  }
1774  }
1775  }
1776  }
1777 
1778  if (ost->stream_copy)
1780 
1781  return ost;
1782 }
1783 
1785 {
1786  OutputStream *ost;
1787 
1788  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1789  if (!ost->stream_copy) {
1790  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1791  exit_program(1);
1792  }
1793 
1794  return ost;
1795 }
1796 
1798 {
1799  OutputStream *ost;
1800 
1801  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1802  if (!ost->stream_copy) {
1803  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1804  exit_program(1);
1805  }
1806 
1807  return ost;
1808 }
1809 
1811 {
1812  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1813  ost->stream_copy = 1;
1814  ost->finished = 1;
1815  return ost;
1816 }
1817 
1819 {
1820  AVStream *st;
1821  OutputStream *ost;
1822  AVCodecContext *subtitle_enc;
1823 
1824  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1825  st = ost->st;
1826  subtitle_enc = ost->enc_ctx;
1827 
1828  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1829 
1830  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1831 
1832  if (!ost->stream_copy) {
1833  char *frame_size = NULL;
1834 
1835  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1836  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1837  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1838  exit_program(1);
1839  }
1840  }
1841 
1842  return ost;
1843 }
1844 
1845 /* arg format is "output-stream-index:streamid-value". */
1846 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1847 {
1848  OptionsContext *o = optctx;
1849  int idx;
1850  char *p;
1851  char idx_str[16];
1852 
1853  av_strlcpy(idx_str, arg, sizeof(idx_str));
1854  p = strchr(idx_str, ':');
1855  if (!p) {
1857  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1858  arg, opt);
1859  exit_program(1);
1860  }
1861  *p++ = '\0';
1862  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1863  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1864  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1865  return 0;
1866 }
1867 
1869 {
1870  AVFormatContext *is = ifile->ctx;
1871  AVFormatContext *os = ofile->ctx;
1872  AVChapter **tmp;
1873  int i;
1874 
1875  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1876  if (!tmp)
1877  return AVERROR(ENOMEM);
1878  os->chapters = tmp;
1879 
1880  for (i = 0; i < is->nb_chapters; i++) {
1881  AVChapter *in_ch = is->chapters[i], *out_ch;
1882  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1883  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1884  AV_TIME_BASE_Q, in_ch->time_base);
1885  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1887 
1888 
1889  if (in_ch->end < ts_off)
1890  continue;
1891  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1892  break;
1893 
1894  out_ch = av_mallocz(sizeof(AVChapter));
1895  if (!out_ch)
1896  return AVERROR(ENOMEM);
1897 
1898  out_ch->id = in_ch->id;
1899  out_ch->time_base = in_ch->time_base;
1900  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1901  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1902 
1903  if (copy_metadata)
1904  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1905 
1906  os->chapters[os->nb_chapters++] = out_ch;
1907  }
1908  return 0;
1909 }
1910 
1911 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1912 {
1913  int i, err;
1915 
1916  ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1917  ic->interrupt_callback = int_cb;
1918  err = avformat_open_input(&ic, filename, NULL, NULL);
1919  if (err < 0)
1920  return err;
1921  /* copy stream format */
1922  for(i=0;i<ic->nb_streams;i++) {
1923  AVStream *st;
1924  OutputStream *ost;
1925  AVCodec *codec;
1926  const char *enc_config;
1927 
1928  codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1929  if (!codec) {
1930  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1931  return AVERROR(EINVAL);
1932  }
1933  if (codec->type == AVMEDIA_TYPE_AUDIO)
1934  opt_audio_codec(o, "c:a", codec->name);
1935  else if (codec->type == AVMEDIA_TYPE_VIDEO)
1936  opt_video_codec(o, "c:v", codec->name);
1937  ost = new_output_stream(o, s, codec->type, -1);
1938  st = ost->st;
1939 
1940  avcodec_get_context_defaults3(st->codec, codec);
1942  if (enc_config) {
1943  AVDictionary *opts = NULL;
1944  av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1945  av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1946  av_dict_free(&opts);
1947  }
1948 
1949  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1950  choose_sample_fmt(st, codec);
1951  else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1952  choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1953  avcodec_copy_context(ost->enc_ctx, st->codec);
1954  if (enc_config)
1955  av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1956  }
1957 
1958  avformat_close_input(&ic);
1959  return err;
1960 }
1961 
1963  AVFormatContext *oc)
1964 {
1965  OutputStream *ost;
1966 
1967  switch (ofilter->type) {
1968  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1969  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1970  default:
1971  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1972  "currently.\n");
1973  exit_program(1);
1974  }
1975 
1976  ost->source_index = -1;
1977  ost->filter = ofilter;
1978 
1979  ofilter->ost = ost;
1980  ofilter->format = -1;
1981 
1982  if (ost->stream_copy) {
1983  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1984  "which is fed from a complex filtergraph. Filtering and streamcopy "
1985  "cannot be used together.\n", ost->file_index, ost->index);
1986  exit_program(1);
1987  }
1988 
1989  if (ost->avfilter && (ost->filters || ost->filters_script)) {
1990  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1992  "%s '%s' was specified through the %s option "
1993  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1994  "%s and -filter_complex cannot be used together for the same stream.\n",
1995  ost->filters ? "Filtergraph" : "Filtergraph script",
1996  ost->filters ? ost->filters : ost->filters_script,
1997  opt, ost->file_index, ost->index, opt);
1998  exit_program(1);
1999  }
2000 
2001  avfilter_inout_free(&ofilter->out_tmp);
2002 }
2003 
2004 static int init_complex_filters(void)
2005 {
2006  int i, ret = 0;
2007 
2008  for (i = 0; i < nb_filtergraphs; i++) {
2010  if (ret < 0)
2011  return ret;
2012  }
2013  return 0;
2014 }
2015 
2016 static int open_output_file(OptionsContext *o, const char *filename)
2017 {
2018  AVFormatContext *oc;
2019  int i, j, err;
2020  AVOutputFormat *file_oformat;
2021  OutputFile *of;
2022  OutputStream *ost;
2023  InputStream *ist;
2024  AVDictionary *unused_opts = NULL;
2025  AVDictionaryEntry *e = NULL;
2026  int format_flags = 0;
2027 
2028  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2029  o->stop_time = INT64_MAX;
2030  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2031  }
2032 
2033  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2034  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2035  if (o->stop_time <= start_time) {
2036  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2037  exit_program(1);
2038  } else {
2040  }
2041  }
2042 
2044  of = av_mallocz(sizeof(*of));
2045  if (!of)
2046  exit_program(1);
2047  output_files[nb_output_files - 1] = of;
2048 
2050  of->recording_time = o->recording_time;
2051  of->start_time = o->start_time;
2052  of->limit_filesize = o->limit_filesize;
2053  of->shortest = o->shortest;
2054  av_dict_copy(&of->opts, o->g->format_opts, 0);
2055 
2056  if (!strcmp(filename, "-"))
2057  filename = "pipe:";
2058 
2059  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2060  if (!oc) {
2061  print_error(filename, err);
2062  exit_program(1);
2063  }
2064 
2065  of->ctx = oc;
2066  if (o->recording_time != INT64_MAX)
2067  oc->duration = o->recording_time;
2068 
2069  file_oformat= oc->oformat;
2070  oc->interrupt_callback = int_cb;
2071 
2072  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2073  if (e) {
2074  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2075  av_opt_eval_flags(oc, o, e->value, &format_flags);
2076  }
2077 
2078  /* create streams for all unlabeled output pads */
2079  for (i = 0; i < nb_filtergraphs; i++) {
2080  FilterGraph *fg = filtergraphs[i];
2081  for (j = 0; j < fg->nb_outputs; j++) {
2082  OutputFilter *ofilter = fg->outputs[j];
2083 
2084  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2085  continue;
2086 
2087  switch (ofilter->type) {
2088  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2089  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2090  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2091  }
2092  init_output_filter(ofilter, o, oc);
2093  }
2094  }
2095 
2096  /* ffserver seeking with date=... needs a date reference */
2097  if (!strcmp(file_oformat->name, "ffm") &&
2098  !(format_flags & AVFMT_FLAG_BITEXACT) &&
2099  av_strstart(filename, "http:", NULL)) {
2100  int err = parse_option(o, "metadata", "creation_time=now", options);
2101  if (err < 0) {
2102  print_error(filename, err);
2103  exit_program(1);
2104  }
2105  }
2106 
2107  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2108  av_strstart(filename, "http:", NULL)) {
2109  int j;
2110  /* special case for files sent to ffserver: we get the stream
2111  parameters from ffserver */
2112  int err = read_ffserver_streams(o, oc, filename);
2113  if (err < 0) {
2114  print_error(filename, err);
2115  exit_program(1);
2116  }
2117  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2118  ost = output_streams[j];
2119  for (i = 0; i < nb_input_streams; i++) {
2120  ist = input_streams[i];
2121  if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2122  ost->sync_ist= ist;
2123  ost->source_index= i;
2124  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2125  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2126  ist->discard = 0;
2127  ist->st->discard = ist->user_set_discard;
2128  break;
2129  }
2130  }
2131  if(!ost->sync_ist){
2132  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));
2133  exit_program(1);
2134  }
2135  }
2136  } else if (!o->nb_stream_maps) {
2137  char *subtitle_codec_name = NULL;
2138  /* pick the "best" stream of each type */
2139 
2140  /* video: highest resolution */
2142  int area = 0, idx = -1;
2143  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2144  for (i = 0; i < nb_input_streams; i++) {
2145  int new_area;
2146  ist = input_streams[i];
2147  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2148  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2149  new_area = 1;
2150  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2151  new_area > area) {
2152  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2153  continue;
2154  area = new_area;
2155  idx = i;
2156  }
2157  }
2158  if (idx >= 0)
2159  new_video_stream(o, oc, idx);
2160  }
2161 
2162  /* audio: most channels */
2164  int best_score = 0, idx = -1;
2165  for (i = 0; i < nb_input_streams; i++) {
2166  int score;
2167  ist = input_streams[i];
2168  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2169  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2170  score > best_score) {
2171  best_score = score;
2172  idx = i;
2173  }
2174  }
2175  if (idx >= 0)
2176  new_audio_stream(o, oc, idx);
2177  }
2178 
2179  /* subtitles: pick first */
2180  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2181  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2182  for (i = 0; i < nb_input_streams; i++)
2183  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2184  AVCodecDescriptor const *input_descriptor =
2185  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2186  AVCodecDescriptor const *output_descriptor = NULL;
2187  AVCodec const *output_codec =
2189  int input_props = 0, output_props = 0;
2190  if (output_codec)
2191  output_descriptor = avcodec_descriptor_get(output_codec->id);
2192  if (input_descriptor)
2193  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2194  if (output_descriptor)
2195  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2196  if (subtitle_codec_name ||
2197  input_props & output_props ||
2198  // Map dvb teletext which has neither property to any output subtitle encoder
2199  input_descriptor && output_descriptor &&
2200  (!input_descriptor->props ||
2201  !output_descriptor->props)) {
2202  new_subtitle_stream(o, oc, i);
2203  break;
2204  }
2205  }
2206  }
2207  /* Data only if codec id match */
2208  if (!o->data_disable ) {
2210  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2211  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2212  && input_streams[i]->st->codecpar->codec_id == codec_id )
2213  new_data_stream(o, oc, i);
2214  }
2215  }
2216  } else {
2217  for (i = 0; i < o->nb_stream_maps; i++) {
2218  StreamMap *map = &o->stream_maps[i];
2219 
2220  if (map->disabled)
2221  continue;
2222 
2223  if (map->linklabel) {
2224  FilterGraph *fg;
2225  OutputFilter *ofilter = NULL;
2226  int j, k;
2227 
2228  for (j = 0; j < nb_filtergraphs; j++) {
2229  fg = filtergraphs[j];
2230  for (k = 0; k < fg->nb_outputs; k++) {
2231  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2232  if (out && !strcmp(out->name, map->linklabel)) {
2233  ofilter = fg->outputs[k];
2234  goto loop_end;
2235  }
2236  }
2237  }
2238 loop_end:
2239  if (!ofilter) {
2240  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2241  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2242  exit_program(1);
2243  }
2244  init_output_filter(ofilter, o, oc);
2245  } else {
2246  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2247 
2250  continue;
2252  continue;
2254  continue;
2255  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2256  continue;
2257 
2258  ost = NULL;
2259  switch (ist->st->codecpar->codec_type) {
2260  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2261  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2262  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2263  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2264  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2265  case AVMEDIA_TYPE_UNKNOWN:
2266  if (copy_unknown_streams) {
2267  ost = new_unknown_stream (o, oc, src_idx);
2268  break;
2269  }
2270  default:
2272  "Cannot map stream #%d:%d - unsupported type.\n",
2273  map->file_index, map->stream_index);
2274  if (!ignore_unknown_streams) {
2275  av_log(NULL, AV_LOG_FATAL,
2276  "If you want unsupported types ignored instead "
2277  "of failing, please use the -ignore_unknown option\n"
2278  "If you want them copied, please use -copy_unknown\n");
2279  exit_program(1);
2280  }
2281  }
2282  if (ost)
2283  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2284  + map->sync_stream_index];
2285  }
2286  }
2287  }
2288 
2289  /* handle attached files */
2290  for (i = 0; i < o->nb_attachments; i++) {
2291  AVIOContext *pb;
2292  uint8_t *attachment;
2293  const char *p;
2294  int64_t len;
2295 
2296  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2297  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2298  o->attachments[i]);
2299  exit_program(1);
2300  }
2301  if ((len = avio_size(pb)) <= 0) {
2302  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2303  o->attachments[i]);
2304  exit_program(1);
2305  }
2306  if (!(attachment = av_malloc(len))) {
2307  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2308  o->attachments[i]);
2309  exit_program(1);
2310  }
2311  avio_read(pb, attachment, len);
2312 
2313  ost = new_attachment_stream(o, oc, -1);
2314  ost->stream_copy = 0;
2315  ost->attachment_filename = o->attachments[i];
2316  ost->st->codecpar->extradata = attachment;
2317  ost->st->codecpar->extradata_size = len;
2318 
2319  p = strrchr(o->attachments[i], '/');
2320  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2321  avio_closep(&pb);
2322  }
2323 
2324 #if FF_API_LAVF_AVCTX
2325  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2326  AVDictionaryEntry *e;
2327  ost = output_streams[i];
2328 
2329  if ((ost->stream_copy || ost->attachment_filename)
2330  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2331  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2332  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2333  exit_program(1);
2334  }
2335 #endif
2336 
2337  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2338  av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2339  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2340  exit_program(1);
2341  }
2342 
2343  /* check if all codec options have been used */
2344  unused_opts = strip_specifiers(o->g->codec_opts);
2345  for (i = of->ost_index; i < nb_output_streams; i++) {
2346  e = NULL;
2347  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2349  av_dict_set(&unused_opts, e->key, NULL, 0);
2350  }
2351 
2352  e = NULL;
2353  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2354  const AVClass *class = avcodec_get_class();
2355  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2357  const AVClass *fclass = avformat_get_class();
2358  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2360  if (!option || foption)
2361  continue;
2362 
2363 
2364  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2365  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2366  "output file #%d (%s) is not an encoding option.\n", e->key,
2367  option->help ? option->help : "", nb_output_files - 1,
2368  filename);
2369  exit_program(1);
2370  }
2371 
2372  // gop_timecode is injected by generic code but not always used
2373  if (!strcmp(e->key, "gop_timecode"))
2374  continue;
2375 
2376  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2377  "output file #%d (%s) has not been used for any stream. The most "
2378  "likely reason is either wrong type (e.g. a video option with "
2379  "no video streams) or that it is a private option of some encoder "
2380  "which was not actually used for any stream.\n", e->key,
2381  option->help ? option->help : "", nb_output_files - 1, filename);
2382  }
2383  av_dict_free(&unused_opts);
2384 
2385  /* set the decoding_needed flags and create simple filtergraphs */
2386  for (i = of->ost_index; i < nb_output_streams; i++) {
2387  OutputStream *ost = output_streams[i];
2388 
2389  if (ost->encoding_needed && ost->source_index >= 0) {
2390  InputStream *ist = input_streams[ost->source_index];
2392 
2393  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2395  err = init_simple_filtergraph(ist, ost);
2396  if (err < 0) {
2398  "Error initializing a simple filtergraph between streams "
2399  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2400  nb_output_files - 1, ost->st->index);
2401  exit_program(1);
2402  }
2403  }
2404  }
2405 
2406  /* set the filter output constraints */
2407  if (ost->filter) {
2408  OutputFilter *f = ost->filter;
2409  int count;
2410  switch (ost->enc_ctx->codec_type) {
2411  case AVMEDIA_TYPE_VIDEO:
2412  f->frame_rate = ost->frame_rate;
2413  f->width = ost->enc_ctx->width;
2414  f->height = ost->enc_ctx->height;
2415  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2416  f->format = ost->enc_ctx->pix_fmt;
2417  } else if (ost->enc->pix_fmts) {
2418  count = 0;
2419  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2420  count++;
2421  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2422  if (!f->formats)
2423  exit_program(1);
2424  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2425  }
2426  break;
2427  case AVMEDIA_TYPE_AUDIO:
2428  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2429  f->format = ost->enc_ctx->sample_fmt;
2430  } else if (ost->enc->sample_fmts) {
2431  count = 0;
2432  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2433  count++;
2434  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2435  if (!f->formats)
2436  exit_program(1);
2437  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2438  }
2439  if (ost->enc_ctx->sample_rate) {
2440  f->sample_rate = ost->enc_ctx->sample_rate;
2441  } else if (ost->enc->supported_samplerates) {
2442  count = 0;
2443  while (ost->enc->supported_samplerates[count])
2444  count++;
2445  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2446  if (!f->sample_rates)
2447  exit_program(1);
2448  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2449  (count + 1) * sizeof(*f->sample_rates));
2450  }
2451  if (ost->enc_ctx->channels) {
2453  } else if (ost->enc->channel_layouts) {
2454  count = 0;
2455  while (ost->enc->channel_layouts[count])
2456  count++;
2457  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2458  if (!f->channel_layouts)
2459  exit_program(1);
2460  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2461  (count + 1) * sizeof(*f->channel_layouts));
2462  }
2463  break;
2464  }
2465  }
2466  }
2467 
2468  /* check filename in case of an image number is expected */
2469  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2470  if (!av_filename_number_test(oc->filename)) {
2471  print_error(oc->filename, AVERROR(EINVAL));
2472  exit_program(1);
2473  }
2474  }
2475 
2478  "No input streams but output needs an input stream\n");
2479  exit_program(1);
2480  }
2481 
2482  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2483  /* test if it already exists to avoid losing precious files */
2484  assert_file_overwrite(filename);
2485 
2486  /* open the file */
2487  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2488  &oc->interrupt_callback,
2489  &of->opts)) < 0) {
2490  print_error(filename, err);
2491  exit_program(1);
2492  }
2493  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2494  assert_file_overwrite(filename);
2495 
2496  if (o->mux_preload) {
2497  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2498  }
2499  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2500 
2501  /* copy metadata */
2502  for (i = 0; i < o->nb_metadata_map; i++) {
2503  char *p;
2504  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2505 
2506  if (in_file_index >= nb_input_files) {
2507  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2508  exit_program(1);
2509  }
2510  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2511  in_file_index >= 0 ?
2512  input_files[in_file_index]->ctx : NULL, o);
2513  }
2514 
2515  /* copy chapters */
2516  if (o->chapters_input_file >= nb_input_files) {
2517  if (o->chapters_input_file == INT_MAX) {
2518  /* copy chapters from the first input file that has them*/
2519  o->chapters_input_file = -1;
2520  for (i = 0; i < nb_input_files; i++)
2521  if (input_files[i]->ctx->nb_chapters) {
2522  o->chapters_input_file = i;
2523  break;
2524  }
2525  } else {
2526  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2527  o->chapters_input_file);
2528  exit_program(1);
2529  }
2530  }
2531  if (o->chapters_input_file >= 0)
2534 
2535  /* copy global metadata by default */
2539  if(o->recording_time != INT64_MAX)
2540  av_dict_set(&oc->metadata, "duration", NULL, 0);
2541  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2542  }
2543  if (!o->metadata_streams_manual)
2544  for (i = of->ost_index; i < nb_output_streams; i++) {
2545  InputStream *ist;
2546  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2547  continue;
2549  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2550  if (!output_streams[i]->stream_copy) {
2551  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2552  }
2553  }
2554 
2555  /* process manually set programs */
2556  for (i = 0; i < o->nb_program; i++) {
2557  const char *p = o->program[i].u.str;
2558  int progid = i+1;
2559  AVProgram *program;
2560 
2561  while(*p) {
2562  const char *p2 = av_get_token(&p, ":");
2563  const char *to_dealloc = p2;
2564  char *key;
2565  if (!p2)
2566  break;
2567 
2568  if(*p) p++;
2569 
2570  key = av_get_token(&p2, "=");
2571  if (!key || !*p2) {
2572  av_freep(&to_dealloc);
2573  av_freep(&key);
2574  break;
2575  }
2576  p2++;
2577 
2578  if (!strcmp(key, "program_num"))
2579  progid = strtol(p2, NULL, 0);
2580  av_freep(&to_dealloc);
2581  av_freep(&key);
2582  }
2583 
2584  program = av_new_program(oc, progid);
2585 
2586  p = o->program[i].u.str;
2587  while(*p) {
2588  const char *p2 = av_get_token(&p, ":");
2589  const char *to_dealloc = p2;
2590  char *key;
2591  if (!p2)
2592  break;
2593  if(*p) p++;
2594 
2595  key = av_get_token(&p2, "=");
2596  if (!key) {
2598  "No '=' character in program string %s.\n",
2599  p2);
2600  exit_program(1);
2601  }
2602  if (!*p2)
2603  exit_program(1);
2604  p2++;
2605 
2606  if (!strcmp(key, "title")) {
2607  av_dict_set(&program->metadata, "title", p2, 0);
2608  } else if (!strcmp(key, "program_num")) {
2609  } else if (!strcmp(key, "st")) {
2610  int st_num = strtol(p2, NULL, 0);
2611  av_program_add_stream_index(oc, progid, st_num);
2612  } else {
2613  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2614  exit_program(1);
2615  }
2616  av_freep(&to_dealloc);
2617  av_freep(&key);
2618  }
2619  }
2620 
2621  /* process manually set metadata */
2622  for (i = 0; i < o->nb_metadata; i++) {
2623  AVDictionary **m;
2624  char type, *val;
2625  const char *stream_spec;
2626  int index = 0, j, ret = 0;
2627 
2628  val = strchr(o->metadata[i].u.str, '=');
2629  if (!val) {
2630  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2631  o->metadata[i].u.str);
2632  exit_program(1);
2633  }
2634  *val++ = 0;
2635 
2636  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2637  if (type == 's') {
2638  for (j = 0; j < oc->nb_streams; j++) {
2639  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2640  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2641  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2642  char *tail;
2643  double theta = av_strtod(val, &tail);
2644  if (!*tail) {
2645  ost->rotate_overridden = 1;
2646  ost->rotate_override_value = theta;
2647  }
2648  } else {
2649  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2650  }
2651  } else if (ret < 0)
2652  exit_program(1);
2653  }
2654  }
2655  else {
2656  switch (type) {
2657  case 'g':
2658  m = &oc->metadata;
2659  break;
2660  case 'c':
2661  if (index < 0 || index >= oc->nb_chapters) {
2662  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2663  exit_program(1);
2664  }
2665  m = &oc->chapters[index]->metadata;
2666  break;
2667  case 'p':
2668  if (index < 0 || index >= oc->nb_programs) {
2669  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2670  exit_program(1);
2671  }
2672  m = &oc->programs[index]->metadata;
2673  break;
2674  default:
2675  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2676  exit_program(1);
2677  }
2678  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2679  }
2680  }
2681 
2682  return 0;
2683 }
2684 
2685 static int opt_target(void *optctx, const char *opt, const char *arg)
2686 {
2687  OptionsContext *o = optctx;
2688  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2689  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2690 
2691  if (!strncmp(arg, "pal-", 4)) {
2692  norm = PAL;
2693  arg += 4;
2694  } else if (!strncmp(arg, "ntsc-", 5)) {
2695  norm = NTSC;
2696  arg += 5;
2697  } else if (!strncmp(arg, "film-", 5)) {
2698  norm = FILM;
2699  arg += 5;
2700  } else {
2701  /* Try to determine PAL/NTSC by peeking in the input files */
2702  if (nb_input_files) {
2703  int i, j, fr;
2704  for (j = 0; j < nb_input_files; j++) {
2705  for (i = 0; i < input_files[j]->nb_streams; i++) {
2706  AVStream *st = input_files[j]->ctx->streams[i];
2708  continue;
2709  fr = st->time_base.den * 1000 / st->time_base.num;
2710  if (fr == 25000) {
2711  norm = PAL;
2712  break;
2713  } else if ((fr == 29970) || (fr == 23976)) {
2714  norm = NTSC;
2715  break;
2716  }
2717  }
2718  if (norm != UNKNOWN)
2719  break;
2720  }
2721  }
2722  if (norm != UNKNOWN)
2723  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2724  }
2725 
2726  if (norm == UNKNOWN) {
2727  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2728  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2729  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2730  exit_program(1);
2731  }
2732 
2733  if (!strcmp(arg, "vcd")) {
2734  opt_video_codec(o, "c:v", "mpeg1video");
2735  opt_audio_codec(o, "c:a", "mp2");
2736  parse_option(o, "f", "vcd", options);
2737 
2738  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2739  parse_option(o, "r", frame_rates[norm], options);
2740  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2741 
2742  opt_default(NULL, "b:v", "1150000");
2743  opt_default(NULL, "maxrate:v", "1150000");
2744  opt_default(NULL, "minrate:v", "1150000");
2745  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2746 
2747  opt_default(NULL, "b:a", "224000");
2748  parse_option(o, "ar", "44100", options);
2749  parse_option(o, "ac", "2", options);
2750 
2751  opt_default(NULL, "packetsize", "2324");
2752  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2753 
2754  /* We have to offset the PTS, so that it is consistent with the SCR.
2755  SCR starts at 36000, but the first two packs contain only padding
2756  and the first pack from the other stream, respectively, may also have
2757  been written before.
2758  So the real data starts at SCR 36000+3*1200. */
2759  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2760  } else if (!strcmp(arg, "svcd")) {
2761 
2762  opt_video_codec(o, "c:v", "mpeg2video");
2763  opt_audio_codec(o, "c:a", "mp2");
2764  parse_option(o, "f", "svcd", options);
2765 
2766  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2767  parse_option(o, "r", frame_rates[norm], options);
2768  parse_option(o, "pix_fmt", "yuv420p", options);
2769  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2770 
2771  opt_default(NULL, "b:v", "2040000");
2772  opt_default(NULL, "maxrate:v", "2516000");
2773  opt_default(NULL, "minrate:v", "0"); // 1145000;
2774  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2775  opt_default(NULL, "scan_offset", "1");
2776 
2777  opt_default(NULL, "b:a", "224000");
2778  parse_option(o, "ar", "44100", options);
2779 
2780  opt_default(NULL, "packetsize", "2324");
2781 
2782  } else if (!strcmp(arg, "dvd")) {
2783 
2784  opt_video_codec(o, "c:v", "mpeg2video");
2785  opt_audio_codec(o, "c:a", "ac3");
2786  parse_option(o, "f", "dvd", options);
2787 
2788  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2789  parse_option(o, "r", frame_rates[norm], options);
2790  parse_option(o, "pix_fmt", "yuv420p", options);
2791  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2792 
2793  opt_default(NULL, "b:v", "6000000");
2794  opt_default(NULL, "maxrate:v", "9000000");
2795  opt_default(NULL, "minrate:v", "0"); // 1500000;
2796  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2797 
2798  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2799  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2800 
2801  opt_default(NULL, "b:a", "448000");
2802  parse_option(o, "ar", "48000", options);
2803 
2804  } else if (!strncmp(arg, "dv", 2)) {
2805 
2806  parse_option(o, "f", "dv", options);
2807 
2808  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2809  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2810  norm == PAL ? "yuv420p" : "yuv411p", options);
2811  parse_option(o, "r", frame_rates[norm], options);
2812 
2813  parse_option(o, "ar", "48000", options);
2814  parse_option(o, "ac", "2", options);
2815 
2816  } else {
2817  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2818  return AVERROR(EINVAL);
2819  }
2820 
2823 
2824  return 0;
2825 }
2826 
2827 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2828 {
2830  vstats_filename = av_strdup (arg);
2831  return 0;
2832 }
2833 
2834 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2835 {
2836  char filename[40];
2837  time_t today2 = time(NULL);
2838  struct tm *today = localtime(&today2);
2839 
2840  if (!today) { // maybe tomorrow
2841  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2842  exit_program(1);
2843  }
2844 
2845  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2846  today->tm_sec);
2847  return opt_vstats_file(NULL, opt, filename);
2848 }
2849 
2850 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2851 {
2852  OptionsContext *o = optctx;
2853  return parse_option(o, "frames:v", arg, options);
2854 }
2855 
2856 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2857 {
2858  OptionsContext *o = optctx;
2859  return parse_option(o, "frames:a", arg, options);
2860 }
2861 
2862 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2863 {
2864  OptionsContext *o = optctx;
2865  return parse_option(o, "frames:d", arg, options);
2866 }
2867 
2868 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2869 {
2870  int ret;
2871  AVDictionary *cbak = codec_opts;
2872  AVDictionary *fbak = format_opts;
2873  codec_opts = NULL;
2874  format_opts = NULL;
2875 
2876  ret = opt_default(NULL, opt, arg);
2877 
2878  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2882  codec_opts = cbak;
2883  format_opts = fbak;
2884 
2885  return ret;
2886 }
2887 
2888 static int opt_preset(void *optctx, const char *opt, const char *arg)
2889 {
2890  OptionsContext *o = optctx;
2891  FILE *f=NULL;
2892  char filename[1000], line[1000], tmp_line[1000];
2893  const char *codec_name = NULL;
2894 
2895  tmp_line[0] = *opt;
2896  tmp_line[1] = 0;
2897  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2898 
2899  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2900  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2901  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2902  }else
2903  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2904  exit_program(1);
2905  }
2906 
2907  while (fgets(line, sizeof(line), f)) {
2908  char *key = tmp_line, *value, *endptr;
2909 
2910  if (strcspn(line, "#\n\r") == 0)
2911  continue;
2912  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2913  if (!av_strtok(key, "=", &value) ||
2914  !av_strtok(value, "\r\n", &endptr)) {
2915  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2916  exit_program(1);
2917  }
2918  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2919 
2920  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2921  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2922  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2923  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2924  else if (opt_default_new(o, key, value) < 0) {
2925  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2926  filename, line, key, value);
2927  exit_program(1);
2928  }
2929  }
2930 
2931  fclose(f);
2932 
2933  return 0;
2934 }
2935 
2936 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2937 {
2938  OptionsContext *o = optctx;
2939  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2940  int ret = parse_option(o, s, arg, options);
2941  av_free(s);
2942  return ret;
2943 }
2944 
2945 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2946 {
2947  OptionsContext *o = optctx;
2948 
2949  if(!strcmp(opt, "ab")){
2950  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2951  return 0;
2952  } else if(!strcmp(opt, "b")){
2953  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2954  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2955  return 0;
2956  }
2957  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2958  return 0;
2959 }
2960 
2961 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2962 {
2963  OptionsContext *o = optctx;
2964  char *s;
2965  int ret;
2966  if(!strcmp(opt, "qscale")){
2967  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2968  return parse_option(o, "q:v", arg, options);
2969  }
2970  s = av_asprintf("q%s", opt + 6);
2971  ret = parse_option(o, s, arg, options);
2972  av_free(s);
2973  return ret;
2974 }
2975 
2976 static int opt_profile(void *optctx, const char *opt, const char *arg)
2977 {
2978  OptionsContext *o = optctx;
2979  if(!strcmp(opt, "profile")){
2980  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2981  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2982  return 0;
2983  }
2984  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2985  return 0;
2986 }
2987 
2988 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2989 {
2990  OptionsContext *o = optctx;
2991  return parse_option(o, "filter:v", arg, options);
2992 }
2993 
2994 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2995 {
2996  OptionsContext *o = optctx;
2997  return parse_option(o, "filter:a", arg, options);
2998 }
2999 
3000 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3001 {
3002  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3003  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3004  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3005  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3006 
3009  return 0;
3010 }
3011 
3012 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3013 {
3014  OptionsContext *o = optctx;
3015  char *tcr = av_asprintf("timecode=%s", arg);
3016  int ret = parse_option(o, "metadata:g", tcr, options);
3017  if (ret >= 0)
3018  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3019  av_free(tcr);
3020  return 0;
3021 }
3022 
3023 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3024 {
3025  OptionsContext *o = optctx;
3026  char layout_str[32];
3027  char *stream_str;
3028  char *ac_str;
3029  int ret, channels, ac_str_size;
3030  uint64_t layout;
3031 
3032  layout = av_get_channel_layout(arg);
3033  if (!layout) {
3034  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3035  return AVERROR(EINVAL);
3036  }
3037  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3038  ret = opt_default_new(o, opt, layout_str);
3039  if (ret < 0)
3040  return ret;
3041 
3042  /* set 'ac' option based on channel layout */
3043  channels = av_get_channel_layout_nb_channels(layout);
3044  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3045  stream_str = strchr(opt, ':');
3046  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3047  ac_str = av_mallocz(ac_str_size);
3048  if (!ac_str)
3049  return AVERROR(ENOMEM);
3050  av_strlcpy(ac_str, "ac", 3);
3051  if (stream_str)
3052  av_strlcat(ac_str, stream_str, ac_str_size);
3053  ret = parse_option(o, ac_str, layout_str, options);
3054  av_free(ac_str);
3055 
3056  return ret;
3057 }
3058 
3059 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3060 {
3061  OptionsContext *o = optctx;
3062  return parse_option(o, "q:a", arg, options);
3063 }
3064 
3065 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3066 {
3068  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3069  return AVERROR(ENOMEM);
3072  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3073  return AVERROR(ENOMEM);
3074 
3076 
3077  return 0;
3078 }
3079 
3080 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3081 {
3082  uint8_t *graph_desc = read_file(arg);
3083  if (!graph_desc)
3084  return AVERROR(EINVAL);
3085 
3087  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3088  return AVERROR(ENOMEM);
3090  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3091 
3093 
3094  return 0;
3095 }
3096 
3097 void show_help_default(const char *opt, const char *arg)
3098 {
3099  /* per-file options have at least one of those set */
3100  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3101  int show_advanced = 0, show_avoptions = 0;
3102 
3103  if (opt && *opt) {
3104  if (!strcmp(opt, "long"))
3105  show_advanced = 1;
3106  else if (!strcmp(opt, "full"))
3107  show_advanced = show_avoptions = 1;
3108  else
3109  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3110  }
3111 
3112  show_usage();
3113 
3114  printf("Getting help:\n"
3115  " -h -- print basic options\n"
3116  " -h long -- print more options\n"
3117  " -h full -- print all options (including all format and codec specific options, very long)\n"
3118  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3119  " See man %s for detailed description of the options.\n"
3120  "\n", program_name);
3121 
3122  show_help_options(options, "Print help / information / capabilities:",
3123  OPT_EXIT, 0, 0);
3124 
3125  show_help_options(options, "Global options (affect whole program "
3126  "instead of just one file:",
3127  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3128  if (show_advanced)
3129  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3130  per_file | OPT_EXIT, 0);
3131 
3132  show_help_options(options, "Per-file main options:", 0,
3134  OPT_EXIT, per_file);
3135  if (show_advanced)
3136  show_help_options(options, "Advanced per-file options:",
3137  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3138 
3139  show_help_options(options, "Video options:",
3141  if (show_advanced)
3142  show_help_options(options, "Advanced Video options:",
3144 
3145  show_help_options(options, "Audio options:",
3147  if (show_advanced)
3148  show_help_options(options, "Advanced Audio options:",
3150  show_help_options(options, "Subtitle options:",
3151  OPT_SUBTITLE, 0, 0);
3152  printf("\n");
3153 
3154  if (show_avoptions) {
3158 #if CONFIG_SWSCALE
3160 #endif
3163  }
3164 }
3165 
3166 void show_usage(void)
3167 {
3168  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3169  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3170  av_log(NULL, AV_LOG_INFO, "\n");
3171 }
3172 
3173 enum OptGroup {
3176 };
3177 
3178 static const OptionGroupDef groups[] = {
3179  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3180  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3181 };
3182 
3183 static int open_files(OptionGroupList *l, const char *inout,
3184  int (*open_file)(OptionsContext*, const char*))
3185 {
3186  int i, ret;
3187 
3188  for (i = 0; i < l->nb_groups; i++) {
3189  OptionGroup *g = &l->groups[i];
3190  OptionsContext o;
3191 
3192  init_options(&o);
3193  o.g = g;
3194 
3195  ret = parse_optgroup(&o, g);
3196  if (ret < 0) {
3197  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3198  "%s.\n", inout, g->arg);
3199  return ret;
3200  }
3201 
3202  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3203  ret = open_file(&o, g->arg);
3204  uninit_options(&o);
3205  if (ret < 0) {
3206  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3207  inout, g->arg);
3208  return ret;
3209  }
3210  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3211  }
3212 
3213  return 0;
3214 }
3215 
3216 int ffmpeg_parse_options(int argc, char **argv)
3217 {
3218  OptionParseContext octx;
3219  uint8_t error[128];
3220  int ret;
3221 
3222  memset(&octx, 0, sizeof(octx));
3223 
3224  /* split the commandline into an internal representation */
3225  ret = split_commandline(&octx, argc, argv, options, groups,
3226  FF_ARRAY_ELEMS(groups));
3227  if (ret < 0) {
3228  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3229  goto fail;
3230  }
3231 
3232  /* apply global options */
3233  ret = parse_optgroup(NULL, &octx.global_opts);
3234  if (ret < 0) {
3235  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3236  goto fail;
3237  }
3238 
3239  /* configure terminal and setup signal handlers */
3240  term_init();
3241 
3242  /* open input files */
3243  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3244  if (ret < 0) {
3245  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3246  goto fail;
3247  }
3248 
3249  /* create the complex filtergraphs */
3250  ret = init_complex_filters();
3251  if (ret < 0) {
3252  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3253  goto fail;
3254  }
3255 
3256  /* open output files */
3257  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3258  if (ret < 0) {
3259  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3260  goto fail;
3261  }
3262 
3263 fail:
3264  uninit_parse_context(&octx);
3265  if (ret < 0) {
3266  av_strerror(ret, error, sizeof(error));
3267  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3268  }
3269  return ret;
3270 }
3271 
3272 static int opt_progress(void *optctx, const char *opt, const char *arg)
3273 {
3274  AVIOContext *avio = NULL;
3275  int ret;
3276 
3277  if (!strcmp(arg, "-"))
3278  arg = "pipe:";
3279  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3280  if (ret < 0) {
3281  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3282  arg, av_err2str(ret));
3283  return ret;
3284  }
3285  progress_avio = avio;
3286  return 0;
3287 }
3288 
3289 #define OFFSET(x) offsetof(OptionsContext, x)
3290 const OptionDef options[] = {
3291  /* main options */
3292 #include "cmdutils_common_opts.h"
3293  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3294  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3295  "force format", "fmt" },
3296  { "y", OPT_BOOL, { &file_overwrite },
3297  "overwrite output files" },
3298  { "n", OPT_BOOL, { &no_file_overwrite },
3299  "never overwrite output files" },
3300  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3301  "Ignore unknown stream types" },
3302  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3303  "Copy unknown stream types" },
3304  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3305  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3306  "codec name", "codec" },
3307  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3308  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3309  "codec name", "codec" },
3310  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3311  OPT_OUTPUT, { .off = OFFSET(presets) },
3312  "preset name", "preset" },
3313  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3314  OPT_OUTPUT, { .func_arg = opt_map },
3315  "set input stream mapping",
3316  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3317  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3318  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3319  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3320  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3321  "set metadata information of outfile from infile",
3322  "outfile[,metadata]:infile[,metadata]" },
3323  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3324  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3325  "set chapters mapping", "input_file_index" },
3326  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3327  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3328  "record or transcode \"duration\" seconds of audio/video",
3329  "duration" },
3330  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3331  "record or transcode stop time", "time_stop" },
3332  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3333  "set the limit file size in bytes", "limit_size" },
3334  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3335  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3336  "set the start time offset", "time_off" },
3337  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3338  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3339  "set the start time offset relative to EOF", "time_off" },
3340  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3341  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3342  "enable/disable seeking by timestamp with -ss" },
3343  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3344  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3345  "enable/disable accurate seeking with -ss" },
3346  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3347  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3348  "set the input ts offset", "time_off" },
3349  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3350  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3351  "set the input ts scale", "scale" },
3352  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3353  "set the recording timestamp ('now' to set the current time)", "time" },
3354  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3355  "add metadata", "string=string" },
3356  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3357  "add program with specified streams", "title=string:st=number..." },
3358  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3359  OPT_OUTPUT, { .func_arg = opt_data_frames },
3360  "set the number of data frames to output", "number" },
3361  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3362  "add timings for benchmarking" },
3363  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3364  "add timings for each task" },
3365  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3366  "write program-readable progress information", "url" },
3367  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3368  "enable or disable interaction on standard input" },
3369  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3370  "set max runtime in seconds", "limit" },
3371  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3372  "dump each input packet" },
3373  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3374  "when dumping packets, also dump the payload" },
3375  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3376  OPT_INPUT, { .off = OFFSET(rate_emu) },
3377  "read input at native frame rate", "" },
3378  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3379  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3380  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3381  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3382  "video sync method", "" },
3383  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3384  "frame drop threshold", "" },
3385  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3386  "audio sync method", "" },
3387  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3388  "audio drift threshold", "threshold" },
3389  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3390  "copy timestamps" },
3391  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3392  "shift input timestamps to start at 0 when using copyts" },
3393  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3394  "copy input stream time base when stream copying", "mode" },
3395  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3396  OPT_OUTPUT, { .off = OFFSET(shortest) },
3397  "finish encoding within shortest input" },
3398  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3399  OPT_OUTPUT, { .off = OFFSET(apad) },
3400  "audio pad", "" },
3401  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3402  "timestamp discontinuity delta threshold", "threshold" },
3403  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3404  "timestamp error delta threshold", "threshold" },
3405  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3406  "exit on error", "error" },
3407  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3408  "abort on the specified condition flags", "flags" },
3409  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3410  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3411  "copy initial non-keyframes" },
3412  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3413  "copy or discard frames before start time" },
3414  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3415  "set the number of frames to output", "number" },
3416  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3417  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3418  "force codec tag/fourcc", "fourcc/tag" },
3419  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3420  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3421  "use fixed quality scale (VBR)", "q" },
3422  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3423  OPT_OUTPUT, { .func_arg = opt_qscale },
3424  "use fixed quality scale (VBR)", "q" },
3425  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3426  "set profile", "profile" },
3427  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3428  "set stream filtergraph", "filter_graph" },
3429  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3430  "number of non-complex filter threads" },
3431  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3432  "read stream filtergraph description from a file", "filename" },
3433  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3434  "reinit filtergraph on input parameter changes", "" },
3435  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3436  "create a complex filtergraph", "graph_description" },
3437  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3438  "number of threads for -filter_complex" },
3439  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3440  "create a complex filtergraph", "graph_description" },
3441  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3442  "read complex filtergraph description from a file", "filename" },
3443  { "stats", OPT_BOOL, { &print_stats },
3444  "print progress report during encoding", },
3445  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3446  OPT_OUTPUT, { .func_arg = opt_attach },
3447  "add an attachment to the output file", "filename" },
3448  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3449  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3450  "extract an attachment into a file", "filename" },
3451  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3452  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3453  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3454  "print timestamp debugging info" },
3455  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3456  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3457  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3458  OPT_INPUT, { .off = OFFSET(discard) },
3459  "discard", "" },
3460  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3461  OPT_OUTPUT, { .off = OFFSET(disposition) },
3462  "disposition", "" },
3463  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3464  { .off = OFFSET(thread_queue_size) },
3465  "set the maximum number of queued packets from the demuxer" },
3466 
3467  /* video options */
3468  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3469  "set the number of video frames to output", "number" },
3470  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3471  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3472  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3474  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3475  "set frame size (WxH or abbreviation)", "size" },
3476  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3477  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3478  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3479  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3480  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3481  "set pixel format", "format" },
3482  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3483  "set the number of bits per raw sample", "number" },
3484  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3485  "deprecated use -g 1" },
3487  "disable video" },
3488  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3489  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3490  "rate control override for specific intervals", "override" },
3491  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3492  OPT_OUTPUT, { .func_arg = opt_video_codec },
3493  "force video codec ('copy' to copy stream)", "codec" },
3494  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3495  "Removed" },
3496  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3497  "Removed" },
3498  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3499  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3500  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3501  "select the pass number (1 to 3)", "n" },
3502  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3503  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3504  "select two pass log file name prefix", "prefix" },
3505  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3506  "this option is deprecated, use the yadif filter instead" },
3507  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3508  "calculate PSNR of compressed frames" },
3509  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3510  "dump video coding statistics to file" },
3511  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3512  "dump video coding statistics to file", "file" },
3513  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3514  "Version of the vstats format to use."},
3515  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3516  "set video filters", "filter_graph" },
3517  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3518  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3519  "specify intra matrix coeffs", "matrix" },
3520  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3521  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3522  "specify inter matrix coeffs", "matrix" },
3523  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3524  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3525  "specify intra matrix coeffs", "matrix" },
3526  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3527  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3528  "top=1/bottom=0/auto=-1 field first", "" },
3529  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3530  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3531  "force video tag/fourcc", "fourcc/tag" },
3532  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3533  "show QP histogram" },
3534  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3535  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3536  "force the selected framerate, disable the best supported framerate selection" },
3537  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3538  OPT_OUTPUT, { .func_arg = opt_streamid },
3539  "set the value of an outfile streamid", "streamIndex:value" },
3540  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3541  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3542  "force key frames at specified timestamps", "timestamps" },
3543  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3544  "audio bitrate (please use -b:a)", "bitrate" },
3545  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3546  "video bitrate (please use -b:v)", "bitrate" },
3547  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3548  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3549  "use HW accelerated decoding", "hwaccel name" },
3550  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3551  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3552  "select a device for HW acceleration", "devicename" },
3553  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3554  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3555  "select output format used with HW accelerated decoding", "format" },
3556 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3557  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3558 #endif
3559  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3560  "show available HW acceleration methods" },
3561  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3562  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3563  "automatically insert correct rotate filters" },
3564  { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3565  "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3566 
3567  /* audio options */
3568  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3569  "set the number of audio frames to output", "number" },
3570  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3571  "set audio quality (codec-specific)", "quality", },
3572  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3573  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3574  "set audio sampling rate (in Hz)", "rate" },
3575  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3576  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3577  "set number of audio channels", "channels" },
3579  "disable audio" },
3580  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3581  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3582  "force audio codec ('copy' to copy stream)", "codec" },
3583  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3584  OPT_OUTPUT, { .func_arg = opt_old2new },
3585  "force audio tag/fourcc", "fourcc/tag" },
3586  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3587  "change audio volume (256=normal)" , "volume" },
3588  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3590  "set sample format", "format" },
3591  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3592  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3593  "set channel layout", "layout" },
3594  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3595  "set audio filters", "filter_graph" },
3596  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3597  "set the maximum number of channels to try to guess the channel layout" },
3598 
3599  /* subtitle options */
3601  "disable subtitle" },
3602  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3603  "force subtitle codec ('copy' to copy stream)", "codec" },
3604  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3605  , "force subtitle tag/fourcc", "fourcc/tag" },
3606  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3607  "fix subtitles duration" },
3608  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3609  "set canvas size (WxH or abbreviation)", "size" },
3610 
3611  /* grab options */
3612  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3613  "deprecated, use -channel", "channel" },
3614  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3615  "deprecated, use -standard", "standard" },
3616  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3617 
3618  /* muxer options */
3619  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3620  "set the maximum demux-decode delay", "seconds" },
3621  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3622  "set the initial demux-decode delay", "seconds" },
3623  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3624  "override the options from ffserver", "" },
3625  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3626  "specify a file in which to print sdp information", "file" },
3627 
3628  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3629  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3630 
3631  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3632  "A comma-separated list of bitstream filters", "bitstream_filters" },
3633  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3634  "deprecated", "audio bitstream_filters" },
3635  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3636  "deprecated", "video bitstream_filters" },
3637 
3638  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3639  "set the audio options to the indicated preset", "preset" },
3640  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3641  "set the video options to the indicated preset", "preset" },
3642  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3643  "set the subtitle options to the indicated preset", "preset" },
3644  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3645  "set options from indicated preset file", "filename" },
3646 
3647  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3648  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3649 
3650  /* data codec support */
3651  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3652  "force data codec ('copy' to copy stream)", "codec" },
3653  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3654  "disable data" },
3655 
3656 #if CONFIG_VAAPI
3657  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3658  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3659 #endif
3660 
3661 #if CONFIG_QSV
3662  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3663  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3664 #endif
3665 
3666  { NULL, },
3667 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1556
int nb_bitstream_filters
Definition: ffmpeg.h:457
#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
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:2100
void show_usage(void)
Definition: ffmpeg_opt.c:3166
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:266
AVRational framerate
Definition: avcodec.h:3429
const char const char void * val
Definition: avisynth_c.h:771
int audio_sync_method
Definition: ffmpeg_opt.c:103
AVDictionary * resample_opts
Definition: cmdutils.h:284
int keep_pix_fmt
Definition: ffmpeg.h:523
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:5906
#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:556
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:288
int copy_tb
Definition: ffmpeg_opt.c:113
char * qsv_device
Definition: ffmpeg_qsv.c:31
AVDictionary * swr_opts
Definition: ffmpeg.h:504
int qp_hist
Definition: ffmpeg_opt.c:118
AVDictionary * swr_opts
Definition: cmdutils.h:286
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:509
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:2862
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:473
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:1962
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:499
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:1934
float mux_max_delay
Definition: ffmpeg.h:153
int accurate_seek
Definition: ffmpeg.h:409
int * streamid_map
Definition: ffmpeg.h:162
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int video_sync_method
Definition: ffmpeg_opt.c:104
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:138
uint8_t * bsf_extradata_updated
Definition: ffmpeg.h:458
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:329
void choose_sample_fmt(AVStream *st, AVCodec *codec)
Definition: ffmpeg_filter.c:92
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:187
enum AVCodecID video_codec
default video codec
Definition: avformat.h:535
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1994
#define OPT_AUDIO
Definition: cmdutils.h:171
int64_t max_pts
Definition: ffmpeg.h:318
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:262
int decoding_needed
Definition: ffmpeg.h:296
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4074
int qscale
Definition: avcodec.h:847
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:477
int index
stream index in AVFormatContext
Definition: avformat.h:890
int max_muxing_queue_size
Definition: ffmpeg.h:540
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:2994
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1797
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:1911
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:2143
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:762
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1960
Convenience header that includes libavutil's core.
const char * arg
Definition: cmdutils.h:277
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3065
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:2909
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1868
enum AVMediaType type
Definition: avcodec.h:3694
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:825
int64_t input_ts_offset
Definition: ffmpeg.h:398
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:3133
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:5859
#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:3681
#define VSYNC_VFR
Definition: ffmpeg.h:54
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1295
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:4066
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:557
void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c)
int index
Definition: ffmpeg.h:279
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2888
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:459
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:443
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3059
Format I/O context.
Definition: avformat.h:1349
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:280
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:494
#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:295
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:519
int filter_nbthreads
Definition: ffmpeg_opt.c:122
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2502
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:503
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:4140
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:3178
FILE * logfile
Definition: ffmpeg.h:495
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:448
AVDictionary * opts
Definition: ffmpeg.h:554
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:3527
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:3000
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:4357
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:560
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:2834
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:405
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:4456
AVDictionary * resample_opts
Definition: ffmpeg.h:505
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:1446
int * formats
Definition: ffmpeg.h:273
#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:301
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:209
const OptionDef options[]
Definition: ffmpeg_opt.c:3290
int top_field_first
Definition: ffmpeg.h:330
#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:292
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:315
#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:848
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2961
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:1818
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:270
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:123
enum AVCodecID id
Definition: avcodec.h:3695
int rate_emu
Definition: ffmpeg.h:408
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:2976
#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
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:370
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:3183
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:394
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:453
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:4169
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:4070
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1827
const char * name
Definition: cmdutils.h:164
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2945
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:3688
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2936
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:475
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:3085
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4092
#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:497
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:4820
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:3216
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:714
AVRational frame_aspect_ratio
Definition: ffmpeg.h:480
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:296
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:164
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2988
int nb_output_files
Definition: ffmpeg.c:152
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2716
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
char filename[1024]
input or output filename
Definition: avformat.h:1425
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:871
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
#define FFMIN(a, b)
Definition: common.h:96
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1519
SpecifierOpt * audio_channels
Definition: ffmpeg.h:105
uint64_t * channel_layouts
Definition: ffmpeg.h:274
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
Definition: ffmpeg_opt.c:649
#define VSYNC_AUTO
Definition: ffmpeg.h:51
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1580