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