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