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