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  ost->max_muxing_queue_size = 128;
1399  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1400  ost->max_muxing_queue_size *= sizeof(AVPacket);
1401 
1402  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1404 
1405  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1406 
1407  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1408  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1409  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1410 
1411  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1412 
1413  ost->source_index = source_index;
1414  if (source_index >= 0) {
1415  ost->sync_ist = input_streams[source_index];
1416  input_streams[source_index]->discard = 0;
1417  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1418  }
1420 
1421  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1422  if (!ost->muxing_queue)
1423  exit_program(1);
1424 
1425  return ost;
1426 }
1427 
1428 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1429 {
1430  int i;
1431  const char *p = str;
1432  for (i = 0;; i++) {
1433  dest[i] = atoi(p);
1434  if (i == 63)
1435  break;
1436  p = strchr(p, ',');
1437  if (!p) {
1438  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1439  exit_program(1);
1440  }
1441  p++;
1442  }
1443 }
1444 
1445 /* read file contents into a string */
1446 static uint8_t *read_file(const char *filename)
1447 {
1448  AVIOContext *pb = NULL;
1449  AVIOContext *dyn_buf = NULL;
1450  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1451  uint8_t buf[1024], *str;
1452 
1453  if (ret < 0) {
1454  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1455  return NULL;
1456  }
1457 
1458  ret = avio_open_dyn_buf(&dyn_buf);
1459  if (ret < 0) {
1460  avio_closep(&pb);
1461  return NULL;
1462  }
1463  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1464  avio_write(dyn_buf, buf, ret);
1465  avio_w8(dyn_buf, 0);
1466  avio_closep(&pb);
1467 
1468  ret = avio_close_dyn_buf(dyn_buf, &str);
1469  if (ret < 0)
1470  return NULL;
1471  return str;
1472 }
1473 
1475  OutputStream *ost)
1476 {
1477  AVStream *st = ost->st;
1478 
1479  if (ost->filters_script && ost->filters) {
1480  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1481  "output stream #%d:%d.\n", nb_output_files, st->index);
1482  exit_program(1);
1483  }
1484 
1485  if (ost->filters_script)
1486  return read_file(ost->filters_script);
1487  else if (ost->filters)
1488  return av_strdup(ost->filters);
1489 
1491  "null" : "anull");
1492 }
1493 
1495  const OutputStream *ost, enum AVMediaType type)
1496 {
1497  if (ost->filters_script || ost->filters) {
1499  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1500  "Filtering and streamcopy cannot be used together.\n",
1501  ost->filters ? "Filtergraph" : "Filtergraph script",
1502  ost->filters ? ost->filters : ost->filters_script,
1503  av_get_media_type_string(type), ost->file_index, ost->index);
1504  exit_program(1);
1505  }
1506 }
1507 
1509 {
1510  AVStream *st;
1511  OutputStream *ost;
1512  AVCodecContext *video_enc;
1513  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1514 
1515  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1516  st = ost->st;
1517  video_enc = ost->enc_ctx;
1518 
1519  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1520  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1521  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1522  exit_program(1);
1523  }
1524  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1525  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1526 
1527  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1528  if (frame_aspect_ratio) {
1529  AVRational q;
1530  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1531  q.num <= 0 || q.den <= 0) {
1532  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1533  exit_program(1);
1534  }
1535  ost->frame_aspect_ratio = q;
1536  }
1537 
1538  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1539  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1540 
1541  if (!ost->stream_copy) {
1542  const char *p = NULL;
1543  char *frame_size = NULL;
1544  char *frame_pix_fmt = NULL;
1545  char *intra_matrix = NULL, *inter_matrix = NULL;
1546  char *chroma_intra_matrix = NULL;
1547  int do_pass = 0;
1548  int i;
1549 
1550  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1551  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1552  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1553  exit_program(1);
1554  }
1555 
1557  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1558  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1559  ost->keep_pix_fmt = 1;
1560  if (!*++frame_pix_fmt)
1561  frame_pix_fmt = NULL;
1562  }
1563  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1564  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1565  exit_program(1);
1566  }
1567  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1568 
1569  if (intra_only)
1570  video_enc->gop_size = 0;
1571  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1572  if (intra_matrix) {
1573  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1574  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1575  exit_program(1);
1576  }
1577  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1578  }
1579  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1580  if (chroma_intra_matrix) {
1581  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1582  if (!p) {
1583  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1584  exit_program(1);
1585  }
1586  av_codec_set_chroma_intra_matrix(video_enc, p);
1587  parse_matrix_coeffs(p, chroma_intra_matrix);
1588  }
1589  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1590  if (inter_matrix) {
1591  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1592  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1593  exit_program(1);
1594  }
1595  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1596  }
1597 
1598  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1599  for (i = 0; p; i++) {
1600  int start, end, q;
1601  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1602  if (e != 3) {
1603  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1604  exit_program(1);
1605  }
1606  video_enc->rc_override =
1607  av_realloc_array(video_enc->rc_override,
1608  i + 1, sizeof(RcOverride));
1609  if (!video_enc->rc_override) {
1610  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1611  exit_program(1);
1612  }
1613  video_enc->rc_override[i].start_frame = start;
1614  video_enc->rc_override[i].end_frame = end;
1615  if (q > 0) {
1616  video_enc->rc_override[i].qscale = q;
1617  video_enc->rc_override[i].quality_factor = 1.0;
1618  }
1619  else {
1620  video_enc->rc_override[i].qscale = 0;
1621  video_enc->rc_override[i].quality_factor = -q/100.0;
1622  }
1623  p = strchr(p, '/');
1624  if (p) p++;
1625  }
1626  video_enc->rc_override_count = i;
1627 
1628  if (do_psnr)
1629  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1630 
1631  /* two pass mode */
1632  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1633  if (do_pass) {
1634  if (do_pass & 1) {
1635  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1636  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1637  }
1638  if (do_pass & 2) {
1639  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1640  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1641  }
1642  }
1643 
1644  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1645  if (ost->logfile_prefix &&
1646  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1647  exit_program(1);
1648 
1649  if (do_pass) {
1650  char logfilename[1024];
1651  FILE *f;
1652 
1653  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1654  ost->logfile_prefix ? ost->logfile_prefix :
1656  i);
1657  if (!strcmp(ost->enc->name, "libx264")) {
1658  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1659  } else {
1660  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1661  char *logbuffer = read_file(logfilename);
1662 
1663  if (!logbuffer) {
1664  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1665  logfilename);
1666  exit_program(1);
1667  }
1668  video_enc->stats_in = logbuffer;
1669  }
1670  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1671  f = av_fopen_utf8(logfilename, "wb");
1672  if (!f) {
1674  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1675  logfilename, strerror(errno));
1676  exit_program(1);
1677  }
1678  ost->logfile = f;
1679  }
1680  }
1681  }
1682 
1683  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1684  if (ost->forced_keyframes)
1686 
1687  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1688 
1689  ost->top_field_first = -1;
1690  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1691 
1692 
1693  ost->avfilter = get_ost_filters(o, oc, ost);
1694  if (!ost->avfilter)
1695  exit_program(1);
1696  } else {
1697  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1698  }
1699 
1700  if (ost->stream_copy)
1702 
1703  return ost;
1704 }
1705 
1707 {
1708  int n;
1709  AVStream *st;
1710  OutputStream *ost;
1711  AVCodecContext *audio_enc;
1712 
1713  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1714  st = ost->st;
1715 
1716  audio_enc = ost->enc_ctx;
1717  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1718 
1719  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1720  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1721 
1722  if (!ost->stream_copy) {
1723  char *sample_fmt = NULL;
1724 
1725  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1726 
1727  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1728  if (sample_fmt &&
1729  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1730  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1731  exit_program(1);
1732  }
1733 
1734  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1735 
1736  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1737  ost->apad = av_strdup(ost->apad);
1738 
1739  ost->avfilter = get_ost_filters(o, oc, ost);
1740  if (!ost->avfilter)
1741  exit_program(1);
1742 
1743  /* check for channel mapping for this audio stream */
1744  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1746  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1747  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1748  InputStream *ist;
1749 
1750  if (map->channel_idx == -1) {
1751  ist = NULL;
1752  } else if (ost->source_index < 0) {
1753  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1754  ost->file_index, ost->st->index);
1755  continue;
1756  } else {
1757  ist = input_streams[ost->source_index];
1758  }
1759 
1760  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1762  ost->audio_channels_mapped + 1,
1763  sizeof(*ost->audio_channels_map)
1764  ) < 0 )
1765  exit_program(1);
1766 
1768  }
1769  }
1770  }
1771  }
1772 
1773  if (ost->stream_copy)
1775 
1776  return ost;
1777 }
1778 
1780 {
1781  OutputStream *ost;
1782 
1783  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1784  if (!ost->stream_copy) {
1785  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1786  exit_program(1);
1787  }
1788 
1789  return ost;
1790 }
1791 
1793 {
1794  OutputStream *ost;
1795 
1796  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1797  if (!ost->stream_copy) {
1798  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1799  exit_program(1);
1800  }
1801 
1802  return ost;
1803 }
1804 
1806 {
1807  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1808  ost->stream_copy = 1;
1809  ost->finished = 1;
1810  return ost;
1811 }
1812 
1814 {
1815  AVStream *st;
1816  OutputStream *ost;
1817  AVCodecContext *subtitle_enc;
1818 
1819  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1820  st = ost->st;
1821  subtitle_enc = ost->enc_ctx;
1822 
1823  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1824 
1825  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1826 
1827  if (!ost->stream_copy) {
1828  char *frame_size = NULL;
1829 
1830  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1831  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1832  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1833  exit_program(1);
1834  }
1835  }
1836 
1837  return ost;
1838 }
1839 
1840 /* arg format is "output-stream-index:streamid-value". */
1841 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1842 {
1843  OptionsContext *o = optctx;
1844  int idx;
1845  char *p;
1846  char idx_str[16];
1847 
1848  av_strlcpy(idx_str, arg, sizeof(idx_str));
1849  p = strchr(idx_str, ':');
1850  if (!p) {
1852  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1853  arg, opt);
1854  exit_program(1);
1855  }
1856  *p++ = '\0';
1857  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1858  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1859  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1860  return 0;
1861 }
1862 
1864 {
1865  AVFormatContext *is = ifile->ctx;
1866  AVFormatContext *os = ofile->ctx;
1867  AVChapter **tmp;
1868  int i;
1869 
1870  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1871  if (!tmp)
1872  return AVERROR(ENOMEM);
1873  os->chapters = tmp;
1874 
1875  for (i = 0; i < is->nb_chapters; i++) {
1876  AVChapter *in_ch = is->chapters[i], *out_ch;
1877  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1878  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1879  AV_TIME_BASE_Q, in_ch->time_base);
1880  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1882 
1883 
1884  if (in_ch->end < ts_off)
1885  continue;
1886  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1887  break;
1888 
1889  out_ch = av_mallocz(sizeof(AVChapter));
1890  if (!out_ch)
1891  return AVERROR(ENOMEM);
1892 
1893  out_ch->id = in_ch->id;
1894  out_ch->time_base = in_ch->time_base;
1895  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1896  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1897 
1898  if (copy_metadata)
1899  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1900 
1901  os->chapters[os->nb_chapters++] = out_ch;
1902  }
1903  return 0;
1904 }
1905 
1906 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1907 {
1908  int i, err;
1910 
1911  ic->interrupt_callback = int_cb;
1912  err = avformat_open_input(&ic, filename, NULL, NULL);
1913  if (err < 0)
1914  return err;
1915  /* copy stream format */
1916  for(i=0;i<ic->nb_streams;i++) {
1917  AVStream *st;
1918  OutputStream *ost;
1919  AVCodec *codec;
1920  const char *enc_config;
1921 
1922  codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1923  if (!codec) {
1924  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1925  return AVERROR(EINVAL);
1926  }
1927  if (codec->type == AVMEDIA_TYPE_AUDIO)
1928  opt_audio_codec(o, "c:a", codec->name);
1929  else if (codec->type == AVMEDIA_TYPE_VIDEO)
1930  opt_video_codec(o, "c:v", codec->name);
1931  ost = new_output_stream(o, s, codec->type, -1);
1932  st = ost->st;
1933 
1934  avcodec_get_context_defaults3(st->codec, codec);
1936  if (enc_config) {
1937  AVDictionary *opts = NULL;
1938  av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1939  av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1940  av_dict_free(&opts);
1941  }
1942 
1943  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1944  choose_sample_fmt(st, codec);
1945  else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1946  choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1947  avcodec_copy_context(ost->enc_ctx, st->codec);
1948  if (enc_config)
1949  av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1950  }
1951 
1952  avformat_close_input(&ic);
1953  return err;
1954 }
1955 
1957  AVFormatContext *oc)
1958 {
1959  OutputStream *ost;
1960 
1961  switch (ofilter->type) {
1962  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1963  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1964  default:
1965  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1966  "currently.\n");
1967  exit_program(1);
1968  }
1969 
1970  ost->source_index = -1;
1971  ost->filter = ofilter;
1972 
1973  ofilter->ost = ost;
1974 
1975  if (ost->stream_copy) {
1976  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1977  "which is fed from a complex filtergraph. Filtering and streamcopy "
1978  "cannot be used together.\n", ost->file_index, ost->index);
1979  exit_program(1);
1980  }
1981 
1982  if (ost->avfilter && (ost->filters || ost->filters_script)) {
1983  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1985  "%s '%s' was specified through the %s option "
1986  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1987  "%s and -filter_complex cannot be used together for the same stream.\n",
1988  ost->filters ? "Filtergraph" : "Filtergraph script",
1989  ost->filters ? ost->filters : ost->filters_script,
1990  opt, ost->file_index, ost->index, opt);
1991  exit_program(1);
1992  }
1993 
1994  avfilter_inout_free(&ofilter->out_tmp);
1995 }
1996 
1997 static int init_complex_filters(void)
1998 {
1999  int i, ret = 0;
2000 
2001  for (i = 0; i < nb_filtergraphs; i++) {
2003  if (ret < 0)
2004  return ret;
2005  }
2006  return 0;
2007 }
2008 
2010 {
2011  int i, ret = 0;
2012 
2013  for (i = 0; i < nb_filtergraphs; i++)
2015  (ret = configure_filtergraph(filtergraphs[i])) < 0)
2016  return ret;
2017  return 0;
2018 }
2019 
2020 static int open_output_file(OptionsContext *o, const char *filename)
2021 {
2022  AVFormatContext *oc;
2023  int i, j, err;
2024  AVOutputFormat *file_oformat;
2025  OutputFile *of;
2026  OutputStream *ost;
2027  InputStream *ist;
2028  AVDictionary *unused_opts = NULL;
2029  AVDictionaryEntry *e = NULL;
2030 
2031 
2032  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2033  o->stop_time = INT64_MAX;
2034  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2035  }
2036 
2037  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2038  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2039  if (o->stop_time <= start_time) {
2040  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2041  exit_program(1);
2042  } else {
2044  }
2045  }
2046 
2048  of = av_mallocz(sizeof(*of));
2049  if (!of)
2050  exit_program(1);
2051  output_files[nb_output_files - 1] = of;
2052 
2054  of->recording_time = o->recording_time;
2055  of->start_time = o->start_time;
2056  of->limit_filesize = o->limit_filesize;
2057  of->shortest = o->shortest;
2058  av_dict_copy(&of->opts, o->g->format_opts, 0);
2059 
2060  if (!strcmp(filename, "-"))
2061  filename = "pipe:";
2062 
2063  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2064  if (!oc) {
2065  print_error(filename, err);
2066  exit_program(1);
2067  }
2068 
2069  of->ctx = oc;
2070  if (o->recording_time != INT64_MAX)
2071  oc->duration = o->recording_time;
2072 
2073  file_oformat= oc->oformat;
2074  oc->interrupt_callback = int_cb;
2075 
2076  /* create streams for all unlabeled output pads */
2077  for (i = 0; i < nb_filtergraphs; i++) {
2078  FilterGraph *fg = filtergraphs[i];
2079  for (j = 0; j < fg->nb_outputs; j++) {
2080  OutputFilter *ofilter = fg->outputs[j];
2081 
2082  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2083  continue;
2084 
2085  switch (ofilter->type) {
2086  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2087  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2088  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2089  }
2090  init_output_filter(ofilter, o, oc);
2091  }
2092  }
2093 
2094  /* ffserver seeking with date=... needs a date reference */
2095  if (!strcmp(file_oformat->name, "ffm") &&
2096  av_strstart(filename, "http:", NULL)) {
2097  int err = parse_option(o, "metadata", "creation_time=now", options);
2098  if (err < 0) {
2099  print_error(filename, err);
2100  exit_program(1);
2101  }
2102  }
2103 
2104  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2105  av_strstart(filename, "http:", NULL)) {
2106  int j;
2107  /* special case for files sent to ffserver: we get the stream
2108  parameters from ffserver */
2109  int err = read_ffserver_streams(o, oc, filename);
2110  if (err < 0) {
2111  print_error(filename, err);
2112  exit_program(1);
2113  }
2114  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2115  ost = output_streams[j];
2116  for (i = 0; i < nb_input_streams; i++) {
2117  ist = input_streams[i];
2118  if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2119  ost->sync_ist= ist;
2120  ost->source_index= i;
2121  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2122  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2123  ist->discard = 0;
2124  ist->st->discard = ist->user_set_discard;
2125  break;
2126  }
2127  }
2128  if(!ost->sync_ist){
2129  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));
2130  exit_program(1);
2131  }
2132  }
2133  } else if (!o->nb_stream_maps) {
2134  char *subtitle_codec_name = NULL;
2135  /* pick the "best" stream of each type */
2136 
2137  /* video: highest resolution */
2139  int area = 0, idx = -1;
2140  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2141  for (i = 0; i < nb_input_streams; i++) {
2142  int new_area;
2143  ist = input_streams[i];
2144  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2145  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2146  new_area = 1;
2147  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2148  new_area > area) {
2149  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2150  continue;
2151  area = new_area;
2152  idx = i;
2153  }
2154  }
2155  if (idx >= 0)
2156  new_video_stream(o, oc, idx);
2157  }
2158 
2159  /* audio: most channels */
2161  int best_score = 0, idx = -1;
2162  for (i = 0; i < nb_input_streams; i++) {
2163  int score;
2164  ist = input_streams[i];
2165  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2166  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2167  score > best_score) {
2168  best_score = score;
2169  idx = i;
2170  }
2171  }
2172  if (idx >= 0)
2173  new_audio_stream(o, oc, idx);
2174  }
2175 
2176  /* subtitles: pick first */
2177  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2178  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2179  for (i = 0; i < nb_input_streams; i++)
2180  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2181  AVCodecDescriptor const *input_descriptor =
2182  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2183  AVCodecDescriptor const *output_descriptor = NULL;
2184  AVCodec const *output_codec =
2186  int input_props = 0, output_props = 0;
2187  if (output_codec)
2188  output_descriptor = avcodec_descriptor_get(output_codec->id);
2189  if (input_descriptor)
2190  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2191  if (output_descriptor)
2192  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2193  if (subtitle_codec_name ||
2194  input_props & output_props ||
2195  // Map dvb teletext which has neither property to any output subtitle encoder
2196  input_descriptor && output_descriptor &&
2197  (!input_descriptor->props ||
2198  !output_descriptor->props)) {
2199  new_subtitle_stream(o, oc, i);
2200  break;
2201  }
2202  }
2203  }
2204  /* Data only if codec id match */
2205  if (!o->data_disable ) {
2207  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2208  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2209  && input_streams[i]->st->codecpar->codec_id == codec_id )
2210  new_data_stream(o, oc, i);
2211  }
2212  }
2213  } else {
2214  for (i = 0; i < o->nb_stream_maps; i++) {
2215  StreamMap *map = &o->stream_maps[i];
2216 
2217  if (map->disabled)
2218  continue;
2219 
2220  if (map->linklabel) {
2221  FilterGraph *fg;
2222  OutputFilter *ofilter = NULL;
2223  int j, k;
2224 
2225  for (j = 0; j < nb_filtergraphs; j++) {
2226  fg = filtergraphs[j];
2227  for (k = 0; k < fg->nb_outputs; k++) {
2228  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2229  if (out && !strcmp(out->name, map->linklabel)) {
2230  ofilter = fg->outputs[k];
2231  goto loop_end;
2232  }
2233  }
2234  }
2235 loop_end:
2236  if (!ofilter) {
2237  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2238  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2239  exit_program(1);
2240  }
2241  init_output_filter(ofilter, o, oc);
2242  } else {
2243  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2244 
2247  continue;
2249  continue;
2251  continue;
2252  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2253  continue;
2254 
2255  ost = NULL;
2256  switch (ist->st->codecpar->codec_type) {
2257  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2258  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2259  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2260  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2261  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2262  case AVMEDIA_TYPE_UNKNOWN:
2263  if (copy_unknown_streams) {
2264  ost = new_unknown_stream (o, oc, src_idx);
2265  break;
2266  }
2267  default:
2269  "Cannot map stream #%d:%d - unsupported type.\n",
2270  map->file_index, map->stream_index);
2271  if (!ignore_unknown_streams) {
2272  av_log(NULL, AV_LOG_FATAL,
2273  "If you want unsupported types ignored instead "
2274  "of failing, please use the -ignore_unknown option\n"
2275  "If you want them copied, please use -copy_unknown\n");
2276  exit_program(1);
2277  }
2278  }
2279  if (ost)
2280  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2281  + map->sync_stream_index];
2282  }
2283  }
2284  }
2285 
2286  /* handle attached files */
2287  for (i = 0; i < o->nb_attachments; i++) {
2288  AVIOContext *pb;
2289  uint8_t *attachment;
2290  const char *p;
2291  int64_t len;
2292 
2293  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2294  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2295  o->attachments[i]);
2296  exit_program(1);
2297  }
2298  if ((len = avio_size(pb)) <= 0) {
2299  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2300  o->attachments[i]);
2301  exit_program(1);
2302  }
2303  if (!(attachment = av_malloc(len))) {
2304  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2305  o->attachments[i]);
2306  exit_program(1);
2307  }
2308  avio_read(pb, attachment, len);
2309 
2310  ost = new_attachment_stream(o, oc, -1);
2311  ost->stream_copy = 0;
2312  ost->attachment_filename = o->attachments[i];
2313  ost->st->codecpar->extradata = attachment;
2314  ost->st->codecpar->extradata_size = len;
2315 
2316  p = strrchr(o->attachments[i], '/');
2317  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2318  avio_closep(&pb);
2319  }
2320 
2321 #if FF_API_LAVF_AVCTX
2322  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2323  AVDictionaryEntry *e;
2324  ost = output_streams[i];
2325 
2326  if ((ost->stream_copy || ost->attachment_filename)
2327  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2328  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2329  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2330  exit_program(1);
2331  }
2332 #endif
2333 
2334  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2335  av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2336  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2337  exit_program(1);
2338  }
2339 
2340  /* check if all codec options have been used */
2341  unused_opts = strip_specifiers(o->g->codec_opts);
2342  for (i = of->ost_index; i < nb_output_streams; i++) {
2343  e = NULL;
2344  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2346  av_dict_set(&unused_opts, e->key, NULL, 0);
2347  }
2348 
2349  e = NULL;
2350  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2351  const AVClass *class = avcodec_get_class();
2352  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2354  const AVClass *fclass = avformat_get_class();
2355  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2357  if (!option || foption)
2358  continue;
2359 
2360 
2361  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2362  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2363  "output file #%d (%s) is not an encoding option.\n", e->key,
2364  option->help ? option->help : "", nb_output_files - 1,
2365  filename);
2366  exit_program(1);
2367  }
2368 
2369  // gop_timecode is injected by generic code but not always used
2370  if (!strcmp(e->key, "gop_timecode"))
2371  continue;
2372 
2373  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2374  "output file #%d (%s) has not been used for any stream. The most "
2375  "likely reason is either wrong type (e.g. a video option with "
2376  "no video streams) or that it is a private option of some encoder "
2377  "which was not actually used for any stream.\n", e->key,
2378  option->help ? option->help : "", nb_output_files - 1, filename);
2379  }
2380  av_dict_free(&unused_opts);
2381 
2382  /* set the decoding_needed flags and create simple filtergraphs */
2383  for (i = of->ost_index; i < nb_output_streams; i++) {
2384  OutputStream *ost = output_streams[i];
2385 
2386  if (ost->encoding_needed && ost->source_index >= 0) {
2387  InputStream *ist = input_streams[ost->source_index];
2389 
2390  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2392  err = init_simple_filtergraph(ist, ost);
2393  if (err < 0) {
2395  "Error initializing a simple filtergraph between streams "
2396  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2397  nb_output_files - 1, ost->st->index);
2398  exit_program(1);
2399  }
2400  }
2401  }
2402  }
2403 
2404  /* check filename in case of an image number is expected */
2405  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2406  if (!av_filename_number_test(oc->filename)) {
2407  print_error(oc->filename, AVERROR(EINVAL));
2408  exit_program(1);
2409  }
2410  }
2411 
2414  "No input streams but output needs an input stream\n");
2415  exit_program(1);
2416  }
2417 
2418  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2419  /* test if it already exists to avoid losing precious files */
2420  assert_file_overwrite(filename);
2421 
2422  /* open the file */
2423  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2424  &oc->interrupt_callback,
2425  &of->opts)) < 0) {
2426  print_error(filename, err);
2427  exit_program(1);
2428  }
2429  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2430  assert_file_overwrite(filename);
2431 
2432  if (o->mux_preload) {
2433  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2434  }
2435  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2436 
2437  /* copy metadata */
2438  for (i = 0; i < o->nb_metadata_map; i++) {
2439  char *p;
2440  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2441 
2442  if (in_file_index >= nb_input_files) {
2443  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2444  exit_program(1);
2445  }
2446  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2447  in_file_index >= 0 ?
2448  input_files[in_file_index]->ctx : NULL, o);
2449  }
2450 
2451  /* copy chapters */
2452  if (o->chapters_input_file >= nb_input_files) {
2453  if (o->chapters_input_file == INT_MAX) {
2454  /* copy chapters from the first input file that has them*/
2455  o->chapters_input_file = -1;
2456  for (i = 0; i < nb_input_files; i++)
2457  if (input_files[i]->ctx->nb_chapters) {
2458  o->chapters_input_file = i;
2459  break;
2460  }
2461  } else {
2462  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2463  o->chapters_input_file);
2464  exit_program(1);
2465  }
2466  }
2467  if (o->chapters_input_file >= 0)
2470 
2471  /* copy global metadata by default */
2475  if(o->recording_time != INT64_MAX)
2476  av_dict_set(&oc->metadata, "duration", NULL, 0);
2477  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2478  }
2479  if (!o->metadata_streams_manual)
2480  for (i = of->ost_index; i < nb_output_streams; i++) {
2481  InputStream *ist;
2482  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2483  continue;
2485  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2486  if (!output_streams[i]->stream_copy) {
2487  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2488  if (ist->autorotate)
2489  av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2490  }
2491  }
2492 
2493  /* process manually set programs */
2494  for (i = 0; i < o->nb_program; i++) {
2495  const char *p = o->program[i].u.str;
2496  int progid = i+1;
2497  AVProgram *program;
2498 
2499  while(*p) {
2500  const char *p2 = av_get_token(&p, ":");
2501  const char *to_dealloc = p2;
2502  char *key;
2503  if (!p2)
2504  break;
2505 
2506  if(*p) p++;
2507 
2508  key = av_get_token(&p2, "=");
2509  if (!key || !*p2) {
2510  av_freep(&to_dealloc);
2511  av_freep(&key);
2512  break;
2513  }
2514  p2++;
2515 
2516  if (!strcmp(key, "program_num"))
2517  progid = strtol(p2, NULL, 0);
2518  av_freep(&to_dealloc);
2519  av_freep(&key);
2520  }
2521 
2522  program = av_new_program(oc, progid);
2523 
2524  p = o->program[i].u.str;
2525  while(*p) {
2526  const char *p2 = av_get_token(&p, ":");
2527  const char *to_dealloc = p2;
2528  char *key;
2529  if (!p2)
2530  break;
2531  if(*p) p++;
2532 
2533  key = av_get_token(&p2, "=");
2534  if (!key) {
2536  "No '=' character in program string %s.\n",
2537  p2);
2538  exit_program(1);
2539  }
2540  if (!*p2)
2541  exit_program(1);
2542  p2++;
2543 
2544  if (!strcmp(key, "title")) {
2545  av_dict_set(&program->metadata, "title", p2, 0);
2546  } else if (!strcmp(key, "program_num")) {
2547  } else if (!strcmp(key, "st")) {
2548  int st_num = strtol(p2, NULL, 0);
2549  av_program_add_stream_index(oc, progid, st_num);
2550  } else {
2551  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2552  exit_program(1);
2553  }
2554  av_freep(&to_dealloc);
2555  av_freep(&key);
2556  }
2557  }
2558 
2559  /* process manually set metadata */
2560  for (i = 0; i < o->nb_metadata; i++) {
2561  AVDictionary **m;
2562  char type, *val;
2563  const char *stream_spec;
2564  int index = 0, j, ret = 0;
2565 
2566  val = strchr(o->metadata[i].u.str, '=');
2567  if (!val) {
2568  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2569  o->metadata[i].u.str);
2570  exit_program(1);
2571  }
2572  *val++ = 0;
2573 
2574  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2575  if (type == 's') {
2576  for (j = 0; j < oc->nb_streams; j++) {
2577  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2578  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2579  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2580  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2581  ost->rotate_overridden = 1;
2582  }
2583  } else if (ret < 0)
2584  exit_program(1);
2585  }
2586  }
2587  else {
2588  switch (type) {
2589  case 'g':
2590  m = &oc->metadata;
2591  break;
2592  case 'c':
2593  if (index < 0 || index >= oc->nb_chapters) {
2594  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2595  exit_program(1);
2596  }
2597  m = &oc->chapters[index]->metadata;
2598  break;
2599  case 'p':
2600  if (index < 0 || index >= oc->nb_programs) {
2601  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2602  exit_program(1);
2603  }
2604  m = &oc->programs[index]->metadata;
2605  break;
2606  default:
2607  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2608  exit_program(1);
2609  }
2610  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2611  }
2612  }
2613 
2614  return 0;
2615 }
2616 
2617 static int opt_target(void *optctx, const char *opt, const char *arg)
2618 {
2619  OptionsContext *o = optctx;
2620  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2621  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2622 
2623  if (!strncmp(arg, "pal-", 4)) {
2624  norm = PAL;
2625  arg += 4;
2626  } else if (!strncmp(arg, "ntsc-", 5)) {
2627  norm = NTSC;
2628  arg += 5;
2629  } else if (!strncmp(arg, "film-", 5)) {
2630  norm = FILM;
2631  arg += 5;
2632  } else {
2633  /* Try to determine PAL/NTSC by peeking in the input files */
2634  if (nb_input_files) {
2635  int i, j, fr;
2636  for (j = 0; j < nb_input_files; j++) {
2637  for (i = 0; i < input_files[j]->nb_streams; i++) {
2638  AVStream *st = input_files[j]->ctx->streams[i];
2640  continue;
2641  fr = st->time_base.den * 1000 / st->time_base.num;
2642  if (fr == 25000) {
2643  norm = PAL;
2644  break;
2645  } else if ((fr == 29970) || (fr == 23976)) {
2646  norm = NTSC;
2647  break;
2648  }
2649  }
2650  if (norm != UNKNOWN)
2651  break;
2652  }
2653  }
2654  if (norm != UNKNOWN)
2655  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2656  }
2657 
2658  if (norm == UNKNOWN) {
2659  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2660  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2661  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2662  exit_program(1);
2663  }
2664 
2665  if (!strcmp(arg, "vcd")) {
2666  opt_video_codec(o, "c:v", "mpeg1video");
2667  opt_audio_codec(o, "c:a", "mp2");
2668  parse_option(o, "f", "vcd", options);
2669 
2670  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2671  parse_option(o, "r", frame_rates[norm], options);
2672  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2673 
2674  opt_default(NULL, "b:v", "1150000");
2675  opt_default(NULL, "maxrate:v", "1150000");
2676  opt_default(NULL, "minrate:v", "1150000");
2677  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2678 
2679  opt_default(NULL, "b:a", "224000");
2680  parse_option(o, "ar", "44100", options);
2681  parse_option(o, "ac", "2", options);
2682 
2683  opt_default(NULL, "packetsize", "2324");
2684  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2685 
2686  /* We have to offset the PTS, so that it is consistent with the SCR.
2687  SCR starts at 36000, but the first two packs contain only padding
2688  and the first pack from the other stream, respectively, may also have
2689  been written before.
2690  So the real data starts at SCR 36000+3*1200. */
2691  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2692  } else if (!strcmp(arg, "svcd")) {
2693 
2694  opt_video_codec(o, "c:v", "mpeg2video");
2695  opt_audio_codec(o, "c:a", "mp2");
2696  parse_option(o, "f", "svcd", options);
2697 
2698  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2699  parse_option(o, "r", frame_rates[norm], options);
2700  parse_option(o, "pix_fmt", "yuv420p", options);
2701  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2702 
2703  opt_default(NULL, "b:v", "2040000");
2704  opt_default(NULL, "maxrate:v", "2516000");
2705  opt_default(NULL, "minrate:v", "0"); // 1145000;
2706  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2707  opt_default(NULL, "scan_offset", "1");
2708 
2709  opt_default(NULL, "b:a", "224000");
2710  parse_option(o, "ar", "44100", options);
2711 
2712  opt_default(NULL, "packetsize", "2324");
2713 
2714  } else if (!strcmp(arg, "dvd")) {
2715 
2716  opt_video_codec(o, "c:v", "mpeg2video");
2717  opt_audio_codec(o, "c:a", "ac3");
2718  parse_option(o, "f", "dvd", options);
2719 
2720  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2721  parse_option(o, "r", frame_rates[norm], options);
2722  parse_option(o, "pix_fmt", "yuv420p", options);
2723  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2724 
2725  opt_default(NULL, "b:v", "6000000");
2726  opt_default(NULL, "maxrate:v", "9000000");
2727  opt_default(NULL, "minrate:v", "0"); // 1500000;
2728  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2729 
2730  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2731  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2732 
2733  opt_default(NULL, "b:a", "448000");
2734  parse_option(o, "ar", "48000", options);
2735 
2736  } else if (!strncmp(arg, "dv", 2)) {
2737 
2738  parse_option(o, "f", "dv", options);
2739 
2740  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2741  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2742  norm == PAL ? "yuv420p" : "yuv411p", options);
2743  parse_option(o, "r", frame_rates[norm], options);
2744 
2745  parse_option(o, "ar", "48000", options);
2746  parse_option(o, "ac", "2", options);
2747 
2748  } else {
2749  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2750  return AVERROR(EINVAL);
2751  }
2752 
2755 
2756  return 0;
2757 }
2758 
2759 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2760 {
2762  vstats_filename = av_strdup (arg);
2763  return 0;
2764 }
2765 
2766 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2767 {
2768  char filename[40];
2769  time_t today2 = time(NULL);
2770  struct tm *today = localtime(&today2);
2771 
2772  if (!today) { // maybe tomorrow
2773  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2774  exit_program(1);
2775  }
2776 
2777  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2778  today->tm_sec);
2779  return opt_vstats_file(NULL, opt, filename);
2780 }
2781 
2782 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2783 {
2784  OptionsContext *o = optctx;
2785  return parse_option(o, "frames:v", arg, options);
2786 }
2787 
2788 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2789 {
2790  OptionsContext *o = optctx;
2791  return parse_option(o, "frames:a", arg, options);
2792 }
2793 
2794 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2795 {
2796  OptionsContext *o = optctx;
2797  return parse_option(o, "frames:d", arg, options);
2798 }
2799 
2800 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2801 {
2802  int ret;
2803  AVDictionary *cbak = codec_opts;
2804  AVDictionary *fbak = format_opts;
2805  codec_opts = NULL;
2806  format_opts = NULL;
2807 
2808  ret = opt_default(NULL, opt, arg);
2809 
2810  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2814  codec_opts = cbak;
2815  format_opts = fbak;
2816 
2817  return ret;
2818 }
2819 
2820 static int opt_preset(void *optctx, const char *opt, const char *arg)
2821 {
2822  OptionsContext *o = optctx;
2823  FILE *f=NULL;
2824  char filename[1000], line[1000], tmp_line[1000];
2825  const char *codec_name = NULL;
2826 
2827  tmp_line[0] = *opt;
2828  tmp_line[1] = 0;
2829  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2830 
2831  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2832  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2833  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2834  }else
2835  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2836  exit_program(1);
2837  }
2838 
2839  while (fgets(line, sizeof(line), f)) {
2840  char *key = tmp_line, *value, *endptr;
2841 
2842  if (strcspn(line, "#\n\r") == 0)
2843  continue;
2844  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2845  if (!av_strtok(key, "=", &value) ||
2846  !av_strtok(value, "\r\n", &endptr)) {
2847  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2848  exit_program(1);
2849  }
2850  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2851 
2852  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2853  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2854  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2855  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2856  else if (opt_default_new(o, key, value) < 0) {
2857  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2858  filename, line, key, value);
2859  exit_program(1);
2860  }
2861  }
2862 
2863  fclose(f);
2864 
2865  return 0;
2866 }
2867 
2868 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2869 {
2870  OptionsContext *o = optctx;
2871  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2872  int ret = parse_option(o, s, arg, options);
2873  av_free(s);
2874  return ret;
2875 }
2876 
2877 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2878 {
2879  OptionsContext *o = optctx;
2880 
2881  if(!strcmp(opt, "ab")){
2882  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2883  return 0;
2884  } else if(!strcmp(opt, "b")){
2885  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2886  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2887  return 0;
2888  }
2889  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2890  return 0;
2891 }
2892 
2893 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2894 {
2895  OptionsContext *o = optctx;
2896  char *s;
2897  int ret;
2898  if(!strcmp(opt, "qscale")){
2899  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2900  return parse_option(o, "q:v", arg, options);
2901  }
2902  s = av_asprintf("q%s", opt + 6);
2903  ret = parse_option(o, s, arg, options);
2904  av_free(s);
2905  return ret;
2906 }
2907 
2908 static int opt_profile(void *optctx, const char *opt, const char *arg)
2909 {
2910  OptionsContext *o = optctx;
2911  if(!strcmp(opt, "profile")){
2912  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2913  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2914  return 0;
2915  }
2916  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2917  return 0;
2918 }
2919 
2920 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2921 {
2922  OptionsContext *o = optctx;
2923  return parse_option(o, "filter:v", arg, options);
2924 }
2925 
2926 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2927 {
2928  OptionsContext *o = optctx;
2929  return parse_option(o, "filter:a", arg, options);
2930 }
2931 
2932 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2933 {
2934  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2935  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2936  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2937  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2938 
2941  return 0;
2942 }
2943 
2944 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2945 {
2946  OptionsContext *o = optctx;
2947  char *tcr = av_asprintf("timecode=%s", arg);
2948  int ret = parse_option(o, "metadata:g", tcr, options);
2949  if (ret >= 0)
2950  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2951  av_free(tcr);
2952  return 0;
2953 }
2954 
2955 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2956 {
2957  OptionsContext *o = optctx;
2958  char layout_str[32];
2959  char *stream_str;
2960  char *ac_str;
2961  int ret, channels, ac_str_size;
2962  uint64_t layout;
2963 
2964  layout = av_get_channel_layout(arg);
2965  if (!layout) {
2966  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2967  return AVERROR(EINVAL);
2968  }
2969  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2970  ret = opt_default_new(o, opt, layout_str);
2971  if (ret < 0)
2972  return ret;
2973 
2974  /* set 'ac' option based on channel layout */
2975  channels = av_get_channel_layout_nb_channels(layout);
2976  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2977  stream_str = strchr(opt, ':');
2978  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2979  ac_str = av_mallocz(ac_str_size);
2980  if (!ac_str)
2981  return AVERROR(ENOMEM);
2982  av_strlcpy(ac_str, "ac", 3);
2983  if (stream_str)
2984  av_strlcat(ac_str, stream_str, ac_str_size);
2985  ret = parse_option(o, ac_str, layout_str, options);
2986  av_free(ac_str);
2987 
2988  return ret;
2989 }
2990 
2991 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2992 {
2993  OptionsContext *o = optctx;
2994  return parse_option(o, "q:a", arg, options);
2995 }
2996 
2997 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2998 {
3000  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3001  return AVERROR(ENOMEM);
3004  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3005  return AVERROR(ENOMEM);
3006 
3008 
3009  return 0;
3010 }
3011 
3012 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3013 {
3014  uint8_t *graph_desc = read_file(arg);
3015  if (!graph_desc)
3016  return AVERROR(EINVAL);
3017 
3019  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3020  return AVERROR(ENOMEM);
3022  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3023 
3025 
3026  return 0;
3027 }
3028 
3029 void show_help_default(const char *opt, const char *arg)
3030 {
3031  /* per-file options have at least one of those set */
3032  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3033  int show_advanced = 0, show_avoptions = 0;
3034 
3035  if (opt && *opt) {
3036  if (!strcmp(opt, "long"))
3037  show_advanced = 1;
3038  else if (!strcmp(opt, "full"))
3039  show_advanced = show_avoptions = 1;
3040  else
3041  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3042  }
3043 
3044  show_usage();
3045 
3046  printf("Getting help:\n"
3047  " -h -- print basic options\n"
3048  " -h long -- print more options\n"
3049  " -h full -- print all options (including all format and codec specific options, very long)\n"
3050  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3051  " See man %s for detailed description of the options.\n"
3052  "\n", program_name);
3053 
3054  show_help_options(options, "Print help / information / capabilities:",
3055  OPT_EXIT, 0, 0);
3056 
3057  show_help_options(options, "Global options (affect whole program "
3058  "instead of just one file:",
3059  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3060  if (show_advanced)
3061  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3062  per_file | OPT_EXIT, 0);
3063 
3064  show_help_options(options, "Per-file main options:", 0,
3066  OPT_EXIT, per_file);
3067  if (show_advanced)
3068  show_help_options(options, "Advanced per-file options:",
3069  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3070 
3071  show_help_options(options, "Video options:",
3073  if (show_advanced)
3074  show_help_options(options, "Advanced Video options:",
3076 
3077  show_help_options(options, "Audio options:",
3079  if (show_advanced)
3080  show_help_options(options, "Advanced Audio options:",
3082  show_help_options(options, "Subtitle options:",
3083  OPT_SUBTITLE, 0, 0);
3084  printf("\n");
3085 
3086  if (show_avoptions) {
3090 #if CONFIG_SWSCALE
3092 #endif
3095  }
3096 }
3097 
3098 void show_usage(void)
3099 {
3100  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3101  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3102  av_log(NULL, AV_LOG_INFO, "\n");
3103 }
3104 
3105 enum OptGroup {
3108 };
3109 
3110 static const OptionGroupDef groups[] = {
3111  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
3112  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
3113 };
3114 
3115 static int open_files(OptionGroupList *l, const char *inout,
3116  int (*open_file)(OptionsContext*, const char*))
3117 {
3118  int i, ret;
3119 
3120  for (i = 0; i < l->nb_groups; i++) {
3121  OptionGroup *g = &l->groups[i];
3122  OptionsContext o;
3123 
3124  init_options(&o);
3125  o.g = g;
3126 
3127  ret = parse_optgroup(&o, g);
3128  if (ret < 0) {
3129  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3130  "%s.\n", inout, g->arg);
3131  return ret;
3132  }
3133 
3134  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3135  ret = open_file(&o, g->arg);
3136  uninit_options(&o);
3137  if (ret < 0) {
3138  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3139  inout, g->arg);
3140  return ret;
3141  }
3142  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3143  }
3144 
3145  return 0;
3146 }
3147 
3148 int ffmpeg_parse_options(int argc, char **argv)
3149 {
3150  OptionParseContext octx;
3151  uint8_t error[128];
3152  int ret;
3153 
3154  memset(&octx, 0, sizeof(octx));
3155 
3156  /* split the commandline into an internal representation */
3157  ret = split_commandline(&octx, argc, argv, options, groups,
3158  FF_ARRAY_ELEMS(groups));
3159  if (ret < 0) {
3160  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3161  goto fail;
3162  }
3163 
3164  /* apply global options */
3165  ret = parse_optgroup(NULL, &octx.global_opts);
3166  if (ret < 0) {
3167  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3168  goto fail;
3169  }
3170 
3171  /* configure terminal and setup signal handlers */
3172  term_init();
3173 
3174  /* open input files */
3175  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3176  if (ret < 0) {
3177  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3178  goto fail;
3179  }
3180 
3181  /* create the complex filtergraphs */
3182  ret = init_complex_filters();
3183  if (ret < 0) {
3184  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3185  goto fail;
3186  }
3187 
3188  /* open output files */
3189  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3190  if (ret < 0) {
3191  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3192  goto fail;
3193  }
3194 
3195  /* configure the complex filtergraphs */
3196  ret = configure_complex_filters();
3197  if (ret < 0) {
3198  av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3199  goto fail;
3200  }
3201 
3202 fail:
3203  uninit_parse_context(&octx);
3204  if (ret < 0) {
3205  av_strerror(ret, error, sizeof(error));
3206  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3207  }
3208  return ret;
3209 }
3210 
3211 static int opt_progress(void *optctx, const char *opt, const char *arg)
3212 {
3213  AVIOContext *avio = NULL;
3214  int ret;
3215 
3216  if (!strcmp(arg, "-"))
3217  arg = "pipe:";
3218  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3219  if (ret < 0) {
3220  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3221  arg, av_err2str(ret));
3222  return ret;
3223  }
3224  progress_avio = avio;
3225  return 0;
3226 }
3227 
3228 #define OFFSET(x) offsetof(OptionsContext, x)
3229 const OptionDef options[] = {
3230  /* main options */
3231 #include "cmdutils_common_opts.h"
3232  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3233  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3234  "force format", "fmt" },
3235  { "y", OPT_BOOL, { &file_overwrite },
3236  "overwrite output files" },
3237  { "n", OPT_BOOL, { &no_file_overwrite },
3238  "never overwrite output files" },
3239  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3240  "Ignore unknown stream types" },
3241  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3242  "Copy unknown stream types" },
3243  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3244  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3245  "codec name", "codec" },
3246  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3247  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3248  "codec name", "codec" },
3249  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3250  OPT_OUTPUT, { .off = OFFSET(presets) },
3251  "preset name", "preset" },
3252  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3253  OPT_OUTPUT, { .func_arg = opt_map },
3254  "set input stream mapping",
3255  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3256  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3257  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3258  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3259  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3260  "set metadata information of outfile from infile",
3261  "outfile[,metadata]:infile[,metadata]" },
3262  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3263  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3264  "set chapters mapping", "input_file_index" },
3265  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3266  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3267  "record or transcode \"duration\" seconds of audio/video",
3268  "duration" },
3269  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3270  "record or transcode stop time", "time_stop" },
3271  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3272  "set the limit file size in bytes", "limit_size" },
3273  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3274  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3275  "set the start time offset", "time_off" },
3276  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3277  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3278  "set the start time offset relative to EOF", "time_off" },
3279  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3280  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3281  "enable/disable seeking by timestamp with -ss" },
3282  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3283  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3284  "enable/disable accurate seeking with -ss" },
3285  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3286  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3287  "set the input ts offset", "time_off" },
3288  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3289  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3290  "set the input ts scale", "scale" },
3291  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3292  "set the recording timestamp ('now' to set the current time)", "time" },
3293  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3294  "add metadata", "string=string" },
3295  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3296  "add program with specified streams", "title=string:st=number..." },
3297  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3298  OPT_OUTPUT, { .func_arg = opt_data_frames },
3299  "set the number of data frames to output", "number" },
3300  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3301  "add timings for benchmarking" },
3302  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3303  "add timings for each task" },
3304  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3305  "write program-readable progress information", "url" },
3306  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3307  "enable or disable interaction on standard input" },
3308  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3309  "set max runtime in seconds", "limit" },
3310  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3311  "dump each input packet" },
3312  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3313  "when dumping packets, also dump the payload" },
3314  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3315  OPT_INPUT, { .off = OFFSET(rate_emu) },
3316  "read input at native frame rate", "" },
3317  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3318  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3319  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3320  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3321  "video sync method", "" },
3322  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3323  "frame drop threshold", "" },
3324  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3325  "audio sync method", "" },
3326  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3327  "audio drift threshold", "threshold" },
3328  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3329  "copy timestamps" },
3330  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3331  "shift input timestamps to start at 0 when using copyts" },
3332  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3333  "copy input stream time base when stream copying", "mode" },
3334  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3335  OPT_OUTPUT, { .off = OFFSET(shortest) },
3336  "finish encoding within shortest input" },
3337  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3338  OPT_OUTPUT, { .off = OFFSET(apad) },
3339  "audio pad", "" },
3340  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3341  "timestamp discontinuity delta threshold", "threshold" },
3342  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3343  "timestamp error delta threshold", "threshold" },
3344  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3345  "exit on error", "error" },
3346  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3347  "abort on the specified condition flags", "flags" },
3348  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3349  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3350  "copy initial non-keyframes" },
3351  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3352  "copy or discard frames before start time" },
3353  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3354  "set the number of frames to output", "number" },
3355  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3356  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3357  "force codec tag/fourcc", "fourcc/tag" },
3358  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3359  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3360  "use fixed quality scale (VBR)", "q" },
3361  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3362  OPT_OUTPUT, { .func_arg = opt_qscale },
3363  "use fixed quality scale (VBR)", "q" },
3364  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3365  "set profile", "profile" },
3366  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3367  "set stream filtergraph", "filter_graph" },
3368  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3369  "read stream filtergraph description from a file", "filename" },
3370  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3371  "reinit filtergraph on input parameter changes", "" },
3372  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3373  "create a complex filtergraph", "graph_description" },
3374  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3375  "create a complex filtergraph", "graph_description" },
3376  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3377  "read complex filtergraph description from a file", "filename" },
3378  { "stats", OPT_BOOL, { &print_stats },
3379  "print progress report during encoding", },
3380  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3381  OPT_OUTPUT, { .func_arg = opt_attach },
3382  "add an attachment to the output file", "filename" },
3383  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3384  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3385  "extract an attachment into a file", "filename" },
3386  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3387  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3388  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3389  "print timestamp debugging info" },
3390  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3391  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3392  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3393  OPT_INPUT, { .off = OFFSET(discard) },
3394  "discard", "" },
3395  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3396  OPT_OUTPUT, { .off = OFFSET(disposition) },
3397  "disposition", "" },
3398  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3399  { .off = OFFSET(thread_queue_size) },
3400  "set the maximum number of queued packets from the demuxer" },
3401 
3402  /* video options */
3403  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3404  "set the number of video frames to output", "number" },
3405  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3406  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3407  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3409  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3410  "set frame size (WxH or abbreviation)", "size" },
3411  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3412  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3413  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3414  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3415  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3416  "set pixel format", "format" },
3417  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3418  "set the number of bits per raw sample", "number" },
3419  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3420  "deprecated use -g 1" },
3422  "disable video" },
3423  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3424  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3425  "rate control override for specific intervals", "override" },
3426  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3427  OPT_OUTPUT, { .func_arg = opt_video_codec },
3428  "force video codec ('copy' to copy stream)", "codec" },
3429  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3430  "Removed" },
3431  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3432  "Removed" },
3433  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3434  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3435  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3436  "select the pass number (1 to 3)", "n" },
3437  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3438  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3439  "select two pass log file name prefix", "prefix" },
3440  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3441  "this option is deprecated, use the yadif filter instead" },
3442  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3443  "calculate PSNR of compressed frames" },
3444  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3445  "dump video coding statistics to file" },
3446  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3447  "dump video coding statistics to file", "file" },
3448  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3449  "set video filters", "filter_graph" },
3450  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3451  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3452  "specify intra matrix coeffs", "matrix" },
3453  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3454  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3455  "specify inter matrix coeffs", "matrix" },
3456  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3457  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3458  "specify intra matrix coeffs", "matrix" },
3459  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3460  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3461  "top=1/bottom=0/auto=-1 field first", "" },
3462  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3463  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3464  "force video tag/fourcc", "fourcc/tag" },
3465  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3466  "show QP histogram" },
3467  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3468  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3469  "force the selected framerate, disable the best supported framerate selection" },
3470  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3471  OPT_OUTPUT, { .func_arg = opt_streamid },
3472  "set the value of an outfile streamid", "streamIndex:value" },
3473  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3474  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3475  "force key frames at specified timestamps", "timestamps" },
3476  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3477  "audio bitrate (please use -b:a)", "bitrate" },
3478  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3479  "video bitrate (please use -b:v)", "bitrate" },
3480  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3481  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3482  "use HW accelerated decoding", "hwaccel name" },
3483  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3484  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3485  "select a device for HW acceleration", "devicename" },
3486  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3487  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3488  "select output format used with HW accelerated decoding", "format" },
3489 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3490  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3491 #endif
3492  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3493  "show available HW acceleration methods" },
3494  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3495  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3496  "automatically insert correct rotate filters" },
3497  { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3498  "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3499 
3500  /* audio options */
3501  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3502  "set the number of audio frames to output", "number" },
3503  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3504  "set audio quality (codec-specific)", "quality", },
3505  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3506  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3507  "set audio sampling rate (in Hz)", "rate" },
3508  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3509  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3510  "set number of audio channels", "channels" },
3512  "disable audio" },
3513  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3514  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3515  "force audio codec ('copy' to copy stream)", "codec" },
3516  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3517  OPT_OUTPUT, { .func_arg = opt_old2new },
3518  "force audio tag/fourcc", "fourcc/tag" },
3519  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3520  "change audio volume (256=normal)" , "volume" },
3521  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3523  "set sample format", "format" },
3524  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3525  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3526  "set channel layout", "layout" },
3527  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3528  "set audio filters", "filter_graph" },
3529  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3530  "set the maximum number of channels to try to guess the channel layout" },
3531 
3532  /* subtitle options */
3534  "disable subtitle" },
3535  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3536  "force subtitle codec ('copy' to copy stream)", "codec" },
3537  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3538  , "force subtitle tag/fourcc", "fourcc/tag" },
3539  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3540  "fix subtitles duration" },
3541  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3542  "set canvas size (WxH or abbreviation)", "size" },
3543 
3544  /* grab options */
3545  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3546  "deprecated, use -channel", "channel" },
3547  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3548  "deprecated, use -standard", "standard" },
3549  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3550 
3551  /* muxer options */
3552  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3553  "set the maximum demux-decode delay", "seconds" },
3554  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3555  "set the initial demux-decode delay", "seconds" },
3556  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3557  "override the options from ffserver", "" },
3558  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3559  "specify a file in which to print sdp information", "file" },
3560 
3561  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3562  "A comma-separated list of bitstream filters", "bitstream_filters" },
3563  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3564  "deprecated", "audio bitstream_filters" },
3565  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3566  "deprecated", "video bitstream_filters" },
3567 
3568  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3569  "set the audio options to the indicated preset", "preset" },
3570  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3571  "set the video options to the indicated preset", "preset" },
3572  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3573  "set the subtitle options to the indicated preset", "preset" },
3574  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3575  "set options from indicated preset file", "filename" },
3576 
3577  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3578  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3579 
3580  /* data codec support */
3581  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3582  "force data codec ('copy' to copy stream)", "codec" },
3583  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3584  "disable data" },
3585 
3586 #if CONFIG_VAAPI
3587  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3588  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3589 #endif
3590 
3591  { NULL, },
3592 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1543
int nb_bitstream_filters
Definition: ffmpeg.h:424
#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:1995
void show_usage(void)
Definition: ffmpeg_opt.c:3098
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:3375
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:487
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:5796
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:520
void term_init(void)
Definition: ffmpeg.c:368
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:309
int nb_outputs
Definition: ffmpeg.h:257
int copy_tb
Definition: ffmpeg_opt.c:113
AVDictionary * swr_opts
Definition: ffmpeg.h:470
int qp_hist
Definition: ffmpeg_opt.c:118
AVDictionary * swr_opts
Definition: cmdutils.h:286
int resample_channels
Definition: ffmpeg.h:304
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:310
int stream_copy
Definition: ffmpeg.h:475
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:3108
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2794
int do_benchmark
Definition: ffmpeg_opt.c:107
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1592
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1280
AVOption.
Definition: opt.h:245
AVRational frame_rate
Definition: ffmpeg.h:440
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:1956
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:465
static AVInputFormat * file_iformat
Definition: ffplay.c:311
#define OPT_VIDEO
Definition: cmdutils.h:170
int data_disable
Definition: ffmpeg.h:159
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1878
float mux_max_delay
Definition: ffmpeg.h:153
int accurate_seek
Definition: ffmpeg.h:378
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:425
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:296
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:747
AVRational framerate
Definition: ffmpeg.h:293
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:287
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:243
int decoding_needed
Definition: ffmpeg.h:265
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3980
int qscale
Definition: avcodec.h:809
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:956
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
int rotate_overridden
Definition: ffmpeg.h:444
int index
stream index in AVFormatContext
Definition: avformat.h:890
int max_muxing_queue_size
Definition: ffmpeg.h:504
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:2926
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1792
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:1906
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:2087
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:724
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1904
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:2997
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:2853
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1863
enum AVMediaType type
Definition: avcodec.h:3613
int nb_program
Definition: ffmpeg.h:226
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:787
int64_t input_ts_offset
Definition: ffmpeg.h:367
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:3077
int nb_input_streams
Definition: ffmpeg.c:140
static int audio_disable
Definition: ffplay.c:318
const char * name
Definition: ffmpeg.h:73
AVDictionary * metadata
Definition: avformat.h:1299
static const char * audio_codec_name
Definition: ffplay.c:339
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:5752
#define OPT_DOUBLE
Definition: cmdutils.h:185
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1512
#define OPT_FLOAT
Definition: cmdutils.h:173
AVCodec.
Definition: avcodec.h:3600
#define VSYNC_VFR
Definition: ffmpeg.h:54
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1268
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:1983
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3972
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:521
void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c)
int index
Definition: ffmpeg.h:248
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2820
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:426
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:412
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2991
Format I/O context.
Definition: avformat.h:1338
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:460
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1452
int vdpau_init(AVCodecContext *s)
Definition: ffmpeg_vdpau.c:145
int user_set_discard
Definition: ffmpeg.h:264
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:131
static int64_t start_time
Definition: ffplay.c:326
int copy_initial_nonkeyframes
Definition: ffmpeg.h:483
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2446
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:469
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:4046
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:678
#define HAS_ARG
Definition: cmdutils.h:166
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:4127
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:901
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3110
FILE * logfile
Definition: ffmpeg.h:461
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:445
AVDictionary * opts
Definition: ffmpeg.h:518
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:3482
int id
unique ID to identify the chapter
Definition: avformat.h:1296
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2932
int id
Format-specific stream ID.
Definition: avformat.h:896
#define OPT_OFFSET
Definition: cmdutils.h:180
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4193
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:524
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1406
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2766
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:4223
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:132
void av_codec_set_lowres(AVCodecContext *avctx, int val)
int channel_idx
Definition: ffmpeg.h:90
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:689
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int nb_streams
Definition: ffmpeg.h:374
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1449
int sync_file_index
Definition: ffmpeg.h:84
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4289
AVDictionary * resample_opts
Definition: ffmpeg.h:471
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:142
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int resample_sample_rate
Definition: ffmpeg.h:303
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:270
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:204
const OptionDef options[]
Definition: ffmpeg_opt.c:3229
int top_field_first
Definition: ffmpeg.h:294
int nb_output_streams
Definition: ffmpeg.c:145
int file_index
Definition: ffmpeg.h:261
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:208
int resample_pix_fmt
Definition: ffmpeg.h:300
int resample_height
Definition: ffmpeg.h:298
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1500
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:284
#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:810
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2893
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1357
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:3113
AVDictionary * format_opts
Definition: cmdutils.c:72
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1813
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:3614
int rate_emu
Definition: ffmpeg.h:377
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:2908
#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:1554
static int configure_complex_filters(void)
Definition: ffmpeg_opt.c:2009
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:341
FilterGraph ** filtergraphs
Definition: ffmpeg.c:149
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:459
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:3115
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:363
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:422
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:4075
static int autorotate
Definition: ffplay.c:350
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1493
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:3976
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1771
const char * name
Definition: cmdutils.h:164
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2877
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:1544
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:3607
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2868
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:596
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:224
int flags
Definition: cmdutils.h:165
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: ffmpeg_opt.c:497
int force_fps
Definition: ffmpeg.h:442
GLsizei count
Definition: opengl_enc.c:109
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:967
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1265
#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:83
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:2977
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2489
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3998
#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:463
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:4653
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:3148
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:676
AVRational frame_aspect_ratio
Definition: ffmpeg.h:446
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:340
static int subtitle_disable
Definition: ffplay.c:320
int file_index
Definition: ffmpeg.h:82
int nb_audio_channel_maps
Definition: ffmpeg.h:140
int vaapi_decode_init(AVCodecContext *avctx)
Definition: ffmpeg_vaapi.c:411
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1394
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:2920
int nb_output_files
Definition: ffmpeg.c:147
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2660
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:1414
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:833
#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:1506
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:3455
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:3211
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:238
int accurate_seek
Definition: ffmpeg.h:120
int width
picture width / height.
Definition: avcodec.h:1863
static int open_output_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:2020
char * apad
Definition: ffmpeg.h:472
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
int64_t nb_samples
Definition: ffmpeg.h:288
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:364
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:865
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:849
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:150
int qsv_init(AVCodecContext *s)
Definition: ffmpeg_qsv.c:115
int start_frame
Definition: avcodec.h:807
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:431
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:153
int audio_channels_mapped
Definition: ffmpeg.h:458
int n
Definition: avisynth_c.h:684
AVDictionary * metadata
Definition: avformat.h:958
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:249
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)