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