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