FFmpeg  4.2.3
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)) !=
180  printf("%s\n", av_hwdevice_get_type_name(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 {
474  sdp_filename = av_strdup(arg);
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;
492  hw_device_ctx = av_buffer_ref(dev->device_ref);
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)) !=
506  printf("%s\n", av_hwdevice_get_type_name(type));
507  printf("\n");
508  exit_program(0);
509  } else {
510  return hw_device_init_from_string(arg, NULL);
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  }
520  filter_hw_device = hw_device_get_by_name(arg);
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) :
679  avcodec_find_decoder(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;
746  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
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 
785  ret = avcodec_parameters_to_context(ist->dec_ctx, par);
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);
812  if (framerate && av_parse_video_rate(&ist->framerate,
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) {
843  type = av_hwdevice_find_type_by_name(hwaccel);
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: ");
854  type = AV_HWDEVICE_TYPE_NONE;
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 
915  ret = avcodec_parameters_from_context(par, ist->dec_ctx);
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 */
1054  if (file_iformat && file_iformat->priv_class &&
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 */
1063  if (file_iformat && file_iformat->priv_class &&
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)
1082  ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1083  if (audio_codec_name)
1084  ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1085  if (subtitle_codec_name)
1086  ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1087  if (data_codec_name)
1088  ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1089 
1090  ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1091  ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1092  ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
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) */
1127  ret = avformat_find_stream_info(ic, opts);
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;
1204  f->start_time = o->start_time;
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)
1263  dump_attachment(st, o->dump_attachment[i].u.str);
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);
1286  avio_close_dyn_buf(line, &buf);
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"),
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 
1322  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
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);
1327  ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
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;
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 
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;
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 {
1433  }
1434 
1435 
1436  if (o->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) {
1537  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1538  }
1539 
1540  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1541  ost->disposition = av_strdup(ost->disposition);
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)
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  }
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 
1697  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
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)
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)) {
1911  ost->audio_channels_mapped + 1,
1912  sizeof(*ost->audio_channels_map)
1913  ) < 0 )
1914  exit_program(1);
1915 
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 
1979  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
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 :
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");
2242  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
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
2277  && input_streams[i]->st->codecpar->codec_id == codec_id )
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 
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) {
2345  av_log(NULL, AV_LOG_FATAL,
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++) {
2459  OutputStream *ost = 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) {
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;
2621  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
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++) {
2711  ost = output_streams[nb_output_streams - 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 {
2903  vstats_filename = av_strdup (arg);
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 
3105  layout = av_get_channel_layout(arg);
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 */
3116  channels = av_get_channel_layout_nb_channels(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 {
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  return ret;
3276  }
3277 
3278  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3279  ret = open_file(&o, g->arg);
3280  uninit_options(&o);
3281  if (ret < 0) {
3282  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3283  inout, g->arg);
3284  return ret;
3285  }
3286  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3287  }
3288 
3289  return 0;
3290 }
3291 
3292 int ffmpeg_parse_options(int argc, char **argv)
3293 {
3294  OptionParseContext octx;
3295  uint8_t error[128];
3296  int ret;
3297 
3298  memset(&octx, 0, sizeof(octx));
3299 
3300  /* split the commandline into an internal representation */
3301  ret = split_commandline(&octx, argc, argv, options, groups,
3302  FF_ARRAY_ELEMS(groups));
3303  if (ret < 0) {
3304  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3305  goto fail;
3306  }
3307 
3308  /* apply global options */
3309  ret = parse_optgroup(NULL, &octx.global_opts);
3310  if (ret < 0) {
3311  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3312  goto fail;
3313  }
3314 
3315  /* configure terminal and setup signal handlers */
3316  term_init();
3317 
3318  /* open input files */
3319  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3320  if (ret < 0) {
3321  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3322  goto fail;
3323  }
3324 
3325  /* create the complex filtergraphs */
3326  ret = init_complex_filters();
3327  if (ret < 0) {
3328  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3329  goto fail;
3330  }
3331 
3332  /* open output files */
3333  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3334  if (ret < 0) {
3335  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3336  goto fail;
3337  }
3338 
3340 
3341 fail:
3342  uninit_parse_context(&octx);
3343  if (ret < 0) {
3344  av_strerror(ret, error, sizeof(error));
3345  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3346  }
3347  return ret;
3348 }
3349 
3350 static int opt_progress(void *optctx, const char *opt, const char *arg)
3351 {
3352  AVIOContext *avio = NULL;
3353  int ret;
3354 
3355  if (!strcmp(arg, "-"))
3356  arg = "pipe:";
3357  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3358  if (ret < 0) {
3359  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3360  arg, av_err2str(ret));
3361  return ret;
3362  }
3363  progress_avio = avio;
3364  return 0;
3365 }
3366 
3367 #define OFFSET(x) offsetof(OptionsContext, x)
3368 const OptionDef options[] = {
3369  /* main options */
3371  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3372  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3373  "force format", "fmt" },
3374  { "y", OPT_BOOL, { &file_overwrite },
3375  "overwrite output files" },
3376  { "n", OPT_BOOL, { &no_file_overwrite },
3377  "never overwrite output files" },
3378  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3379  "Ignore unknown stream types" },
3380  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3381  "Copy unknown stream types" },
3382  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3383  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3384  "codec name", "codec" },
3385  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3386  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3387  "codec name", "codec" },
3388  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3389  OPT_OUTPUT, { .off = OFFSET(presets) },
3390  "preset name", "preset" },
3391  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3392  OPT_OUTPUT, { .func_arg = opt_map },
3393  "set input stream mapping",
3394  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3395  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3396  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3397  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3398  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3399  "set metadata information of outfile from infile",
3400  "outfile[,metadata]:infile[,metadata]" },
3401  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3402  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3403  "set chapters mapping", "input_file_index" },
3404  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3405  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3406  "record or transcode \"duration\" seconds of audio/video",
3407  "duration" },
3408  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3409  "record or transcode stop time", "time_stop" },
3410  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3411  "set the limit file size in bytes", "limit_size" },
3412  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3413  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3414  "set the start time offset", "time_off" },
3415  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3416  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3417  "set the start time offset relative to EOF", "time_off" },
3418  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3419  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3420  "enable/disable seeking by timestamp with -ss" },
3421  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3422  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3423  "enable/disable accurate seeking with -ss" },
3424  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3425  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3426  "set the input ts offset", "time_off" },
3427  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3428  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3429  "set the input ts scale", "scale" },
3430  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3431  "set the recording timestamp ('now' to set the current time)", "time" },
3432  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3433  "add metadata", "string=string" },
3434  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3435  "add program with specified streams", "title=string:st=number..." },
3436  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3437  OPT_OUTPUT, { .func_arg = opt_data_frames },
3438  "set the number of data frames to output", "number" },
3439  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3440  "add timings for benchmarking" },
3441  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3442  "add timings for each task" },
3443  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3444  "write program-readable progress information", "url" },
3445  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3446  "enable or disable interaction on standard input" },
3447  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3448  "set max runtime in seconds", "limit" },
3449  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3450  "dump each input packet" },
3451  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3452  "when dumping packets, also dump the payload" },
3453  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3454  OPT_INPUT, { .off = OFFSET(rate_emu) },
3455  "read input at native frame rate", "" },
3456  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3457  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3458  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3459  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3460  "video sync method", "" },
3461  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3462  "frame drop threshold", "" },
3463  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3464  "audio sync method", "" },
3465  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3466  "audio drift threshold", "threshold" },
3467  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3468  "copy timestamps" },
3469  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3470  "shift input timestamps to start at 0 when using copyts" },
3471  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3472  "copy input stream time base when stream copying", "mode" },
3473  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3474  OPT_OUTPUT, { .off = OFFSET(shortest) },
3475  "finish encoding within shortest input" },
3476  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3477  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3478  "bitexact mode" },
3479  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3480  OPT_OUTPUT, { .off = OFFSET(apad) },
3481  "audio pad", "" },
3482  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3483  "timestamp discontinuity delta threshold", "threshold" },
3484  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3485  "timestamp error delta threshold", "threshold" },
3486  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3487  "exit on error", "error" },
3488  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3489  "abort on the specified condition flags", "flags" },
3490  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3491  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3492  "copy initial non-keyframes" },
3493  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3494  "copy or discard frames before start time" },
3495  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3496  "set the number of frames to output", "number" },
3497  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3498  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3499  "force codec tag/fourcc", "fourcc/tag" },
3500  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3501  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3502  "use fixed quality scale (VBR)", "q" },
3503  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3504  OPT_OUTPUT, { .func_arg = opt_qscale },
3505  "use fixed quality scale (VBR)", "q" },
3506  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3507  "set profile", "profile" },
3508  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3509  "set stream filtergraph", "filter_graph" },
3510  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3511  "number of non-complex filter threads" },
3512  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3513  "read stream filtergraph description from a file", "filename" },
3514  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3515  "reinit filtergraph on input parameter changes", "" },
3516  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3517  "create a complex filtergraph", "graph_description" },
3518  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3519  "number of threads for -filter_complex" },
3520  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3521  "create a complex filtergraph", "graph_description" },
3522  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3523  "read complex filtergraph description from a file", "filename" },
3524  { "stats", OPT_BOOL, { &print_stats },
3525  "print progress report during encoding", },
3526  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3527  OPT_OUTPUT, { .func_arg = opt_attach },
3528  "add an attachment to the output file", "filename" },
3529  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3530  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3531  "extract an attachment into a file", "filename" },
3532  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3533  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3534  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3535  "print timestamp debugging info" },
3536  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3537  "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3538  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3539  OPT_INPUT, { .off = OFFSET(discard) },
3540  "discard", "" },
3541  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3542  OPT_OUTPUT, { .off = OFFSET(disposition) },
3543  "disposition", "" },
3544  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3545  { .off = OFFSET(thread_queue_size) },
3546  "set the maximum number of queued packets from the demuxer" },
3547  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3548  "read and decode the streams to fill missing information with heuristics" },
3549 
3550  /* video options */
3551  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3552  "set the number of video frames to output", "number" },
3553  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3554  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3555  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3557  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3558  "set frame size (WxH or abbreviation)", "size" },
3559  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3560  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3561  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3562  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3563  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3564  "set pixel format", "format" },
3565  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3566  "set the number of bits per raw sample", "number" },
3567  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3568  "deprecated use -g 1" },
3570  "disable video" },
3571  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3572  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3573  "rate control override for specific intervals", "override" },
3574  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3575  OPT_OUTPUT, { .func_arg = opt_video_codec },
3576  "force video codec ('copy' to copy stream)", "codec" },
3577  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3578  "Removed" },
3579  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3580  "Removed" },
3581  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3582  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3583  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3584  "select the pass number (1 to 3)", "n" },
3585  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3586  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3587  "select two pass log file name prefix", "prefix" },
3588  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3589  "this option is deprecated, use the yadif filter instead" },
3590  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3591  "calculate PSNR of compressed frames" },
3592  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3593  "dump video coding statistics to file" },
3594  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3595  "dump video coding statistics to file", "file" },
3596  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3597  "Version of the vstats format to use."},
3598  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3599  "set video filters", "filter_graph" },
3600  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3601  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3602  "specify intra matrix coeffs", "matrix" },
3603  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3604  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3605  "specify inter matrix coeffs", "matrix" },
3606  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3607  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3608  "specify intra matrix coeffs", "matrix" },
3609  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3610  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3611  "top=1/bottom=0/auto=-1 field first", "" },
3612  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3613  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3614  "force video tag/fourcc", "fourcc/tag" },
3615  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3616  "show QP histogram" },
3617  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3618  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3619  "force the selected framerate, disable the best supported framerate selection" },
3620  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3621  OPT_OUTPUT, { .func_arg = opt_streamid },
3622  "set the value of an outfile streamid", "streamIndex:value" },
3623  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3624  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3625  "force key frames at specified timestamps", "timestamps" },
3626  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3627  "audio bitrate (please use -b:a)", "bitrate" },
3628  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3629  "video bitrate (please use -b:v)", "bitrate" },
3630  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3631  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3632  "use HW accelerated decoding", "hwaccel name" },
3633  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3634  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3635  "select a device for HW acceleration", "devicename" },
3636  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3637  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3638  "select output format used with HW accelerated decoding", "format" },
3639 #if CONFIG_VIDEOTOOLBOX
3640  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3641 #endif
3642  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3643  "show available HW acceleration methods" },
3644  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3645  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3646  "automatically insert correct rotate filters" },
3647 
3648  /* audio options */
3649  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3650  "set the number of audio frames to output", "number" },
3651  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3652  "set audio quality (codec-specific)", "quality", },
3653  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3654  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3655  "set audio sampling rate (in Hz)", "rate" },
3656  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3657  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3658  "set number of audio channels", "channels" },
3660  "disable audio" },
3661  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3662  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3663  "force audio codec ('copy' to copy stream)", "codec" },
3664  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3665  OPT_OUTPUT, { .func_arg = opt_old2new },
3666  "force audio tag/fourcc", "fourcc/tag" },
3667  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3668  "change audio volume (256=normal)" , "volume" },
3669  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3671  "set sample format", "format" },
3672  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3673  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3674  "set channel layout", "layout" },
3675  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3676  "set audio filters", "filter_graph" },
3677  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3678  "set the maximum number of channels to try to guess the channel layout" },
3679 
3680  /* subtitle options */
3682  "disable subtitle" },
3683  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3684  "force subtitle codec ('copy' to copy stream)", "codec" },
3685  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3686  , "force subtitle tag/fourcc", "fourcc/tag" },
3687  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3688  "fix subtitles duration" },
3689  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3690  "set canvas size (WxH or abbreviation)", "size" },
3691 
3692  /* grab options */
3693  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3694  "deprecated, use -channel", "channel" },
3695  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3696  "deprecated, use -standard", "standard" },
3697  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3698 
3699  /* muxer options */
3700  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3701  "set the maximum demux-decode delay", "seconds" },
3702  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3703  "set the initial demux-decode delay", "seconds" },
3704  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3705  "specify a file in which to print sdp information", "file" },
3706 
3707  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3708  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3709  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3710  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3711  "two special values are defined - "
3712  "0 = use frame rate (video) or sample rate (audio),"
3713  "-1 = match source time base", "ratio" },
3714 
3716  "A comma-separated list of bitstream filters", "bitstream_filters" },
3717  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3718  "deprecated", "audio bitstream_filters" },
3719  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3720  "deprecated", "video bitstream_filters" },
3721 
3722  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723  "set the audio options to the indicated preset", "preset" },
3724  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3725  "set the video options to the indicated preset", "preset" },
3726  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3727  "set the subtitle options to the indicated preset", "preset" },
3728  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3729  "set options from indicated preset file", "filename" },
3730 
3731  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3732  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3733 
3734  /* data codec support */
3735  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3736  "force data codec ('copy' to copy stream)", "codec" },
3737  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3738  "disable data" },
3739 
3740 #if CONFIG_VAAPI
3741  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3742  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3743 #endif
3744 
3745 #if CONFIG_QSV
3746  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3747  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3748 #endif
3749 
3750  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3751  "initialise hardware device", "args" },
3752  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3753  "set hardware device used when filtering", "device" },
3754 
3755  { NULL, },
3756 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
int nb_bitstream_filters
Definition: ffmpeg.h:462
const char * name
Definition: avisynth_c.h:867
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:54
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1153
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:414
AVRational enc_timebase
Definition: ffmpeg.h:460
char * vstats_filename
Definition: ffmpeg_opt.c:84
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:45
int nb_dump_attachment
Definition: ffmpeg.h:127
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2080
void show_usage(void)
Definition: ffmpeg_opt.c:3242
int nb_metadata
Definition: ffmpeg.h:168
int nb_streamid_map
Definition: ffmpeg.h:165
#define NULL
Definition: coverity.c:32
int width
Definition: ffmpeg.h:270
AVRational framerate
Definition: avcodec.h:3105
const char const char void * val
Definition: avisynth_c.h:863
int audio_sync_method
Definition: ffmpeg_opt.c:92
AVDictionary * resample_opts
Definition: cmdutils.h:320
int keep_pix_fmt
Definition: ffmpeg.h:528
Bytestream IO Context.
Definition: avio.h:161
float mux_preload
Definition: ffmpeg.h:153
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:514
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5831
#define OPT_EXPERT
Definition: cmdutils.h:163
int start_at_zero
Definition: ffmpeg_opt.c:101
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:558
void term_init(void)
Definition: ffmpeg.c:387
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
int nb_outputs
Definition: ffmpeg.h:292
int copy_tb
Definition: ffmpeg_opt.c:102
static const char * format[]
Definition: af_aiir.c:338
char * qsv_device
Definition: ffmpeg_qsv.c:31
AVDictionary * swr_opts
Definition: ffmpeg.h:509
int qp_hist
Definition: ffmpeg_opt.c:107
AVDictionary * swr_opts
Definition: cmdutils.h:322
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
void term_exit(void)
Definition: ffmpeg.c:328
int stream_copy
Definition: ffmpeg.h:514
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:885
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2935
int do_benchmark
Definition: ffmpeg_opt.c:96
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1636
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1415
AVOption.
Definition: opt.h:246
AVRational frame_rate
Definition: ffmpeg.h:477
int audio_channels
Definition: rtp.c:40
int64_t start_time_eof
Definition: ffmpeg.h:100
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
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c:2055
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:504
static AVInputFormat * file_iformat
Definition: ffplay.c:310
#define OPT_VIDEO
Definition: cmdutils.h:165
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1753
int data_disable
Definition: ffmpeg.h:161
float mux_max_delay
Definition: ffmpeg.h:154
int accurate_seek
Definition: ffmpeg.h:413
int64_t forced_kf_ref_pts
Definition: ffmpeg.h:487
int * streamid_map
Definition: ffmpeg.h:164
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int video_sync_method
Definition: ffmpeg_opt.c:93
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:139
static void assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:923
int ostream_idx
Definition: ffmpeg.h:92
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static int input_sync
Definition: ffmpeg_opt.c:120
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:78
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
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
AVRational framerate
Definition: ffmpeg.h:333
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
enum AVCodecID video_codec
default video codec
Definition: avformat.h:516
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2071
channels
Definition: aptx.c:30
#define OPT_AUDIO
Definition: cmdutils.h:166
int64_t max_pts
Definition: ffmpeg.h:322
enum AVCodecID codec_id
Definition: qsv.c:72
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
AVFilterInOut * out_tmp
Definition: ffmpeg.h:266
int bitexact
Definition: ffmpeg.h:156
int decoding_needed
Definition: ffmpeg.h:300
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int qscale
Definition: avcodec.h:833
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int rotate_overridden
Definition: ffmpeg.h:481
int index
stream index in AVFormatContext
Definition: avformat.h:882
int max_muxing_queue_size
Definition: ffmpeg.h:542
int nb_frame_pix_fmts
Definition: ffmpeg.h:115
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int do_deinterlace
Definition: ffmpeg_opt.c:95
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3067
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1941
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:655
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
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:780
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
Convenience header that includes libavutil&#39;s core.
const char * arg
Definition: cmdutils.h:313
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3138
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
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:537
int cuvid_init(AVCodecContext *s)
Definition: ffmpeg_cuvid.c:30
#define OPT_DATA
Definition: cmdutils.h:172
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2592
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:2012
enum AVMediaType type
Definition: avcodec.h:3494
int nb_program
Definition: ffmpeg.h:228
const char * key
static int file_overwrite
Definition: ffmpeg_opt.c:117
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1352
discard all
Definition: avcodec.h:811
static int find_stream_info
Definition: ffmpeg_opt.c:124
int64_t input_ts_offset
Definition: ffmpeg.h:402
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2796
int nb_input_streams
Definition: ffmpeg.c:148
static int audio_disable
Definition: ffplay.c:319
const char * name
Definition: ffmpeg.h:68
AVDictionary * metadata
Definition: avformat.h:1319
static const char * audio_codec_name
Definition: ffplay.c:344
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1317
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5784
#define OPT_DOUBLE
Definition: cmdutils.h:180
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1556
#define OPT_FLOAT
Definition: cmdutils.h:168
AVCodec.
Definition: avcodec.h:3481
int framerate
Definition: h264_levels.c:65
#define VSYNC_VFR
Definition: ffmpeg.h:52
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1386
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:215
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
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:559
int index
Definition: ffmpeg.h:283
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2961
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:463
Definition: ftp.c:34
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:114
uint8_t base
Definition: vp3data.h:202
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:262
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:47
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:727
int encoding_needed
Definition: ffmpeg.h:447
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3132
Format I/O context.
Definition: avformat.h:1358
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:294
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:480
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:82
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1506
enum HWAccelID id
Definition: ffmpeg.h:70
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:119
const char * name
Definition: opt.h:247
char * logfile_prefix
Definition: ffmpeg.h:499
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1492
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
int user_set_discard
Definition: ffmpeg.h:299
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:122
static int64_t start_time
Definition: ffplay.c:331
int copy_initial_nonkeyframes
Definition: ffmpeg.h:524
int filter_nbthreads
Definition: ffmpeg_opt.c:111
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:524
uint8_t
static int nb_streams
Definition: ffprobe.c:280
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:508
Opaque data information usually continuous.
Definition: avutil.h:203
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:545
#define OPT_OUTPUT
Definition: cmdutils.h:182
int width
Video only.
Definition: avcodec.h:4023
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:668
#define HAS_ARG
Definition: cmdutils.h:161
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2019
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:998
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3254
FILE * logfile
Definition: ffmpeg.h:500
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:471
#define f(width, name)
Definition: cbs_vp9.c:255
AVDictionary * opts
Definition: ffmpeg.h:556
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:3204
int id
unique ID to identify the chapter
Definition: avformat.h:1316
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3073
#define AVCONV_DATADIR
Definition: config.h:8
int id
Format-specific stream ID.
Definition: avformat.h:888
#define OPT_OFFSET
Definition: cmdutils.h:175
int vstats_version
Definition: ffmpeg_opt.c:113
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4476
int nb_max_frames
Definition: ffmpeg.h:170
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
int shortest
Definition: ffmpeg.h:562
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2907
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:2115
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
int channel_idx
Definition: ffmpeg.h:91
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:679
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int nb_streams
Definition: ffmpeg.h:409
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
int sync_file_index
Definition: ffmpeg.h:85
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4575
AVDictionary * resample_opts
Definition: ffmpeg.h:510
int seek_timestamp
Definition: ffmpeg.h:101
uint32_t tag
Definition: movenc.c:1496
int * formats
Definition: ffmpeg.h:277
#define OPT_SPEC
Definition: cmdutils.h:176
int nb_input_files
Definition: ffmpeg.c:150
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2804
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:168
int init_complex_filtergraph(FilterGraph *fg)
int print_stats
Definition: ffmpeg_opt.c:106
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
AVCodec * dec
Definition: ffmpeg.h:305
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
const OptionDef options[]
Definition: ffmpeg_opt.c:3368
int top_field_first
Definition: ffmpeg.h:334
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
int nb_output_streams
Definition: ffmpeg.c:153
int file_index
Definition: ffmpeg.h:296
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1544
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:319
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:250
float quality_factor
Definition: avcodec.h:834
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3034
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2136
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:913
AVDictionary * format_opts
Definition: cmdutils.c:73
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1962
#define OPT_SUBTITLE
Definition: cmdutils.h:169
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:571
uint64_t channel_layout
Definition: ffmpeg.h:274
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:112
enum AVCodecID id
Definition: avcodec.h:3495
int rate_emu
Definition: ffmpeg.h:412
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3049
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
void check_filter_outputs(void)
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:374
FilterGraph ** filtergraphs
Definition: ffmpeg.c:157
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:481
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:3259
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:256
int nb_filters
Definition: ffmpeg.h:204
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:291
int64_t start_time
Definition: ffmpeg.h:99
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:232
int loop
Definition: ffmpeg.h:398
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:457
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:652
int ofile_idx
Definition: ffmpeg.h:92
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1185
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1370
char * url
input or output URL.
Definition: avformat.h:1454
int video_delay
Video only.
Definition: avcodec.h:4052
static int autorotate
Definition: ffplay.c:355
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1537
AudioChannelMap * audio_channel_maps
Definition: ffmpeg.h:140
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int debug_ts
Definition: ffmpeg_opt.c:103
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
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
const char * name
Definition: cmdutils.h:159
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3018
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:350
AVChapter ** chapters
Definition: avformat.h:1588
Definition: graph2dot.c:48
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as &#39;arg&#39; parameter.
Definition: ffmpeg_opt.c:535
simple assert() macros that are a bit more flexible than ISO C assert().
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
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
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
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
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3009
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:637
int video_disable
Definition: ffmpeg.h:158
static int opt_sameq(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:223
int flags
Definition: cmdutils.h:160
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: ffmpeg_opt.c:562
int force_fps
Definition: ffmpeg.h:479
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1275
#define FFMAX(a, b)
Definition: common.h:94
static void uninit_options(OptionsContext *o)
Definition: ffmpeg_opt.c:126
StreamMap * stream_maps
Definition: ffmpeg.h:138
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:120
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:149
uint64_t limit_filesize
Definition: ffmpeg.h:152
AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1835
const char * format
Definition: ffmpeg.h:102
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
#define pass
Definition: fft_template.c:619
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:638
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
OutputFilter * filter
Definition: ffmpeg.h:502
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:4996
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:3292
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:732
AVRational frame_aspect_ratio
Definition: ffmpeg.h:484
static AVDictionary * strip_specifiers(AVDictionary *dict)
Definition: ffmpeg_opt.c:188
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:205
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1608
static const char * subtitle_codec_name
Definition: ffplay.c:345
static int subtitle_disable
Definition: ffplay.c:321
int file_index
Definition: ffmpeg.h:83
int nb_audio_channel_maps
Definition: ffmpeg.h:141
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int nb_attachments
Definition: ffmpeg.h:146
AVDictionary * opts
Definition: movenc.c:50
OptionGroup * groups
Definition: cmdutils.h:332
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3061
int nb_output_files
Definition: ffmpeg.c:155
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2435
size_t off
Definition: cmdutils.h:186
char * linklabel
Definition: ffmpeg.h:87
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:77
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:908
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:850
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
#define FFMIN(a, b)
Definition: common.h:96
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1550
SpecifierOpt * audio_channels
Definition: ffmpeg.h:106
uint64_t * channel_layouts
Definition: ffmpeg.h:278
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
Definition: ffmpeg_opt.c:711
#define VSYNC_AUTO
Definition: ffmpeg.h:49
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1450
int nb_audio_sample_rate
Definition: ffmpeg.h:109
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:156
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
static int opt_progress(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3350
int exit_on_error
Definition: ffmpeg_opt.c:104
int metadata_chapters_manual
Definition: ffmpeg.h:144
struct OutputStream * ost
Definition: ffmpeg.h:261
int accurate_seek
Definition: ffmpeg.h:121
int width
picture width / height.
Definition: avcodec.h:1738
static int open_output_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:2109
char * apad
Definition: ffmpeg.h:511
int64_t nb_samples
Definition: ffmpeg.h:328
SpecifierOpt * audio_sample_rate
Definition: ffmpeg.h:108
char * sdp_filename
Definition: ffmpeg_opt.c:85
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
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
int64_t duration
Definition: ffmpeg.h:399
const char * name
Definition: avformat.h:505
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:887
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871
SpecifierOpt * dump_attachment
Definition: ffmpeg.h:126
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:329
int copy_ts
Definition: ffmpeg_opt.c:100
#define OPT_EXIT
Definition: cmdutils.h:171
static AVCodec * find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
Definition: ffmpeg_opt.c:667
int nb_filtergraphs
Definition: ffmpeg.c:158
int qsv_init(AVCodecContext *s)
Definition: ffmpeg_qsv.c:71
int start_frame
Definition: avcodec.h:831
float frame_drop_threshold
Definition: ffmpeg_opt.c:94
SpecifierOpt * metadata_map
Definition: ffmpeg.h:195
#define s(width, name)
Definition: cbs_vp9.c:257
static int open_file(AVFormatContext *avf, unsigned fileno)
Definition: concatdec.c:332
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:290
#define OPT_INT64
Definition: cmdutils.h:170
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:80
int64_t max_frames
Definition: ffmpeg.h:468
#define AV_RL32
Definition: intreadwrite.h:146
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:147
int audio_channels_mapped
Definition: ffmpeg.h:497
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:945
int height
Definition: ffmpeg.h:270
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
Opaque data information usually sparse.
Definition: avutil.h:205
static void init_options(OptionsContext *o)
Definition: ffmpeg_opt.c:158
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:144
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:1068
SpecifierOpt * frame_sizes
Definition: ffmpeg.h:112
int stream_idx
Definition: ffmpeg.h:91
#define is(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:274
if(ret< 0)
Definition: vf_mcdeint.c:279
int sample_rate
Definition: ffmpeg.h:273
HW acceleration through CUDA.
Definition: pixfmt.h:235
static void error(const char *err)
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3272
int do_hex_dump
Definition: ffmpeg_opt.c:98
HWDevice * filter_hw_device
Definition: ffmpeg_opt.c:82
RcOverride * rc_override
Definition: avcodec.h:2436
#define FF_ARRAY_ELEMS(a)
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:849
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1166
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:136
AVCodecContext * enc
Definition: muxing.c:55
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
HWDevice * hw_device_get_by_name(const char *name)
Definition: ffmpeg_hw.c:42
int do_pkt_dump
Definition: ffmpeg_opt.c:99
uint8_t * str
Definition: cmdutils.h:149
Stream structure.
Definition: avformat.h:881
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1635
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1003
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1318
int fix_sub_duration
Definition: ffmpeg.h:339
#define VSYNC_DROP
Definition: ffmpeg.h:54
int64_t recording_time
Definition: ffmpeg.h:408
int do_benchmark_all
Definition: ffmpeg_opt.c:97
Definition: ffmpeg.h:67
SpecifierOpt * frame_rates
Definition: ffmpeg.h:110
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:826
AVStream * st
Definition: ffmpeg.h:297
union SpecifierOpt::@22 u
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int frame_size
Definition: mxfenc.c:2215
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg.h:365
int file_idx
Definition: ffmpeg.h:91
int abort_on_flags
Definition: ffmpeg_opt.c:105
int ost_index
Definition: ffmpeg.h:557
struct InputStream * sync_ist
Definition: ffmpeg.h:451
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1573
double ts_scale
Definition: ffmpeg.h:330
int64_t recording_time
Definition: ffmpeg.h:150
int chapters_input_file
Definition: ffmpeg.h:148
int64_t stop_time
Definition: ffmpeg.h:151
static int intra_only
Definition: ffmpeg_opt.c:116
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
int stdin_interaction
Definition: ffmpeg_opt.c:108
int sample_rate
samples per second
Definition: avcodec.h:2225
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
AVFifoBuffer * muxing_queue
Definition: ffmpeg.h:545
#define SET_DICT(type, meta, context, index)
int ist_index
Definition: ffmpeg.h:397
static int loop
Definition: ffplay.c:340
const char * graph_desc
Definition: ffmpeg.h:284
int guess_layout_max
Definition: ffmpeg.h:335
int64_t start_time
Definition: ffmpeg.h:406
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:279
main external API structure.
Definition: avcodec.h:1565
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:890
int rate_emu
Definition: ffmpeg.h:120
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:327
int * sample_rates
Definition: ffmpeg.h:279
int metadata_streams_manual
Definition: ffmpeg.h:143
const char * attachment_filename
Definition: ffmpeg.h:523
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
a very simple circular buffer FIFO implementation
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: avcodec.h:775
AVRational time_base
Definition: ffmpeg.h:401
void assert_avoptions(AVDictionary *m)
Definition: ffmpeg.c:646
AVCodecContext * enc_ctx
Definition: ffmpeg.h:465
int audio_disable
Definition: ffmpeg.h:159
void * buf
Definition: avisynth_c.h:766
int64_t input_ts_offset
Definition: ffmpeg.h:118
float audio_drift_threshold
Definition: ffmpeg_opt.c:87
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:3170
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:2065
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:394
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
double value
Definition: eval.c:98
int * audio_channels_map
Definition: ffmpeg.h:496
int coded_height
Definition: avcodec.h:1753
#define VSYNC_PASSTHROUGH
Definition: ffmpeg.h:50
Describe the class of an AVClass context structure.
Definition: log.h:67
#define NTSC
Definition: bktr.c:67
OutputStream ** output_streams
Definition: ffmpeg.c:152
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:88
int index
Definition: gxfenc.c:89
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3153
static char * get_ost_filters(OptionsContext *o, AVFormatContext *oc, OutputStream *ost)
Definition: ffmpeg_opt.c:1619
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:517
option
Definition: libkvazaar.c:291
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int file_index
Definition: ffmpeg.h:443
int metadata_global_manual
Definition: ffmpeg.h:142
#define ABORT_ON_FLAG_EMPTY_OUTPUT
Definition: ffmpeg.h:433
double rotate_override_value
Definition: ffmpeg.h:482
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:2058
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
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
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
AVCodecContext * dec_ctx
Definition: ffmpeg.h:304
#define OPT_STRING
Definition: cmdutils.h:164
char * disposition
Definition: ffmpeg.h:526
cl_device_type type
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:222
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
AVMediaType
Definition: avutil.h:199
static OutputStream * new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1853
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
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:498
AVDictionary * decoder_opts
Definition: ffmpeg.h:332
const VDPAUPixFmtMap * map
int shortest
Definition: ffmpeg.h:155
#define MAX_STREAMS
Definition: ffmpeg.h:56
int autorotate
Definition: ffmpeg.h:337
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:724
#define snprintf
Definition: snprintf.h:34
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
int64_t ts_offset
Definition: ffmpeg.h:404
char * filters_script
filtergraph script associated to the -filter_script option
Definition: ffmpeg.h:505
int audio_volume
Definition: ffmpeg_opt.c:91
misc parsing utilities
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
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:2074
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3096
int end_frame
Definition: avcodec.h:832
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:2544
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:244
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:716
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
enum AVPixelFormat hwaccel_output_format
Definition: ffmpeg.h:367
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2900
char * name
unique name for this input/output in the list
Definition: avfilter.h:1005
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:473
int nb_audio_channels
Definition: ffmpeg.h:107
#define OPT_TIME
Definition: cmdutils.h:179
int source_index
Definition: ffmpeg.h:445
static int init_complex_filters(void)
Definition: ffmpeg_opt.c:2097
AVDictionary * metadata
Definition: avformat.h:1281
int copy_prior_start
Definition: ffmpeg.h:525
SpecifierOpt * metadata
Definition: ffmpeg.h:167
static AVCodec * choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
Definition: ffmpeg_opt.c:696
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1631
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
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:918
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static OutputStream * new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1653
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:386
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
Definition: ffmpeg_opt.c:1573
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1463
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:499
AVBufferRef * hw_device_ctx
Definition: ffmpeg_opt.c:81
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:904
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
#define OFFSET(x)
Definition: ffmpeg_opt.c:3367
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2923
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
int64_t start
Definition: avformat.h:1318
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1760
OSTFinished finished
Definition: ffmpeg.h:512
char * forced_keyframes
Definition: ffmpeg.h:491
int nb_frame_rates
Definition: ffmpeg.h:111
#define OPT_BOOL
Definition: cmdutils.h:162
A reference to a data buffer.
Definition: buffer.h:81
float dts_error_threshold
Definition: ffmpeg_opt.c:89
static AVStream * ost
Main libavformat public API header.
static uint8_t * get_line(AVIOContext *s)
Definition: ffmpeg_opt.c:1272
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
preset
Definition: vf_curves.c:46
int
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
Definition: ffmpeg_opt.c:1291
static uint8_t * read_file(const char *filename)
Definition: ffmpeg_opt.c:1591
uint64_t limit_filesize
Definition: ffmpeg.h:560
#define OPT_INT
Definition: cmdutils.h:167
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2757
AVDictionary * codec_opts
Definition: cmdutils.c:73
AVIOContext * progress_avio
Definition: ffmpeg.c:143
AVDictionary * format_opts
Definition: cmdutils.h:319
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:238
SpecifierOpt * program
Definition: ffmpeg.h:227
int reinit_filters
Definition: ffmpeg.h:361
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
int nb_frame_sizes
Definition: ffmpeg.h:113
OptionGroupList * groups
Definition: cmdutils.h:339
AVCodecParameters * ref_par
Definition: ffmpeg.h:466
OptionGroup * g
Definition: ffmpeg.h:96
#define VSYNC_CFR
Definition: ffmpeg.h:51
static int video_disable
Definition: ffplay.c:320
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3584
AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1827
static double c[64]
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
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:472
AVStream * st
Definition: muxing.c:54
AVBufferRef * device_ref
Definition: ffmpeg.h:77
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
OptionGroup global_opts
Definition: cmdutils.h:337
const char ** attachments
Definition: ffmpeg.h:145
#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 poi...
Definition: opt.h:565
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1317
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4448
AVFormatContext * ctx
Definition: ffmpeg.h:394
int stream_index
Definition: ffmpeg.h:84
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
union OptionDef::@23 u
int nb_metadata_map
Definition: ffmpeg.h:196
int frame_bits_per_raw_sample
Definition: ffmpeg_opt.c:109
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:97
enum AVCodecID id
Definition: avcodec.h:717
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:622
pixel format definitions
AVHWDeviceType
Definition: hwcontext.h:27
char * avfilter
Definition: ffmpeg.h:503
#define av_free(p)
enum AVCodecID data_codec_id
Forced Data codec_id.
Definition: avformat.h:1889
char * value
Definition: dict.h:87
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1843
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
int len
static int opt_timecode(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3085
static void dump_attachment(AVStream *st, const char *filename)
Definition: ffmpeg_opt.c:966
int channels
number of audio channels
Definition: avcodec.h:2226
AVCodec * data_codec
Forced data codec.
Definition: avformat.h:1851
OptGroup
Definition: ffmpeg_opt.c:3249
int top_field_first
Definition: ffmpeg.h:480
OutputFilter ** outputs
Definition: ffmpeg.h:291
static const struct PPFilter filters[]
Definition: postprocess.c:134
InputFile ** input_files
Definition: ffmpeg.c:149
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1096
SpecifierOpt * max_frames
Definition: ffmpeg.h:169
int disabled
Definition: ffmpeg.h:82
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
AVRational frame_rate
Definition: ffmpeg.h:271
#define PAL
Definition: bktr.c:65
AVFormatContext * ctx
Definition: ffmpeg.h:555
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:172
int hw_device_init_from_string(const char *arg, HWDevice **dev)
Definition: ffmpeg_hw.c:92
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1990
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
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc, const OutputStream *ost, enum AVMediaType type)
Definition: ffmpeg_opt.c:1639
uint64_t layout
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
int thread_queue_size
Definition: ffmpeg.h:122
int channels
Audio only.
Definition: avcodec.h:4063
char * hwaccel_device
Definition: ffmpeg.h:366
AVDictionary * encoder_opts
Definition: ffmpeg.h:507
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
float max_error_rate
Definition: ffmpeg_opt.c:110
AVDictionary * codec_opts
Definition: cmdutils.h:318
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1473
static const AVBitStreamFilter *const bitstream_filters[]
Definition: bsf_list.c:1
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
static const char * video_codec_name
Definition: ffplay.c:346
FILE * out
Definition: movenc.c:54
float dts_delta_threshold
Definition: ffmpeg_opt.c:88
char * videotoolbox_pixfmt
#define av_freep(p)
void INT64 INT64 count
Definition: avisynth_c.h:766
void INT64 start
Definition: avisynth_c.h:766
int sync_stream_index
Definition: ffmpeg.h:86
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static int input_stream_potentially_available
Definition: ffmpeg_opt.c:121
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)
Definition: ffmpeg_opt.c:59
OutputFile ** output_files
Definition: ffmpeg.c:154
#define DEFAULT_PASS_LOGFILENAME_PREFIX
Definition: ffmpeg_opt.c:45
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2941
const HWAccel hwaccels[]
Definition: ffmpeg_opt.c:69
static int no_file_overwrite
Definition: ffmpeg_opt.c:118
int format
Definition: ffmpeg.h:272
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
int64_t min_pts
Definition: ffmpeg.h:321
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2450
int discard
Definition: ffmpeg.h:298
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:268
#define OPT_PERFILE
Definition: cmdutils.h:173
AVDictionary * sws_dict
Definition: cmdutils.h:321
#define OPT_INPUT
Definition: cmdutils.h:181
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:364
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2929
#define MKTAG(a, b, c, d)
Definition: common.h:366
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:936
#define DECODING_FOR_OST
Definition: ffmpeg.h:301
int index
Definition: ffmpeg.h:444
static OutputStream * new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1954
enum AVMediaType type
Definition: ffmpeg.h:267
This structure stores compressed data.
Definition: avcodec.h:1454
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
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:109
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVProgram ** programs
Definition: avformat.h:1538
#define AVFMT_NEEDNUMBER
Needs &#39;d&#39; in filename.
Definition: avformat.h:464
InputStream ** input_streams
Definition: ffmpeg.c:147
discard nothing
Definition: avcodec.h:805
int videotoolbox_init(AVCodecContext *s)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
int subtitle_disable
Definition: ffmpeg.h:160
static int copy_unknown_streams
Definition: ffmpeg_opt.c:123
static OutputStream * new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1928
static uint8_t tmp[11]
Definition: aes_ctr.c:26