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