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; i < FF_ARRAY_ELEMS(hwaccels) - 1; 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  if (ist->autorotate)
2553  av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2554  }
2555  }
2556 
2557  /* process manually set programs */
2558  for (i = 0; i < o->nb_program; i++) {
2559  const char *p = o->program[i].u.str;
2560  int progid = i+1;
2561  AVProgram *program;
2562 
2563  while(*p) {
2564  const char *p2 = av_get_token(&p, ":");
2565  const char *to_dealloc = p2;
2566  char *key;
2567  if (!p2)
2568  break;
2569 
2570  if(*p) p++;
2571 
2572  key = av_get_token(&p2, "=");
2573  if (!key || !*p2) {
2574  av_freep(&to_dealloc);
2575  av_freep(&key);
2576  break;
2577  }
2578  p2++;
2579 
2580  if (!strcmp(key, "program_num"))
2581  progid = strtol(p2, NULL, 0);
2582  av_freep(&to_dealloc);
2583  av_freep(&key);
2584  }
2585 
2586  program = av_new_program(oc, progid);
2587 
2588  p = o->program[i].u.str;
2589  while(*p) {
2590  const char *p2 = av_get_token(&p, ":");
2591  const char *to_dealloc = p2;
2592  char *key;
2593  if (!p2)
2594  break;
2595  if(*p) p++;
2596 
2597  key = av_get_token(&p2, "=");
2598  if (!key) {
2600  "No '=' character in program string %s.\n",
2601  p2);
2602  exit_program(1);
2603  }
2604  if (!*p2)
2605  exit_program(1);
2606  p2++;
2607 
2608  if (!strcmp(key, "title")) {
2609  av_dict_set(&program->metadata, "title", p2, 0);
2610  } else if (!strcmp(key, "program_num")) {
2611  } else if (!strcmp(key, "st")) {
2612  int st_num = strtol(p2, NULL, 0);
2613  av_program_add_stream_index(oc, progid, st_num);
2614  } else {
2615  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2616  exit_program(1);
2617  }
2618  av_freep(&to_dealloc);
2619  av_freep(&key);
2620  }
2621  }
2622 
2623  /* process manually set metadata */
2624  for (i = 0; i < o->nb_metadata; i++) {
2625  AVDictionary **m;
2626  char type, *val;
2627  const char *stream_spec;
2628  int index = 0, j, ret = 0;
2629 
2630  val = strchr(o->metadata[i].u.str, '=');
2631  if (!val) {
2632  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2633  o->metadata[i].u.str);
2634  exit_program(1);
2635  }
2636  *val++ = 0;
2637 
2638  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2639  if (type == 's') {
2640  for (j = 0; j < oc->nb_streams; j++) {
2641  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2642  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2643  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2644  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2645  ost->rotate_overridden = 1;
2646  }
2647  } else if (ret < 0)
2648  exit_program(1);
2649  }
2650  }
2651  else {
2652  switch (type) {
2653  case 'g':
2654  m = &oc->metadata;
2655  break;
2656  case 'c':
2657  if (index < 0 || index >= oc->nb_chapters) {
2658  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2659  exit_program(1);
2660  }
2661  m = &oc->chapters[index]->metadata;
2662  break;
2663  case 'p':
2664  if (index < 0 || index >= oc->nb_programs) {
2665  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2666  exit_program(1);
2667  }
2668  m = &oc->programs[index]->metadata;
2669  break;
2670  default:
2671  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2672  exit_program(1);
2673  }
2674  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2675  }
2676  }
2677 
2678  return 0;
2679 }
2680 
2681 static int opt_target(void *optctx, const char *opt, const char *arg)
2682 {
2683  OptionsContext *o = optctx;
2684  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2685  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2686 
2687  if (!strncmp(arg, "pal-", 4)) {
2688  norm = PAL;
2689  arg += 4;
2690  } else if (!strncmp(arg, "ntsc-", 5)) {
2691  norm = NTSC;
2692  arg += 5;
2693  } else if (!strncmp(arg, "film-", 5)) {
2694  norm = FILM;
2695  arg += 5;
2696  } else {
2697  /* Try to determine PAL/NTSC by peeking in the input files */
2698  if (nb_input_files) {
2699  int i, j, fr;
2700  for (j = 0; j < nb_input_files; j++) {
2701  for (i = 0; i < input_files[j]->nb_streams; i++) {
2702  AVStream *st = input_files[j]->ctx->streams[i];
2704  continue;
2705  fr = st->time_base.den * 1000 / st->time_base.num;
2706  if (fr == 25000) {
2707  norm = PAL;
2708  break;
2709  } else if ((fr == 29970) || (fr == 23976)) {
2710  norm = NTSC;
2711  break;
2712  }
2713  }
2714  if (norm != UNKNOWN)
2715  break;
2716  }
2717  }
2718  if (norm != UNKNOWN)
2719  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2720  }
2721 
2722  if (norm == UNKNOWN) {
2723  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2724  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2725  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2726  exit_program(1);
2727  }
2728 
2729  if (!strcmp(arg, "vcd")) {
2730  opt_video_codec(o, "c:v", "mpeg1video");
2731  opt_audio_codec(o, "c:a", "mp2");
2732  parse_option(o, "f", "vcd", options);
2733 
2734  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2735  parse_option(o, "r", frame_rates[norm], options);
2736  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2737 
2738  opt_default(NULL, "b:v", "1150000");
2739  opt_default(NULL, "maxrate:v", "1150000");
2740  opt_default(NULL, "minrate:v", "1150000");
2741  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2742 
2743  opt_default(NULL, "b:a", "224000");
2744  parse_option(o, "ar", "44100", options);
2745  parse_option(o, "ac", "2", options);
2746 
2747  opt_default(NULL, "packetsize", "2324");
2748  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2749 
2750  /* We have to offset the PTS, so that it is consistent with the SCR.
2751  SCR starts at 36000, but the first two packs contain only padding
2752  and the first pack from the other stream, respectively, may also have
2753  been written before.
2754  So the real data starts at SCR 36000+3*1200. */
2755  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2756  } else if (!strcmp(arg, "svcd")) {
2757 
2758  opt_video_codec(o, "c:v", "mpeg2video");
2759  opt_audio_codec(o, "c:a", "mp2");
2760  parse_option(o, "f", "svcd", options);
2761 
2762  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2763  parse_option(o, "r", frame_rates[norm], options);
2764  parse_option(o, "pix_fmt", "yuv420p", options);
2765  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2766 
2767  opt_default(NULL, "b:v", "2040000");
2768  opt_default(NULL, "maxrate:v", "2516000");
2769  opt_default(NULL, "minrate:v", "0"); // 1145000;
2770  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2771  opt_default(NULL, "scan_offset", "1");
2772 
2773  opt_default(NULL, "b:a", "224000");
2774  parse_option(o, "ar", "44100", options);
2775 
2776  opt_default(NULL, "packetsize", "2324");
2777 
2778  } else if (!strcmp(arg, "dvd")) {
2779 
2780  opt_video_codec(o, "c:v", "mpeg2video");
2781  opt_audio_codec(o, "c:a", "ac3");
2782  parse_option(o, "f", "dvd", options);
2783 
2784  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2785  parse_option(o, "r", frame_rates[norm], options);
2786  parse_option(o, "pix_fmt", "yuv420p", options);
2787  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2788 
2789  opt_default(NULL, "b:v", "6000000");
2790  opt_default(NULL, "maxrate:v", "9000000");
2791  opt_default(NULL, "minrate:v", "0"); // 1500000;
2792  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2793 
2794  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2795  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2796 
2797  opt_default(NULL, "b:a", "448000");
2798  parse_option(o, "ar", "48000", options);
2799 
2800  } else if (!strncmp(arg, "dv", 2)) {
2801 
2802  parse_option(o, "f", "dv", options);
2803 
2804  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2805  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2806  norm == PAL ? "yuv420p" : "yuv411p", options);
2807  parse_option(o, "r", frame_rates[norm], options);
2808 
2809  parse_option(o, "ar", "48000", options);
2810  parse_option(o, "ac", "2", options);
2811 
2812  } else {
2813  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2814  return AVERROR(EINVAL);
2815  }
2816 
2819 
2820  return 0;
2821 }
2822 
2823 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2824 {
2826  vstats_filename = av_strdup (arg);
2827  return 0;
2828 }
2829 
2830 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2831 {
2832  char filename[40];
2833  time_t today2 = time(NULL);
2834  struct tm *today = localtime(&today2);
2835 
2836  if (!today) { // maybe tomorrow
2837  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2838  exit_program(1);
2839  }
2840 
2841  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2842  today->tm_sec);
2843  return opt_vstats_file(NULL, opt, filename);
2844 }
2845 
2846 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2847 {
2848  OptionsContext *o = optctx;
2849  return parse_option(o, "frames:v", arg, options);
2850 }
2851 
2852 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2853 {
2854  OptionsContext *o = optctx;
2855  return parse_option(o, "frames:a", arg, options);
2856 }
2857 
2858 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2859 {
2860  OptionsContext *o = optctx;
2861  return parse_option(o, "frames:d", arg, options);
2862 }
2863 
2864 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2865 {
2866  int ret;
2867  AVDictionary *cbak = codec_opts;
2868  AVDictionary *fbak = format_opts;
2869  codec_opts = NULL;
2870  format_opts = NULL;
2871 
2872  ret = opt_default(NULL, opt, arg);
2873 
2874  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2878  codec_opts = cbak;
2879  format_opts = fbak;
2880 
2881  return ret;
2882 }
2883 
2884 static int opt_preset(void *optctx, const char *opt, const char *arg)
2885 {
2886  OptionsContext *o = optctx;
2887  FILE *f=NULL;
2888  char filename[1000], line[1000], tmp_line[1000];
2889  const char *codec_name = NULL;
2890 
2891  tmp_line[0] = *opt;
2892  tmp_line[1] = 0;
2893  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2894 
2895  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2896  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2897  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2898  }else
2899  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2900  exit_program(1);
2901  }
2902 
2903  while (fgets(line, sizeof(line), f)) {
2904  char *key = tmp_line, *value, *endptr;
2905 
2906  if (strcspn(line, "#\n\r") == 0)
2907  continue;
2908  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2909  if (!av_strtok(key, "=", &value) ||
2910  !av_strtok(value, "\r\n", &endptr)) {
2911  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2912  exit_program(1);
2913  }
2914  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2915 
2916  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2917  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2918  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2919  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2920  else if (opt_default_new(o, key, value) < 0) {
2921  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2922  filename, line, key, value);
2923  exit_program(1);
2924  }
2925  }
2926 
2927  fclose(f);
2928 
2929  return 0;
2930 }
2931 
2932 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2933 {
2934  OptionsContext *o = optctx;
2935  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2936  int ret = parse_option(o, s, arg, options);
2937  av_free(s);
2938  return ret;
2939 }
2940 
2941 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2942 {
2943  OptionsContext *o = optctx;
2944 
2945  if(!strcmp(opt, "ab")){
2946  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2947  return 0;
2948  } else if(!strcmp(opt, "b")){
2949  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2950  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2951  return 0;
2952  }
2953  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2954  return 0;
2955 }
2956 
2957 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2958 {
2959  OptionsContext *o = optctx;
2960  char *s;
2961  int ret;
2962  if(!strcmp(opt, "qscale")){
2963  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2964  return parse_option(o, "q:v", arg, options);
2965  }
2966  s = av_asprintf("q%s", opt + 6);
2967  ret = parse_option(o, s, arg, options);
2968  av_free(s);
2969  return ret;
2970 }
2971 
2972 static int opt_profile(void *optctx, const char *opt, const char *arg)
2973 {
2974  OptionsContext *o = optctx;
2975  if(!strcmp(opt, "profile")){
2976  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2977  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2978  return 0;
2979  }
2980  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2981  return 0;
2982 }
2983 
2984 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2985 {
2986  OptionsContext *o = optctx;
2987  return parse_option(o, "filter:v", arg, options);
2988 }
2989 
2990 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2991 {
2992  OptionsContext *o = optctx;
2993  return parse_option(o, "filter:a", arg, options);
2994 }
2995 
2996 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2997 {
2998  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2999  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3000  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3001  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3002 
3005  return 0;
3006 }
3007 
3008 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3009 {
3010  OptionsContext *o = optctx;
3011  char *tcr = av_asprintf("timecode=%s", arg);
3012  int ret = parse_option(o, "metadata:g", tcr, options);
3013  if (ret >= 0)
3014  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3015  av_free(tcr);
3016  return 0;
3017 }
3018 
3019 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3020 {
3021  OptionsContext *o = optctx;
3022  char layout_str[32];
3023  char *stream_str;
3024  char *ac_str;
3025  int ret, channels, ac_str_size;
3026  uint64_t layout;
3027 
3028  layout = av_get_channel_layout(arg);
3029  if (!layout) {
3030  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3031  return AVERROR(EINVAL);
3032  }
3033  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3034  ret = opt_default_new(o, opt, layout_str);
3035  if (ret < 0)
3036  return ret;
3037 
3038  /* set 'ac' option based on channel layout */
3039  channels = av_get_channel_layout_nb_channels(layout);
3040  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3041  stream_str = strchr(opt, ':');
3042  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3043  ac_str = av_mallocz(ac_str_size);
3044  if (!ac_str)
3045  return AVERROR(ENOMEM);
3046  av_strlcpy(ac_str, "ac", 3);
3047  if (stream_str)
3048  av_strlcat(ac_str, stream_str, ac_str_size);
3049  ret = parse_option(o, ac_str, layout_str, options);
3050  av_free(ac_str);
3051 
3052  return ret;
3053 }
3054 
3055 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3056 {
3057  OptionsContext *o = optctx;
3058  return parse_option(o, "q:a", arg, options);
3059 }
3060 
3061 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3062 {
3064  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3065  return AVERROR(ENOMEM);
3068  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3069  return AVERROR(ENOMEM);
3070 
3072 
3073  return 0;
3074 }
3075 
3076 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3077 {
3078  uint8_t *graph_desc = read_file(arg);
3079  if (!graph_desc)
3080  return AVERROR(EINVAL);
3081 
3083  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3084  return AVERROR(ENOMEM);
3086  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3087 
3089 
3090  return 0;
3091 }
3092 
3093 void show_help_default(const char *opt, const char *arg)
3094 {
3095  /* per-file options have at least one of those set */
3096  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3097  int show_advanced = 0, show_avoptions = 0;
3098 
3099  if (opt && *opt) {
3100  if (!strcmp(opt, "long"))
3101  show_advanced = 1;
3102  else if (!strcmp(opt, "full"))
3103  show_advanced = show_avoptions = 1;
3104  else
3105  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3106  }
3107 
3108  show_usage();
3109 
3110  printf("Getting help:\n"
3111  " -h -- print basic options\n"
3112  " -h long -- print more options\n"
3113  " -h full -- print all options (including all format and codec specific options, very long)\n"
3114  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3115  " See man %s for detailed description of the options.\n"
3116  "\n", program_name);
3117 
3118  show_help_options(options, "Print help / information / capabilities:",
3119  OPT_EXIT, 0, 0);
3120 
3121  show_help_options(options, "Global options (affect whole program "
3122  "instead of just one file:",
3123  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3124  if (show_advanced)
3125  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3126  per_file | OPT_EXIT, 0);
3127 
3128  show_help_options(options, "Per-file main options:", 0,
3130  OPT_EXIT, per_file);
3131  if (show_advanced)
3132  show_help_options(options, "Advanced per-file options:",
3133  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3134 
3135  show_help_options(options, "Video options:",
3137  if (show_advanced)
3138  show_help_options(options, "Advanced Video options:",
3140 
3141  show_help_options(options, "Audio options:",
3143  if (show_advanced)
3144  show_help_options(options, "Advanced Audio options:",
3146  show_help_options(options, "Subtitle options:",
3147  OPT_SUBTITLE, 0, 0);
3148  printf("\n");
3149 
3150  if (show_avoptions) {
3154 #if CONFIG_SWSCALE
3156 #endif
3159  }
3160 }
3161 
3162 void show_usage(void)
3163 {
3164  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3165  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3166  av_log(NULL, AV_LOG_INFO, "\n");
3167 }
3168 
3169 enum OptGroup {
3172 };
3173 
3174 static const OptionGroupDef groups[] = {
3175  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3176  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3177 };
3178 
3179 static int open_files(OptionGroupList *l, const char *inout,
3180  int (*open_file)(OptionsContext*, const char*))
3181 {
3182  int i, ret;
3183 
3184  for (i = 0; i < l->nb_groups; i++) {
3185  OptionGroup *g = &l->groups[i];
3186  OptionsContext o;
3187 
3188  init_options(&o);
3189  o.g = g;
3190 
3191  ret = parse_optgroup(&o, g);
3192  if (ret < 0) {
3193  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3194  "%s.\n", inout, g->arg);
3195  return ret;
3196  }
3197 
3198  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3199  ret = open_file(&o, g->arg);
3200  uninit_options(&o);
3201  if (ret < 0) {
3202  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3203  inout, g->arg);
3204  return ret;
3205  }
3206  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3207  }
3208 
3209  return 0;
3210 }
3211 
3212 int ffmpeg_parse_options(int argc, char **argv)
3213 {
3214  OptionParseContext octx;
3215  uint8_t error[128];
3216  int ret;
3217 
3218  memset(&octx, 0, sizeof(octx));
3219 
3220  /* split the commandline into an internal representation */
3221  ret = split_commandline(&octx, argc, argv, options, groups,
3222  FF_ARRAY_ELEMS(groups));
3223  if (ret < 0) {
3224  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3225  goto fail;
3226  }
3227 
3228  /* apply global options */
3229  ret = parse_optgroup(NULL, &octx.global_opts);
3230  if (ret < 0) {
3231  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3232  goto fail;
3233  }
3234 
3235  /* configure terminal and setup signal handlers */
3236  term_init();
3237 
3238  /* open input files */
3239  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3240  if (ret < 0) {
3241  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3242  goto fail;
3243  }
3244 
3245  /* create the complex filtergraphs */
3246  ret = init_complex_filters();
3247  if (ret < 0) {
3248  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3249  goto fail;
3250  }
3251 
3252  /* open output files */
3253  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3254  if (ret < 0) {
3255  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3256  goto fail;
3257  }
3258 
3259 fail:
3260  uninit_parse_context(&octx);
3261  if (ret < 0) {
3262  av_strerror(ret, error, sizeof(error));
3263  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3264  }
3265  return ret;
3266 }
3267 
3268 static int opt_progress(void *optctx, const char *opt, const char *arg)
3269 {
3270  AVIOContext *avio = NULL;
3271  int ret;
3272 
3273  if (!strcmp(arg, "-"))
3274  arg = "pipe:";
3275  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3276  if (ret < 0) {
3277  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3278  arg, av_err2str(ret));
3279  return ret;
3280  }
3281  progress_avio = avio;
3282  return 0;
3283 }
3284 
3285 #define OFFSET(x) offsetof(OptionsContext, x)
3286 const OptionDef options[] = {
3287  /* main options */
3288 #include "cmdutils_common_opts.h"
3289  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3290  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3291  "force format", "fmt" },
3292  { "y", OPT_BOOL, { &file_overwrite },
3293  "overwrite output files" },
3294  { "n", OPT_BOOL, { &no_file_overwrite },
3295  "never overwrite output files" },
3296  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3297  "Ignore unknown stream types" },
3298  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3299  "Copy unknown stream types" },
3300  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3301  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3302  "codec name", "codec" },
3303  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3304  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3305  "codec name", "codec" },
3306  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3307  OPT_OUTPUT, { .off = OFFSET(presets) },
3308  "preset name", "preset" },
3309  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3310  OPT_OUTPUT, { .func_arg = opt_map },
3311  "set input stream mapping",
3312  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3313  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3314  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3315  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3316  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3317  "set metadata information of outfile from infile",
3318  "outfile[,metadata]:infile[,metadata]" },
3319  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3320  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3321  "set chapters mapping", "input_file_index" },
3322  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3323  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3324  "record or transcode \"duration\" seconds of audio/video",
3325  "duration" },
3326  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3327  "record or transcode stop time", "time_stop" },
3328  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3329  "set the limit file size in bytes", "limit_size" },
3330  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3331  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3332  "set the start time offset", "time_off" },
3333  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3334  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3335  "set the start time offset relative to EOF", "time_off" },
3336  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3337  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3338  "enable/disable seeking by timestamp with -ss" },
3339  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3340  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3341  "enable/disable accurate seeking with -ss" },
3342  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3343  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3344  "set the input ts offset", "time_off" },
3345  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3346  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3347  "set the input ts scale", "scale" },
3348  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3349  "set the recording timestamp ('now' to set the current time)", "time" },
3350  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3351  "add metadata", "string=string" },
3352  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3353  "add program with specified streams", "title=string:st=number..." },
3354  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3355  OPT_OUTPUT, { .func_arg = opt_data_frames },
3356  "set the number of data frames to output", "number" },
3357  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3358  "add timings for benchmarking" },
3359  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3360  "add timings for each task" },
3361  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3362  "write program-readable progress information", "url" },
3363  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3364  "enable or disable interaction on standard input" },
3365  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3366  "set max runtime in seconds", "limit" },
3367  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3368  "dump each input packet" },
3369  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3370  "when dumping packets, also dump the payload" },
3371  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3372  OPT_INPUT, { .off = OFFSET(rate_emu) },
3373  "read input at native frame rate", "" },
3374  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3375  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3376  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3377  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3378  "video sync method", "" },
3379  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3380  "frame drop threshold", "" },
3381  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3382  "audio sync method", "" },
3383  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3384  "audio drift threshold", "threshold" },
3385  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3386  "copy timestamps" },
3387  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3388  "shift input timestamps to start at 0 when using copyts" },
3389  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3390  "copy input stream time base when stream copying", "mode" },
3391  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3392  OPT_OUTPUT, { .off = OFFSET(shortest) },
3393  "finish encoding within shortest input" },
3394  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3395  OPT_OUTPUT, { .off = OFFSET(apad) },
3396  "audio pad", "" },
3397  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3398  "timestamp discontinuity delta threshold", "threshold" },
3399  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3400  "timestamp error delta threshold", "threshold" },
3401  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3402  "exit on error", "error" },
3403  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3404  "abort on the specified condition flags", "flags" },
3405  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3406  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3407  "copy initial non-keyframes" },
3408  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3409  "copy or discard frames before start time" },
3410  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3411  "set the number of frames to output", "number" },
3412  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3413  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3414  "force codec tag/fourcc", "fourcc/tag" },
3415  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3416  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3417  "use fixed quality scale (VBR)", "q" },
3418  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3419  OPT_OUTPUT, { .func_arg = opt_qscale },
3420  "use fixed quality scale (VBR)", "q" },
3421  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3422  "set profile", "profile" },
3423  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3424  "set stream filtergraph", "filter_graph" },
3425  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3426  "number of non-complex filter threads" },
3427  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3428  "read stream filtergraph description from a file", "filename" },
3429  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3430  "reinit filtergraph on input parameter changes", "" },
3431  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3432  "create a complex filtergraph", "graph_description" },
3433  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3434  "number of threads for -filter_complex" },
3435  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3436  "create a complex filtergraph", "graph_description" },
3437  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3438  "read complex filtergraph description from a file", "filename" },
3439  { "stats", OPT_BOOL, { &print_stats },
3440  "print progress report during encoding", },
3441  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3442  OPT_OUTPUT, { .func_arg = opt_attach },
3443  "add an attachment to the output file", "filename" },
3444  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3445  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3446  "extract an attachment into a file", "filename" },
3447  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3448  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3449  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3450  "print timestamp debugging info" },
3451  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3452  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3453  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3454  OPT_INPUT, { .off = OFFSET(discard) },
3455  "discard", "" },
3456  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3457  OPT_OUTPUT, { .off = OFFSET(disposition) },
3458  "disposition", "" },
3459  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3460  { .off = OFFSET(thread_queue_size) },
3461  "set the maximum number of queued packets from the demuxer" },
3462 
3463  /* video options */
3464  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3465  "set the number of video frames to output", "number" },
3466  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3467  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3468  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3470  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3471  "set frame size (WxH or abbreviation)", "size" },
3472  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3473  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3474  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3475  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3476  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3477  "set pixel format", "format" },
3478  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3479  "set the number of bits per raw sample", "number" },
3480  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3481  "deprecated use -g 1" },
3483  "disable video" },
3484  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3485  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3486  "rate control override for specific intervals", "override" },
3487  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3488  OPT_OUTPUT, { .func_arg = opt_video_codec },
3489  "force video codec ('copy' to copy stream)", "codec" },
3490  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3491  "Removed" },
3492  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3493  "Removed" },
3494  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3495  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3496  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3497  "select the pass number (1 to 3)", "n" },
3498  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3499  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3500  "select two pass log file name prefix", "prefix" },
3501  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3502  "this option is deprecated, use the yadif filter instead" },
3503  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3504  "calculate PSNR of compressed frames" },
3505  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3506  "dump video coding statistics to file" },
3507  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3508  "dump video coding statistics to file", "file" },
3509  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3510  "Version of the vstats format to use."},
3511  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3512  "set video filters", "filter_graph" },
3513  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3514  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3515  "specify intra matrix coeffs", "matrix" },
3516  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3517  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3518  "specify inter matrix coeffs", "matrix" },
3519  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3520  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3521  "specify intra matrix coeffs", "matrix" },
3522  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3523  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3524  "top=1/bottom=0/auto=-1 field first", "" },
3525  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3526  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3527  "force video tag/fourcc", "fourcc/tag" },
3528  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3529  "show QP histogram" },
3530  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3531  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3532  "force the selected framerate, disable the best supported framerate selection" },
3533  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3534  OPT_OUTPUT, { .func_arg = opt_streamid },
3535  "set the value of an outfile streamid", "streamIndex:value" },
3536  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3537  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3538  "force key frames at specified timestamps", "timestamps" },
3539  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3540  "audio bitrate (please use -b:a)", "bitrate" },
3541  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3542  "video bitrate (please use -b:v)", "bitrate" },
3543  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3544  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3545  "use HW accelerated decoding", "hwaccel name" },
3546  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3547  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3548  "select a device for HW acceleration", "devicename" },
3549  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3550  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3551  "select output format used with HW accelerated decoding", "format" },
3552 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3553  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3554 #endif
3555  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3556  "show available HW acceleration methods" },
3557  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3558  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3559  "automatically insert correct rotate filters" },
3560  { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3561  "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3562 
3563  /* audio options */
3564  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3565  "set the number of audio frames to output", "number" },
3566  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3567  "set audio quality (codec-specific)", "quality", },
3568  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3569  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3570  "set audio sampling rate (in Hz)", "rate" },
3571  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3572  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3573  "set number of audio channels", "channels" },
3575  "disable audio" },
3576  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3577  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3578  "force audio codec ('copy' to copy stream)", "codec" },
3579  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3580  OPT_OUTPUT, { .func_arg = opt_old2new },
3581  "force audio tag/fourcc", "fourcc/tag" },
3582  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3583  "change audio volume (256=normal)" , "volume" },
3584  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3586  "set sample format", "format" },
3587  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3588  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3589  "set channel layout", "layout" },
3590  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3591  "set audio filters", "filter_graph" },
3592  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3593  "set the maximum number of channels to try to guess the channel layout" },
3594 
3595  /* subtitle options */
3597  "disable subtitle" },
3598  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3599  "force subtitle codec ('copy' to copy stream)", "codec" },
3600  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3601  , "force subtitle tag/fourcc", "fourcc/tag" },
3602  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3603  "fix subtitles duration" },
3604  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3605  "set canvas size (WxH or abbreviation)", "size" },
3606 
3607  /* grab options */
3608  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3609  "deprecated, use -channel", "channel" },
3610  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3611  "deprecated, use -standard", "standard" },
3612  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3613 
3614  /* muxer options */
3615  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3616  "set the maximum demux-decode delay", "seconds" },
3617  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3618  "set the initial demux-decode delay", "seconds" },
3619  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3620  "override the options from ffserver", "" },
3621  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3622  "specify a file in which to print sdp information", "file" },
3623 
3624  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3625  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3626 
3627  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3628  "A comma-separated list of bitstream filters", "bitstream_filters" },
3629  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3630  "deprecated", "audio bitstream_filters" },
3631  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3632  "deprecated", "video bitstream_filters" },
3633 
3634  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3635  "set the audio options to the indicated preset", "preset" },
3636  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3637  "set the video options to the indicated preset", "preset" },
3638  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3639  "set the subtitle options to the indicated preset", "preset" },
3640  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3641  "set options from indicated preset file", "filename" },
3642 
3643  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3644  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3645 
3646  /* data codec support */
3647  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3648  "force data codec ('copy' to copy stream)", "codec" },
3649  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3650  "disable data" },
3651 
3652 #if CONFIG_VAAPI
3653  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3654  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3655 #endif
3656 
3657 #if CONFIG_QSV
3658  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3659  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3660 #endif
3661 
3662  { NULL, },
3663 };
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:1053
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:2089
void show_usage(void)
Definition: ffmpeg_opt.c:3162
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:3419
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:522
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:5883
#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:555
void term_init(void)
Definition: ffmpeg.c:370
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:319
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:503
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:312
int stream_copy
Definition: ffmpeg.h:508
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:3149
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2858
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:1317
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:498
static AVInputFormat * file_iformat
Definition: ffplay.c:311
#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:1924
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:4056
int qscale
Definition: avcodec.h:844
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:539
int nb_frame_pix_fmts
Definition: ffmpeg.h:114
#define AVIO_FLAG_READ
read-only
Definition: avio.h:620
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:2990
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:621
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:2133
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:759
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1950
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:3061
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:2899
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1868
enum AVMediaType type
Definition: avcodec.h:3684
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:822
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:3123
int nb_input_streams
Definition: ffmpeg.c:142
static int audio_disable
Definition: ffplay.c:318
const char * name
Definition: ffmpeg.h:73
AVDictionary * metadata
Definition: avformat.h:1310
static const char * audio_codec_name
Definition: ffplay.c:341
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:5836
#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:3671
#define VSYNC_VFR
Definition: ffmpeg.h:54
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1288
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:4048
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:556
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:2884
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:3055
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:82
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1494
enum HWAccelID id
Definition: ffmpeg.h:75
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val)
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:130
const char * name
Definition: opt.h:247
char * logfile_prefix
Definition: ffmpeg.h:493
#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:328
int copy_initial_nonkeyframes
Definition: ffmpeg.h:518
int filter_nbthreads
Definition: ffmpeg_opt.c:122
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2492
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:543
uint8_t
static int nb_streams
Definition: ffprobe.c:255
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:502
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:4122
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:4170
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:894
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3174
FILE * logfile
Definition: ffmpeg.h:494
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:448
AVDictionary * opts
Definition: ffmpeg.h:553
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:3517
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:2996
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:4237
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:559
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:2830
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:4266
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:4336
AVDictionary * resample_opts
Definition: ffmpeg.h:504
int seek_timestamp
Definition: ffmpeg.h:100
static int flags
Definition: log.c:57
list ifile
Definition: normalize.py:6
uint32_t tag
Definition: movenc.c:1412
int * formats
Definition: ffmpeg.h:273
#define OPT_SPEC
Definition: cmdutils.h:181
int nb_input_files
Definition: ffmpeg.c:144
#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:205
const OptionDef options[]
Definition: ffmpeg_opt.c:3286
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:147
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:614
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:258
float quality_factor
Definition: avcodec.h:845
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2957
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:3154
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:552
uint64_t channel_layout
Definition: ffmpeg.h:270
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:123
enum AVCodecID id
Definition: avcodec.h:3685
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:2972
#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:151
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:461
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:3179
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:1089
int video_delay
Video only.
Definition: avcodec.h:4151
static int autorotate
Definition: ffplay.c:352
#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:4052
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1817
const char * name
Definition: cmdutils.h:164
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2941
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:3678
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2932
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:620
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:226
StreamMap * stream_maps
Definition: ffmpeg.h:137
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:89
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:3063
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4074
#define pass
Definition: fft_template.c:532
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:605
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:191
OutputFilter * filter
Definition: ffmpeg.h:496
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:4700
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:3212
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:711
AVRational frame_aspect_ratio
Definition: ffmpeg.h:479
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:1596
static const char * subtitle_codec_name
Definition: ffplay.c:342
static int subtitle_disable
Definition: ffplay.c:320
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:2984
int nb_output_files
Definition: ffmpeg.c:149
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2706
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:225
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:868
#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:3496
attribute_deprecated int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
Definition: options.c:191