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