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