FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "ffmpeg.h"
24 #include "cmdutils.h"
25 
26 #include "libavformat/avformat.h"
27 
28 #include "libavcodec/avcodec.h"
29 
30 #include "libavfilter/avfilter.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
45 {\
46  int i, ret;\
47  for (i = 0; i < o->nb_ ## name; i++) {\
48  char *spec = o->name[i].specifier;\
49  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50  outvar = o->name[i].u.type;\
51  else if (ret < 0)\
52  exit_program(1);\
53  }\
54 }
55 
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
57 {\
58  int i;\
59  for (i = 0; i < o->nb_ ## name; i++) {\
60  char *spec = o->name[i].specifier;\
61  if (!strcmp(spec, mediatype))\
62  outvar = o->name[i].u.type;\
63  }\
64 }
66 
69 float dts_error_threshold = 3600*30;
70 
71 int audio_volume = 256;
75 int do_benchmark = 0;
77 int do_hex_dump = 0;
78 int do_pkt_dump = 0;
79 int copy_ts = 0;
80 int copy_tb = -1;
81 int debug_ts = 0;
82 int exit_on_error = 0;
83 int print_stats = -1;
84 int qp_hist = 0;
87 
88 
89 static int intra_only = 0;
90 static int file_overwrite = 0;
91 static int no_file_overwrite = 0;
92 static int video_discard = 0;
93 static int intra_dc_precision = 8;
94 static int do_psnr = 0;
95 static int input_sync;
96 static int override_ffserver = 0;
97 
98 static int64_t recording_time = INT64_MAX;
99 
100 static void uninit_options(OptionsContext *o, int is_input)
101 {
102  const OptionDef *po = options;
103  int i;
104 
105  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106  while (po->name) {
107  void *dst = (uint8_t*)o + po->u.off;
108 
109  if (po->flags & OPT_SPEC) {
110  SpecifierOpt **so = dst;
111  int i, *count = (int*)(so + 1);
112  for (i = 0; i < *count; i++) {
113  av_freep(&(*so)[i].specifier);
114  if (po->flags & OPT_STRING)
115  av_freep(&(*so)[i].u.str);
116  }
117  av_freep(so);
118  *count = 0;
119  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
120  av_freep(dst);
121  po++;
122  }
123 
124  for (i = 0; i < o->nb_stream_maps; i++)
126  av_freep(&o->stream_maps);
128  av_freep(&o->streamid_map);
129  av_freep(&o->attachments);
130 
131  if (is_input)
133  else
134  recording_time = INT64_MAX;
135 }
136 
137 static void init_options(OptionsContext *o, int is_input)
138 {
139  memset(o, 0, sizeof(*o));
140 
141  if (!is_input && recording_time != INT64_MAX) {
143  av_log(NULL, AV_LOG_WARNING,
144  "-t is not an input option, keeping it for the next output;"
145  " consider fixing your command line.\n");
146  } else
147  o->recording_time = INT64_MAX;
148  o->stop_time = INT64_MAX;
149  o->mux_max_delay = 0.7;
150  o->limit_filesize = UINT64_MAX;
151  o->chapters_input_file = INT_MAX;
152 }
153 
154 /* return a copy of the input with the stream specifiers removed from the keys */
156 {
157  AVDictionaryEntry *e = NULL;
158  AVDictionary *ret = NULL;
159 
160  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
161  char *p = strchr(e->key, ':');
162 
163  if (p)
164  *p = 0;
165  av_dict_set(&ret, e->key, e->value, 0);
166  if (p)
167  *p = ':';
168  }
169  return ret;
170 }
171 
172 static int opt_sameq(void *optctx, const char *opt, const char *arg)
173 {
174  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
175  "If you are looking for an option to preserve the quality (which is not "
176  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
177  opt, opt);
178  return AVERROR(EINVAL);
179 }
180 
181 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
182 {
183  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
184  return opt_default(optctx, "channel", arg);
185 }
186 
187 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
188 {
189  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
190  return opt_default(optctx, "standard", arg);
191 }
192 
193 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
194 {
195  OptionsContext *o = optctx;
196  return parse_option(o, "codec:a", arg, options);
197 }
198 
199 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
200 {
201  OptionsContext *o = optctx;
202  return parse_option(o, "codec:v", arg, options);
203 }
204 
205 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
206 {
207  OptionsContext *o = optctx;
208  return parse_option(o, "codec:s", arg, options);
209 }
210 
211 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
212 {
213  OptionsContext *o = optctx;
214  return parse_option(o, "codec:d", arg, options);
215 }
216 
217 static int opt_map(void *optctx, const char *opt, const char *arg)
218 {
219  OptionsContext *o = optctx;
220  StreamMap *m = NULL;
221  int i, negative = 0, file_idx;
222  int sync_file_idx = -1, sync_stream_idx = 0;
223  char *p, *sync;
224  char *map;
225 
226  if (*arg == '-') {
227  negative = 1;
228  arg++;
229  }
230  map = av_strdup(arg);
231 
232  /* parse sync stream first, just pick first matching stream */
233  if (sync = strchr(map, ',')) {
234  *sync = 0;
235  sync_file_idx = strtol(sync + 1, &sync, 0);
236  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
237  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
238  exit_program(1);
239  }
240  if (*sync)
241  sync++;
242  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
243  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
244  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
245  sync_stream_idx = i;
246  break;
247  }
248  if (i == input_files[sync_file_idx]->nb_streams) {
249  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
250  "match any streams.\n", arg);
251  exit_program(1);
252  }
253  }
254 
255 
256  if (map[0] == '[') {
257  /* this mapping refers to lavfi output */
258  const char *c = map + 1;
260  m = &o->stream_maps[o->nb_stream_maps - 1];
261  m->linklabel = av_get_token(&c, "]");
262  if (!m->linklabel) {
263  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
264  exit_program(1);
265  }
266  } else {
267  file_idx = strtol(map, &p, 0);
268  if (file_idx >= nb_input_files || file_idx < 0) {
269  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
270  exit_program(1);
271  }
272  if (negative)
273  /* disable some already defined maps */
274  for (i = 0; i < o->nb_stream_maps; i++) {
275  m = &o->stream_maps[i];
276  if (file_idx == m->file_index &&
279  *p == ':' ? p + 1 : p) > 0)
280  m->disabled = 1;
281  }
282  else
283  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
284  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
285  *p == ':' ? p + 1 : p) <= 0)
286  continue;
288  m = &o->stream_maps[o->nb_stream_maps - 1];
289 
290  m->file_index = file_idx;
291  m->stream_index = i;
292 
293  if (sync_file_idx >= 0) {
294  m->sync_file_index = sync_file_idx;
295  m->sync_stream_index = sync_stream_idx;
296  } else {
297  m->sync_file_index = file_idx;
298  m->sync_stream_index = i;
299  }
300  }
301  }
302 
303  if (!m) {
304  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
305  exit_program(1);
306  }
307 
308  av_freep(&map);
309  return 0;
310 }
311 
312 static int opt_attach(void *optctx, const char *opt, const char *arg)
313 {
314  OptionsContext *o = optctx;
316  o->attachments[o->nb_attachments - 1] = arg;
317  return 0;
318 }
319 
320 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
321 {
322  OptionsContext *o = optctx;
323  int n;
324  AVStream *st;
326 
329 
330  /* muted channel syntax */
331  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
332  if ((n == 1 || n == 3) && m->channel_idx == -1) {
333  m->file_idx = m->stream_idx = -1;
334  if (n == 1)
335  m->ofile_idx = m->ostream_idx = -1;
336  return 0;
337  }
338 
339  /* normal syntax */
340  n = sscanf(arg, "%d.%d.%d:%d.%d",
341  &m->file_idx, &m->stream_idx, &m->channel_idx,
342  &m->ofile_idx, &m->ostream_idx);
343 
344  if (n != 3 && n != 5) {
345  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
346  "[file.stream.channel|-1][:syncfile:syncstream]\n");
347  exit_program(1);
348  }
349 
350  if (n != 5) // only file.stream.channel specified
351  m->ofile_idx = m->ostream_idx = -1;
352 
353  /* check input */
354  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
355  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
356  m->file_idx);
357  exit_program(1);
358  }
359  if (m->stream_idx < 0 ||
361  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
362  m->file_idx, m->stream_idx);
363  exit_program(1);
364  }
365  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
366  if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
367  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
368  m->file_idx, m->stream_idx);
369  exit_program(1);
370  }
371  if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
372  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
373  m->file_idx, m->stream_idx, m->channel_idx);
374  exit_program(1);
375  }
376  return 0;
377 }
378 
379 /**
380  * Parse a metadata specifier passed as 'arg' parameter.
381  * @param arg metadata string to parse
382  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
383  * @param index for type c/p, chapter/program index is written here
384  * @param stream_spec for type s, the stream specifier is written here
385  */
386 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
387 {
388  if (*arg) {
389  *type = *arg;
390  switch (*arg) {
391  case 'g':
392  break;
393  case 's':
394  if (*(++arg) && *arg != ':') {
395  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
396  exit_program(1);
397  }
398  *stream_spec = *arg == ':' ? arg + 1 : "";
399  break;
400  case 'c':
401  case 'p':
402  if (*(++arg) == ':')
403  *index = strtol(++arg, NULL, 0);
404  break;
405  default:
406  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
407  exit_program(1);
408  }
409  } else
410  *type = 'g';
411 }
412 
413 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
414 {
415  AVDictionary **meta_in = NULL;
416  AVDictionary **meta_out = NULL;
417  int i, ret = 0;
418  char type_in, type_out;
419  const char *istream_spec = NULL, *ostream_spec = NULL;
420  int idx_in = 0, idx_out = 0;
421 
422  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
423  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
424 
425  if (!ic) {
426  if (type_out == 'g' || !*outspec)
427  o->metadata_global_manual = 1;
428  if (type_out == 's' || !*outspec)
430  if (type_out == 'c' || !*outspec)
432  return 0;
433  }
434 
435  if (type_in == 'g' || type_out == 'g')
436  o->metadata_global_manual = 1;
437  if (type_in == 's' || type_out == 's')
439  if (type_in == 'c' || type_out == 'c')
441 
442  /* ic is NULL when just disabling automatic mappings */
443  if (!ic)
444  return 0;
445 
446 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
447  if ((index) < 0 || (index) >= (nb_elems)) {\
448  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
449  (desc), (index));\
450  exit_program(1);\
451  }
452 
453 #define SET_DICT(type, meta, context, index)\
454  switch (type) {\
455  case 'g':\
456  meta = &context->metadata;\
457  break;\
458  case 'c':\
459  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
460  meta = &context->chapters[index]->metadata;\
461  break;\
462  case 'p':\
463  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
464  meta = &context->programs[index]->metadata;\
465  break;\
466  case 's':\
467  break; /* handled separately below */ \
468  default: av_assert0(0);\
469  }\
470 
471  SET_DICT(type_in, meta_in, ic, idx_in);
472  SET_DICT(type_out, meta_out, oc, idx_out);
473 
474  /* for input streams choose first matching stream */
475  if (type_in == 's') {
476  for (i = 0; i < ic->nb_streams; i++) {
477  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
478  meta_in = &ic->streams[i]->metadata;
479  break;
480  } else if (ret < 0)
481  exit_program(1);
482  }
483  if (!meta_in) {
484  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
485  exit_program(1);
486  }
487  }
488 
489  if (type_out == 's') {
490  for (i = 0; i < oc->nb_streams; i++) {
491  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
492  meta_out = &oc->streams[i]->metadata;
493  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
494  } else if (ret < 0)
495  exit_program(1);
496  }
497  } else
498  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
499 
500  return 0;
501 }
502 
503 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
504 {
505  OptionsContext *o = optctx;
506  char buf[128];
507  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
508  struct tm time = *gmtime((time_t*)&recording_timestamp);
509  strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
510  parse_option(o, "metadata", buf, options);
511 
512  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
513  "tag instead.\n", opt);
514  return 0;
515 }
516 
517 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
518 {
519  const AVCodecDescriptor *desc;
520  const char *codec_string = encoder ? "encoder" : "decoder";
521  AVCodec *codec;
522 
523  codec = encoder ?
526 
527  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
528  codec = encoder ? avcodec_find_encoder(desc->id) :
529  avcodec_find_decoder(desc->id);
530  if (codec)
531  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
532  codec_string, codec->name, desc->name);
533  }
534 
535  if (!codec) {
536  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
537  exit_program(1);
538  }
539  if (codec->type != type) {
540  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
541  exit_program(1);
542  }
543  return codec;
544 }
545 
547 {
548  char *codec_name = NULL;
549 
550  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
551  if (codec_name) {
552  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
553  st->codec->codec_id = codec->id;
554  return codec;
555  } else
556  return avcodec_find_decoder(st->codec->codec_id);
557 }
558 
559 /* Add all the streams from the given input file to the global
560  * list of input streams. */
562 {
563  int i;
564  char *next, *codec_tag = NULL;
565 
566  for (i = 0; i < ic->nb_streams; i++) {
567  AVStream *st = ic->streams[i];
568  AVCodecContext *dec = st->codec;
569  InputStream *ist = av_mallocz(sizeof(*ist));
570  char *framerate = NULL;
571 
572  if (!ist)
573  exit_program(1);
574 
576  input_streams[nb_input_streams - 1] = ist;
577 
578  ist->st = st;
579  ist->file_index = nb_input_files;
580  ist->discard = 1;
581  st->discard = AVDISCARD_ALL;
582 
583  ist->ts_scale = 1.0;
584  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
585 
586  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
587  if (codec_tag) {
588  uint32_t tag = strtol(codec_tag, &next, 0);
589  if (*next)
590  tag = AV_RL32(codec_tag);
591  st->codec->codec_tag = tag;
592  }
593 
594  ist->dec = choose_decoder(o, ic, st);
595  ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
596 
597  ist->reinit_filters = -1;
598  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
599 
601 
602  switch (dec->codec_type) {
603  case AVMEDIA_TYPE_VIDEO:
604  if(!ist->dec)
605  ist->dec = avcodec_find_decoder(dec->codec_id);
606  if (dec->lowres) {
607  dec->flags |= CODEC_FLAG_EMU_EDGE;
608  }
609 
610  ist->resample_height = dec->height;
611  ist->resample_width = dec->width;
612  ist->resample_pix_fmt = dec->pix_fmt;
613 
614  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
615  if (framerate && av_parse_video_rate(&ist->framerate,
616  framerate) < 0) {
617  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
618  framerate);
619  exit_program(1);
620  }
621 
622  ist->top_field_first = -1;
623  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
624 
625  break;
626  case AVMEDIA_TYPE_AUDIO:
627  ist->guess_layout_max = INT_MAX;
628  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
630 
631  ist->resample_sample_fmt = dec->sample_fmt;
632  ist->resample_sample_rate = dec->sample_rate;
633  ist->resample_channels = dec->channels;
635 
636  break;
637  case AVMEDIA_TYPE_DATA:
638  case AVMEDIA_TYPE_SUBTITLE: {
639  char *canvas_size = NULL;
640  if(!ist->dec)
641  ist->dec = avcodec_find_decoder(dec->codec_id);
642  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
643  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
644  if (canvas_size &&
645  av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
646  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
647  exit_program(1);
648  }
649  break;
650  }
653  break;
654  default:
655  abort();
656  }
657  }
658 }
659 
660 static void assert_file_overwrite(const char *filename)
661 {
662  if ((!file_overwrite || no_file_overwrite) &&
663  (strchr(filename, ':') == NULL || filename[1] == ':' ||
664  av_strstart(filename, "file:", NULL))) {
665  if (avio_check(filename, 0) == 0) {
667  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
668  fflush(stderr);
669  term_exit();
670  signal(SIGINT, SIG_DFL);
671  if (!read_yesno()) {
672  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
673  exit_program(1);
674  }
675  term_init();
676  }
677  else {
678  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
679  exit_program(1);
680  }
681  }
682  }
683 }
684 
685 static void dump_attachment(AVStream *st, const char *filename)
686 {
687  int ret;
688  AVIOContext *out = NULL;
690 
691  if (!st->codec->extradata_size) {
692  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
693  nb_input_files - 1, st->index);
694  return;
695  }
696  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
697  filename = e->value;
698  if (!*filename) {
699  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
700  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
701  exit_program(1);
702  }
703 
704  assert_file_overwrite(filename);
705 
706  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
707  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
708  filename);
709  exit_program(1);
710  }
711 
712  avio_write(out, st->codec->extradata, st->codec->extradata_size);
713  avio_flush(out);
714  avio_close(out);
715 }
716 
717 static int open_input_file(OptionsContext *o, const char *filename)
718 {
719  InputFile *f;
720  AVFormatContext *ic;
721  AVInputFormat *file_iformat = NULL;
722  int err, i, ret;
723  int64_t timestamp;
724  uint8_t buf[128];
725  AVDictionary **opts;
726  AVDictionary *unused_opts = NULL;
727  AVDictionaryEntry *e = NULL;
728  int orig_nb_streams; // number of streams before avformat_find_stream_info
729  char * video_codec_name = NULL;
730  char * audio_codec_name = NULL;
731  char *subtitle_codec_name = NULL;
732 
733  if (o->format) {
734  if (!(file_iformat = av_find_input_format(o->format))) {
735  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
736  exit_program(1);
737  }
738  }
739 
740  if (!strcmp(filename, "-"))
741  filename = "pipe:";
742 
743  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
744  strcmp(filename, "/dev/stdin");
745 
746  /* get default parameters from command line */
747  ic = avformat_alloc_context();
748  if (!ic) {
749  print_error(filename, AVERROR(ENOMEM));
750  exit_program(1);
751  }
752  if (o->nb_audio_sample_rate) {
753  snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
754  av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
755  }
756  if (o->nb_audio_channels) {
757  /* because we set audio_channels based on both the "ac" and
758  * "channel_layout" options, we need to check that the specified
759  * demuxer actually has the "channels" option before setting it */
760  if (file_iformat && file_iformat->priv_class &&
761  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
763  snprintf(buf, sizeof(buf), "%d",
764  o->audio_channels[o->nb_audio_channels - 1].u.i);
765  av_dict_set(&o->g->format_opts, "channels", buf, 0);
766  }
767  }
768  if (o->nb_frame_rates) {
769  /* set the format-level framerate option;
770  * this is important for video grabbers, e.g. x11 */
771  if (file_iformat && file_iformat->priv_class &&
772  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
774  av_dict_set(&o->g->format_opts, "framerate",
775  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
776  }
777  }
778  if (o->nb_frame_sizes) {
779  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
780  }
781  if (o->nb_frame_pix_fmts)
782  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
783 
784  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
785  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
786  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
787 
788  ic->video_codec_id = video_codec_name ?
789  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
790  ic->audio_codec_id = audio_codec_name ?
791  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
792  ic->subtitle_codec_id= subtitle_codec_name ?
793  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
794  ic->flags |= AVFMT_FLAG_NONBLOCK;
796 
797  /* open the input file with generic avformat function */
798  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
799  if (err < 0) {
800  print_error(filename, err);
801  exit_program(1);
802  }
804 
805  /* apply forced codec ids */
806  for (i = 0; i < ic->nb_streams; i++)
807  choose_decoder(o, ic, ic->streams[i]);
808 
809  /* Set AVCodecContext options for avformat_find_stream_info */
810  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
811  orig_nb_streams = ic->nb_streams;
812 
813  /* If not enough info to get the stream parameters, we decode the
814  first frames to get it. (used in mpeg case for example) */
815  ret = avformat_find_stream_info(ic, opts);
816  if (ret < 0) {
817  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
819  exit_program(1);
820  }
821 
822  timestamp = o->start_time;
823  /* add the stream start time */
824  if (ic->start_time != AV_NOPTS_VALUE)
825  timestamp += ic->start_time;
826 
827  /* if seeking requested, we execute it */
828  if (o->start_time != 0) {
829  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
830  if (ret < 0) {
831  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
832  filename, (double)timestamp / AV_TIME_BASE);
833  }
834  }
835 
836  /* update the current parameters so that they match the one of the input stream */
837  add_input_streams(o, ic);
838 
839  /* dump the file content */
840  av_dump_format(ic, nb_input_files, filename, 0);
841 
843  f = av_mallocz(sizeof(*f));
844  if (!f)
845  exit_program(1);
846  input_files[nb_input_files - 1] = f;
847 
848  f->ctx = ic;
850  f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
851  f->nb_streams = ic->nb_streams;
852  f->rate_emu = o->rate_emu;
853 
854  /* check if all codec options have been used */
855  unused_opts = strip_specifiers(o->g->codec_opts);
856  for (i = f->ist_index; i < nb_input_streams; i++) {
857  e = NULL;
858  while ((e = av_dict_get(input_streams[i]->opts, "", e,
860  av_dict_set(&unused_opts, e->key, NULL, 0);
861  }
862 
863  e = NULL;
864  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
865  const AVClass *class = avcodec_get_class();
866  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
868  if (!option)
869  continue;
870  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
871  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
872  "input file #%d (%s) is not a decoding option.\n", e->key,
873  option->help ? option->help : "", nb_input_files - 1,
874  filename);
875  exit_program(1);
876  }
877 
878  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
879  "input file #%d (%s) has not been used for any stream. The most "
880  "likely reason is either wrong type (e.g. a video option with "
881  "no video streams) or that it is a private option of some decoder "
882  "which was not actually used for any stream.\n", e->key,
883  option->help ? option->help : "", nb_input_files - 1, filename);
884  }
885  av_dict_free(&unused_opts);
886 
887  for (i = 0; i < o->nb_dump_attachment; i++) {
888  int j;
889 
890  for (j = 0; j < ic->nb_streams; j++) {
891  AVStream *st = ic->streams[j];
892 
893  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
895  }
896  }
897 
898  for (i = 0; i < orig_nb_streams; i++)
899  av_dict_free(&opts[i]);
900  av_freep(&opts);
901 
902  return 0;
903 }
904 
906 {
907  AVIOContext *line;
908  uint8_t *buf;
909  char c;
910 
911  if (avio_open_dyn_buf(&line) < 0) {
912  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
913  exit_program(1);
914  }
915 
916  while ((c = avio_r8(s)) && c != '\n')
917  avio_w8(line, c);
918  avio_w8(line, 0);
919  avio_close_dyn_buf(line, &buf);
920 
921  return buf;
922 }
923 
924 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
925 {
926  int i, ret = 1;
927  char filename[1000];
928  const char *base[3] = { getenv("AVCONV_DATADIR"),
929  getenv("HOME"),
930  AVCONV_DATADIR,
931  };
932 
933  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
934  if (!base[i])
935  continue;
936  if (codec_name) {
937  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
938  i != 1 ? "" : "/.avconv", codec_name, preset_name);
939  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
940  }
941  if (ret) {
942  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
943  i != 1 ? "" : "/.avconv", preset_name);
944  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
945  }
946  }
947  return ret;
948 }
949 
951 {
952  char *codec_name = NULL;
953 
954  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
955  if (!codec_name) {
956  ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
957  NULL, ost->st->codec->codec_type);
958  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
959  } else if (!strcmp(codec_name, "copy"))
960  ost->stream_copy = 1;
961  else {
962  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
963  ost->st->codec->codec_id = ost->enc->id;
964  }
965 }
966 
967 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
968 {
969  OutputStream *ost;
970  AVStream *st = avformat_new_stream(oc, NULL);
971  int idx = oc->nb_streams - 1, ret = 0;
972  char *bsf = NULL, *next, *codec_tag = NULL;
973  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
974  double qscale = -1;
975  int i;
976 
977  if (!st) {
978  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
979  exit_program(1);
980  }
981 
982  if (oc->nb_streams - 1 < o->nb_streamid_map)
983  st->id = o->streamid_map[oc->nb_streams - 1];
984 
986  if (!(ost = av_mallocz(sizeof(*ost))))
987  exit_program(1);
989 
990  ost->file_index = nb_output_files - 1;
991  ost->index = idx;
992  ost->st = st;
993  st->codec->codec_type = type;
994  choose_encoder(o, oc, ost);
995  if (ost->enc) {
996  AVIOContext *s = NULL;
997  char *buf = NULL, *arg = NULL, *preset = NULL;
998 
999  ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1000 
1001  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1002  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1003  do {
1004  buf = get_line(s);
1005  if (!buf[0] || buf[0] == '#') {
1006  av_free(buf);
1007  continue;
1008  }
1009  if (!(arg = strchr(buf, '='))) {
1010  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1011  exit_program(1);
1012  }
1013  *arg++ = 0;
1014  av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1015  av_free(buf);
1016  } while (!s->eof_reached);
1017  avio_close(s);
1018  }
1019  if (ret) {
1020  av_log(NULL, AV_LOG_FATAL,
1021  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1022  preset, ost->file_index, ost->index);
1023  exit_program(1);
1024  }
1025  } else {
1026  ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1027  }
1028 
1030  st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1031 
1032  ost->max_frames = INT64_MAX;
1033  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1034  for (i = 0; i<o->nb_max_frames; i++) {
1035  char *p = o->max_frames[i].specifier;
1036  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1037  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1038  break;
1039  }
1040  }
1041 
1042  ost->copy_prior_start = -1;
1043  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1044 
1045  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1046  while (bsf) {
1047  if (next = strchr(bsf, ','))
1048  *next++ = 0;
1049  if (!(bsfc = av_bitstream_filter_init(bsf))) {
1050  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1051  exit_program(1);
1052  }
1053  if (bsfc_prev)
1054  bsfc_prev->next = bsfc;
1055  else
1056  ost->bitstream_filters = bsfc;
1057 
1058  bsfc_prev = bsfc;
1059  bsf = next;
1060  }
1061 
1062  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1063  if (codec_tag) {
1064  uint32_t tag = strtol(codec_tag, &next, 0);
1065  if (*next)
1066  tag = AV_RL32(codec_tag);
1067  st->codec->codec_tag = tag;
1068  }
1069 
1070  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1071  if (qscale >= 0) {
1072  st->codec->flags |= CODEC_FLAG_QSCALE;
1073  st->codec->global_quality = FF_QP2LAMBDA * qscale;
1074  }
1075 
1076  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1078 
1079  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1080 
1081  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1082  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1083  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1084 
1085  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1086 
1087  ost->source_index = source_index;
1088  if (source_index >= 0) {
1089  ost->sync_ist = input_streams[source_index];
1090  input_streams[source_index]->discard = 0;
1091  input_streams[source_index]->st->discard = AVDISCARD_NONE;
1092  }
1094 
1095  return ost;
1096 }
1097 
1098 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1099 {
1100  int i;
1101  const char *p = str;
1102  for (i = 0;; i++) {
1103  dest[i] = atoi(p);
1104  if (i == 63)
1105  break;
1106  p = strchr(p, ',');
1107  if (!p) {
1108  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1109  exit_program(1);
1110  }
1111  p++;
1112  }
1113 }
1114 
1115 /* read file contents into a string */
1116 static uint8_t *read_file(const char *filename)
1117 {
1118  AVIOContext *pb = NULL;
1119  AVIOContext *dyn_buf = NULL;
1120  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1121  uint8_t buf[1024], *str;
1122 
1123  if (ret < 0) {
1124  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1125  return NULL;
1126  }
1127 
1128  ret = avio_open_dyn_buf(&dyn_buf);
1129  if (ret < 0) {
1130  avio_closep(&pb);
1131  return NULL;
1132  }
1133  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1134  avio_write(dyn_buf, buf, ret);
1135  avio_w8(dyn_buf, 0);
1136  avio_closep(&pb);
1137 
1138  ret = avio_close_dyn_buf(dyn_buf, &str);
1139  if (ret < 0)
1140  return NULL;
1141  return str;
1142 }
1143 
1145  OutputStream *ost)
1146 {
1147  AVStream *st = ost->st;
1148  char *filter = NULL, *filter_script = NULL;
1149 
1150  MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1151  MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1152 
1153  if (filter_script && filter) {
1154  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1155  "output stream #%d:%d.\n", nb_output_files, st->index);
1156  exit_program(1);
1157  }
1158 
1159  if (filter_script)
1160  return read_file(filter_script);
1161  else if (filter)
1162  return av_strdup(filter);
1163 
1164  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1165  "null" : "anull");
1166 }
1167 
1169 {
1170  AVStream *st;
1171  OutputStream *ost;
1172  AVCodecContext *video_enc;
1173  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1174 
1175  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1176  st = ost->st;
1177  video_enc = st->codec;
1178 
1179  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1180  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1181  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1182  exit_program(1);
1183  }
1184 
1185  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1186  if (frame_aspect_ratio) {
1187  AVRational q;
1188  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1189  q.num <= 0 || q.den <= 0) {
1190  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1191  exit_program(1);
1192  }
1193  ost->frame_aspect_ratio = q;
1194  }
1195 
1196  if (!ost->stream_copy) {
1197  const char *p = NULL;
1198  char *frame_size = NULL;
1199  char *frame_pix_fmt = NULL;
1200  char *intra_matrix = NULL, *inter_matrix = NULL;
1201  int do_pass = 0;
1202  int i;
1203 
1204  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1205  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1206  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1207  exit_program(1);
1208  }
1209 
1211  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1212  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1213  ost->keep_pix_fmt = 1;
1214  if (!*++frame_pix_fmt)
1215  frame_pix_fmt = NULL;
1216  }
1217  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1218  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1219  exit_program(1);
1220  }
1221  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1222 
1223  if (intra_only)
1224  video_enc->gop_size = 0;
1225  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1226  if (intra_matrix) {
1227  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1228  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1229  exit_program(1);
1230  }
1231  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1232  }
1233  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1234  if (inter_matrix) {
1235  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1236  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1237  exit_program(1);
1238  }
1239  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1240  }
1241 
1242  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1243  for (i = 0; p; i++) {
1244  int start, end, q;
1245  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1246  if (e != 3) {
1247  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1248  exit_program(1);
1249  }
1250  /* FIXME realloc failure */
1251  video_enc->rc_override =
1252  av_realloc(video_enc->rc_override,
1253  sizeof(RcOverride) * (i + 1));
1254  video_enc->rc_override[i].start_frame = start;
1255  video_enc->rc_override[i].end_frame = end;
1256  if (q > 0) {
1257  video_enc->rc_override[i].qscale = q;
1258  video_enc->rc_override[i].quality_factor = 1.0;
1259  }
1260  else {
1261  video_enc->rc_override[i].qscale = 0;
1262  video_enc->rc_override[i].quality_factor = -q/100.0;
1263  }
1264  p = strchr(p, '/');
1265  if (p) p++;
1266  }
1267  video_enc->rc_override_count = i;
1268  video_enc->intra_dc_precision = intra_dc_precision - 8;
1269 
1270  if (do_psnr)
1271  video_enc->flags|= CODEC_FLAG_PSNR;
1272 
1273  /* two pass mode */
1274  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1275  if (do_pass) {
1276  if (do_pass & 1) {
1277  video_enc->flags |= CODEC_FLAG_PASS1;
1278  av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1279  }
1280  if (do_pass & 2) {
1281  video_enc->flags |= CODEC_FLAG_PASS2;
1282  av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1283  }
1284  }
1285 
1286  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1287  if (ost->logfile_prefix &&
1288  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1289  exit_program(1);
1290 
1291  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1292  if (ost->forced_keyframes)
1294 
1295  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1296 
1297  ost->top_field_first = -1;
1298  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1299 
1300 
1301  ost->avfilter = get_ost_filters(o, oc, ost);
1302  if (!ost->avfilter)
1303  exit_program(1);
1304  } else {
1305  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1306  }
1307 
1308  return ost;
1309 }
1310 
1312 {
1313  int n;
1314  AVStream *st;
1315  OutputStream *ost;
1316  AVCodecContext *audio_enc;
1317 
1318  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1319  st = ost->st;
1320 
1321  audio_enc = st->codec;
1322  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1323 
1324  if (!ost->stream_copy) {
1325  char *sample_fmt = NULL;
1326 
1327  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1328 
1329  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1330  if (sample_fmt &&
1331  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1332  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1333  exit_program(1);
1334  }
1335 
1336  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1337 
1338  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1339  ost->apad = av_strdup(ost->apad);
1340 
1341  ost->avfilter = get_ost_filters(o, oc, ost);
1342  if (!ost->avfilter)
1343  exit_program(1);
1344 
1345  /* check for channel mapping for this audio stream */
1346  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1347  AudioChannelMap *map = &o->audio_channel_maps[n];
1348  InputStream *ist = input_streams[ost->source_index];
1349  if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1350  (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1351  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1354  else
1355  av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1356  ost->file_index, ost->st->index);
1357  }
1358  }
1359  }
1360 
1361  return ost;
1362 }
1363 
1365 {
1366  OutputStream *ost;
1367 
1368  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1369  if (!ost->stream_copy) {
1370  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1371  exit_program(1);
1372  }
1373 
1374  return ost;
1375 }
1376 
1378 {
1379  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1380  ost->stream_copy = 1;
1381  ost->finished = 1;
1382  return ost;
1383 }
1384 
1386 {
1387  AVStream *st;
1388  OutputStream *ost;
1389  AVCodecContext *subtitle_enc;
1390 
1391  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1392  st = ost->st;
1393  subtitle_enc = st->codec;
1394 
1395  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1396 
1397  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1398 
1399  if (!ost->stream_copy) {
1400  char *frame_size = NULL;
1401 
1402  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1403  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1404  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1405  exit_program(1);
1406  }
1407  }
1408 
1409  return ost;
1410 }
1411 
1412 /* arg format is "output-stream-index:streamid-value". */
1413 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1414 {
1415  OptionsContext *o = optctx;
1416  int idx;
1417  char *p;
1418  char idx_str[16];
1419 
1420  av_strlcpy(idx_str, arg, sizeof(idx_str));
1421  p = strchr(idx_str, ':');
1422  if (!p) {
1423  av_log(NULL, AV_LOG_FATAL,
1424  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1425  arg, opt);
1426  exit_program(1);
1427  }
1428  *p++ = '\0';
1429  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1430  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1431  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1432  return 0;
1433 }
1434 
1436 {
1437  AVFormatContext *is = ifile->ctx;
1438  AVFormatContext *os = ofile->ctx;
1439  AVChapter **tmp;
1440  int i;
1441 
1442  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1443  if (!tmp)
1444  return AVERROR(ENOMEM);
1445  os->chapters = tmp;
1446 
1447  for (i = 0; i < is->nb_chapters; i++) {
1448  AVChapter *in_ch = is->chapters[i], *out_ch;
1449  int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1450  AV_TIME_BASE_Q, in_ch->time_base);
1451  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1453 
1454 
1455  if (in_ch->end < ts_off)
1456  continue;
1457  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1458  break;
1459 
1460  out_ch = av_mallocz(sizeof(AVChapter));
1461  if (!out_ch)
1462  return AVERROR(ENOMEM);
1463 
1464  out_ch->id = in_ch->id;
1465  out_ch->time_base = in_ch->time_base;
1466  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1467  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1468 
1469  if (copy_metadata)
1470  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1471 
1472  os->chapters[os->nb_chapters++] = out_ch;
1473  }
1474  return 0;
1475 }
1476 
1477 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1478 {
1479  int i, err;
1481 
1482  ic->interrupt_callback = int_cb;
1483  err = avformat_open_input(&ic, filename, NULL, NULL);
1484  if (err < 0)
1485  return err;
1486  /* copy stream format */
1487  for(i=0;i<ic->nb_streams;i++) {
1488  AVStream *st;
1489  OutputStream *ost;
1490  AVCodec *codec;
1491  AVCodecContext *avctx;
1492 
1493  codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1494  ost = new_output_stream(o, s, codec->type, -1);
1495  st = ost->st;
1496  avctx = st->codec;
1497  ost->enc = codec;
1498 
1499  // FIXME: a more elegant solution is needed
1500  memcpy(st, ic->streams[i], sizeof(AVStream));
1501  st->cur_dts = 0;
1502  st->info = av_malloc(sizeof(*st->info));
1503  memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1504  st->codec= avctx;
1505  avcodec_copy_context(st->codec, ic->streams[i]->codec);
1506 
1507  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1508  choose_sample_fmt(st, codec);
1509  else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1510  choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1511  }
1512 
1513  avformat_close_input(&ic);
1514  return err;
1515 }
1516 
1518  AVFormatContext *oc)
1519 {
1520  OutputStream *ost;
1521 
1523  ofilter->out_tmp->pad_idx)) {
1524  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1525  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1526  default:
1527  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1528  "currently.\n");
1529  exit_program(1);
1530  }
1531 
1532  ost->source_index = -1;
1533  ost->filter = ofilter;
1534 
1535  ofilter->ost = ost;
1536 
1537  if (ost->stream_copy) {
1538  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1539  "which is fed from a complex filtergraph. Filtering and streamcopy "
1540  "cannot be used together.\n", ost->file_index, ost->index);
1541  exit_program(1);
1542  }
1543 
1544  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1545  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1546  exit_program(1);
1547  }
1548  avfilter_inout_free(&ofilter->out_tmp);
1549 }
1550 
1552 {
1553  int i, ret = 0;
1554 
1555  for (i = 0; i < nb_filtergraphs; i++)
1556  if (!filtergraphs[i]->graph &&
1557  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1558  return ret;
1559  return 0;
1560 }
1561 
1562 static int open_output_file(OptionsContext *o, const char *filename)
1563 {
1564  AVFormatContext *oc;
1565  int i, j, err;
1566  AVOutputFormat *file_oformat;
1567  OutputFile *of;
1568  OutputStream *ost;
1569  InputStream *ist;
1570  AVDictionary *unused_opts = NULL;
1571  AVDictionaryEntry *e = NULL;
1572 
1573  if (configure_complex_filters() < 0) {
1574  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1575  exit_program(1);
1576  }
1577 
1578  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1579  o->stop_time = INT64_MAX;
1580  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1581  }
1582 
1583  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1584  if (o->stop_time <= o->start_time) {
1585  av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1586  o->stop_time = INT64_MAX;
1587  } else {
1588  o->recording_time = o->stop_time - o->start_time;
1589  }
1590  }
1591 
1593  of = av_mallocz(sizeof(*of));
1594  if (!of)
1595  exit_program(1);
1596  output_files[nb_output_files - 1] = of;
1597 
1599  of->recording_time = o->recording_time;
1600  of->start_time = o->start_time;
1601  of->limit_filesize = o->limit_filesize;
1602  of->shortest = o->shortest;
1603  av_dict_copy(&of->opts, o->g->format_opts, 0);
1604 
1605  if (!strcmp(filename, "-"))
1606  filename = "pipe:";
1607 
1608  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1609  if (!oc) {
1610  print_error(filename, err);
1611  exit_program(1);
1612  }
1613 
1614  of->ctx = oc;
1615  if (o->recording_time != INT64_MAX)
1616  oc->duration = o->recording_time;
1617 
1618  file_oformat= oc->oformat;
1619  oc->interrupt_callback = int_cb;
1620 
1621  /* create streams for all unlabeled output pads */
1622  for (i = 0; i < nb_filtergraphs; i++) {
1623  FilterGraph *fg = filtergraphs[i];
1624  for (j = 0; j < fg->nb_outputs; j++) {
1625  OutputFilter *ofilter = fg->outputs[j];
1626 
1627  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1628  continue;
1629 
1631  ofilter->out_tmp->pad_idx)) {
1632  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1633  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1634  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1635  }
1636  init_output_filter(ofilter, o, oc);
1637  }
1638  }
1639 
1640  /* ffserver seeking with date=... needs a date reference */
1641  if (!strcmp(file_oformat->name, "ffm") &&
1642  av_strstart(filename, "http:", NULL)) {
1643  int err = parse_option(o, "metadata", "creation_time=now", options);
1644  if (err < 0) {
1645  print_error(filename, err);
1646  exit_program(1);
1647  }
1648  }
1649 
1650  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1651  av_strstart(filename, "http:", NULL)) {
1652  int j;
1653  /* special case for files sent to ffserver: we get the stream
1654  parameters from ffserver */
1655  int err = read_ffserver_streams(o, oc, filename);
1656  if (err < 0) {
1657  print_error(filename, err);
1658  exit_program(1);
1659  }
1660  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1661  ost = output_streams[j];
1662  for (i = 0; i < nb_input_streams; i++) {
1663  ist = input_streams[i];
1664  if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1665  ost->sync_ist= ist;
1666  ost->source_index= i;
1667  if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1668  if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1669  ist->discard = 0;
1670  ist->st->discard = AVDISCARD_NONE;
1671  break;
1672  }
1673  }
1674  if(!ost->sync_ist){
1675  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));
1676  exit_program(1);
1677  }
1678  }
1679  } else if (!o->nb_stream_maps) {
1680  char *subtitle_codec_name = NULL;
1681  /* pick the "best" stream of each type */
1682 
1683  /* video: highest resolution */
1684  if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1685  int area = 0, idx = -1;
1686  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1687  for (i = 0; i < nb_input_streams; i++) {
1688  int new_area;
1689  ist = input_streams[i];
1690  new_area = ist->st->codec->width * ist->st->codec->height;
1691  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1692  new_area = 1;
1693  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1694  new_area > area) {
1695  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1696  continue;
1697  area = new_area;
1698  idx = i;
1699  }
1700  }
1701  if (idx >= 0)
1702  new_video_stream(o, oc, idx);
1703  }
1704 
1705  /* audio: most channels */
1706  if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1707  int channels = 0, idx = -1;
1708  for (i = 0; i < nb_input_streams; i++) {
1709  ist = input_streams[i];
1710  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1711  ist->st->codec->channels > channels) {
1712  channels = ist->st->codec->channels;
1713  idx = i;
1714  }
1715  }
1716  if (idx >= 0)
1717  new_audio_stream(o, oc, idx);
1718  }
1719 
1720  /* subtitles: pick first */
1721  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1722  if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1723  for (i = 0; i < nb_input_streams; i++)
1724  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1725  new_subtitle_stream(o, oc, i);
1726  break;
1727  }
1728  }
1729  /* do something with data? */
1730  } else {
1731  for (i = 0; i < o->nb_stream_maps; i++) {
1732  StreamMap *map = &o->stream_maps[i];
1733 
1734  if (map->disabled)
1735  continue;
1736 
1737  if (map->linklabel) {
1738  FilterGraph *fg;
1739  OutputFilter *ofilter = NULL;
1740  int j, k;
1741 
1742  for (j = 0; j < nb_filtergraphs; j++) {
1743  fg = filtergraphs[j];
1744  for (k = 0; k < fg->nb_outputs; k++) {
1745  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1746  if (out && !strcmp(out->name, map->linklabel)) {
1747  ofilter = fg->outputs[k];
1748  goto loop_end;
1749  }
1750  }
1751  }
1752 loop_end:
1753  if (!ofilter) {
1754  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1755  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1756  exit_program(1);
1757  }
1758  init_output_filter(ofilter, o, oc);
1759  } else {
1760  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1761 
1764  continue;
1765  if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1766  continue;
1767  if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1768  continue;
1769  if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1770  continue;
1771 
1772  switch (ist->st->codec->codec_type) {
1773  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1774  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1775  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1776  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1777  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1778  default:
1779  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1780  map->file_index, map->stream_index);
1781  exit_program(1);
1782  }
1783  }
1784  }
1785  }
1786 
1787  /* handle attached files */
1788  for (i = 0; i < o->nb_attachments; i++) {
1789  AVIOContext *pb;
1790  uint8_t *attachment;
1791  const char *p;
1792  int64_t len;
1793 
1794  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1795  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1796  o->attachments[i]);
1797  exit_program(1);
1798  }
1799  if ((len = avio_size(pb)) <= 0) {
1800  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1801  o->attachments[i]);
1802  exit_program(1);
1803  }
1804  if (!(attachment = av_malloc(len))) {
1805  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1806  o->attachments[i]);
1807  exit_program(1);
1808  }
1809  avio_read(pb, attachment, len);
1810 
1811  ost = new_attachment_stream(o, oc, -1);
1812  ost->stream_copy = 0;
1813  ost->attachment_filename = o->attachments[i];
1814  ost->finished = 1;
1815  ost->st->codec->extradata = attachment;
1816  ost->st->codec->extradata_size = len;
1817 
1818  p = strrchr(o->attachments[i], '/');
1819  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1820  avio_close(pb);
1821  }
1822 
1823  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1824  AVDictionaryEntry *e;
1825  ost = output_streams[i];
1826 
1827  if ((ost->stream_copy || ost->attachment_filename)
1828  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1829  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1830  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1831  exit_program(1);
1832  }
1833 
1834  /* check if all codec options have been used */
1835  unused_opts = strip_specifiers(o->g->codec_opts);
1836  for (i = of->ost_index; i < nb_output_streams; i++) {
1837  e = NULL;
1838  while ((e = av_dict_get(output_streams[i]->opts, "", e,
1840  av_dict_set(&unused_opts, e->key, NULL, 0);
1841  }
1842 
1843  e = NULL;
1844  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1845  const AVClass *class = avcodec_get_class();
1846  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1848  if (!option)
1849  continue;
1850  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1851  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1852  "output file #%d (%s) is not an encoding option.\n", e->key,
1853  option->help ? option->help : "", nb_output_files - 1,
1854  filename);
1855  exit_program(1);
1856  }
1857 
1858  // gop_timecode is injected by generic code but not always used
1859  if (!strcmp(e->key, "gop_timecode"))
1860  continue;
1861 
1862  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1863  "output file #%d (%s) has not been used for any stream. The most "
1864  "likely reason is either wrong type (e.g. a video option with "
1865  "no video streams) or that it is a private option of some encoder "
1866  "which was not actually used for any stream.\n", e->key,
1867  option->help ? option->help : "", nb_output_files - 1, filename);
1868  }
1869  av_dict_free(&unused_opts);
1870 
1871  /* check filename in case of an image number is expected */
1872  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1873  if (!av_filename_number_test(oc->filename)) {
1874  print_error(oc->filename, AVERROR(EINVAL));
1875  exit_program(1);
1876  }
1877  }
1878 
1879  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1880  /* test if it already exists to avoid losing precious files */
1881  assert_file_overwrite(filename);
1882 
1883  /* open the file */
1884  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1885  &oc->interrupt_callback,
1886  &of->opts)) < 0) {
1887  print_error(filename, err);
1888  exit_program(1);
1889  }
1890  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1891  assert_file_overwrite(filename);
1892 
1893  if (o->mux_preload) {
1894  uint8_t buf[64];
1895  snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1896  av_dict_set(&of->opts, "preload", buf, 0);
1897  }
1898  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1899 
1900  /* copy metadata */
1901  for (i = 0; i < o->nb_metadata_map; i++) {
1902  char *p;
1903  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1904 
1905  if (in_file_index >= nb_input_files) {
1906  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1907  exit_program(1);
1908  }
1909  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1910  in_file_index >= 0 ?
1911  input_files[in_file_index]->ctx : NULL, o);
1912  }
1913 
1914  /* copy chapters */
1915  if (o->chapters_input_file >= nb_input_files) {
1916  if (o->chapters_input_file == INT_MAX) {
1917  /* copy chapters from the first input file that has them*/
1918  o->chapters_input_file = -1;
1919  for (i = 0; i < nb_input_files; i++)
1920  if (input_files[i]->ctx->nb_chapters) {
1921  o->chapters_input_file = i;
1922  break;
1923  }
1924  } else {
1925  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1926  o->chapters_input_file);
1927  exit_program(1);
1928  }
1929  }
1930  if (o->chapters_input_file >= 0)
1933 
1934  /* copy global metadata by default */
1938  if(o->recording_time != INT64_MAX)
1939  av_dict_set(&oc->metadata, "duration", NULL, 0);
1940  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1941  }
1942  if (!o->metadata_streams_manual)
1943  for (i = of->ost_index; i < nb_output_streams; i++) {
1944  InputStream *ist;
1945  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1946  continue;
1948  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1949  }
1950 
1951  /* process manually set metadata */
1952  for (i = 0; i < o->nb_metadata; i++) {
1953  AVDictionary **m;
1954  char type, *val;
1955  const char *stream_spec;
1956  int index = 0, j, ret = 0;
1957 
1958  val = strchr(o->metadata[i].u.str, '=');
1959  if (!val) {
1960  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1961  o->metadata[i].u.str);
1962  exit_program(1);
1963  }
1964  *val++ = 0;
1965 
1966  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1967  if (type == 's') {
1968  for (j = 0; j < oc->nb_streams; j++) {
1969  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1970  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1971  } else if (ret < 0)
1972  exit_program(1);
1973  }
1974  }
1975  else {
1976  switch (type) {
1977  case 'g':
1978  m = &oc->metadata;
1979  break;
1980  case 'c':
1981  if (index < 0 || index >= oc->nb_chapters) {
1982  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1983  exit_program(1);
1984  }
1985  m = &oc->chapters[index]->metadata;
1986  break;
1987  default:
1988  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1989  exit_program(1);
1990  }
1991  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1992  }
1993  }
1994 
1995  return 0;
1996 }
1997 
1998 static int opt_target(void *optctx, const char *opt, const char *arg)
1999 {
2000  OptionsContext *o = optctx;
2001  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2002  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2003 
2004  if (!strncmp(arg, "pal-", 4)) {
2005  norm = PAL;
2006  arg += 4;
2007  } else if (!strncmp(arg, "ntsc-", 5)) {
2008  norm = NTSC;
2009  arg += 5;
2010  } else if (!strncmp(arg, "film-", 5)) {
2011  norm = FILM;
2012  arg += 5;
2013  } else {
2014  /* Try to determine PAL/NTSC by peeking in the input files */
2015  if (nb_input_files) {
2016  int i, j, fr;
2017  for (j = 0; j < nb_input_files; j++) {
2018  for (i = 0; i < input_files[j]->nb_streams; i++) {
2020  if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2021  continue;
2022  fr = c->time_base.den * 1000 / c->time_base.num;
2023  if (fr == 25000) {
2024  norm = PAL;
2025  break;
2026  } else if ((fr == 29970) || (fr == 23976)) {
2027  norm = NTSC;
2028  break;
2029  }
2030  }
2031  if (norm != UNKNOWN)
2032  break;
2033  }
2034  }
2035  if (norm != UNKNOWN)
2036  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2037  }
2038 
2039  if (norm == UNKNOWN) {
2040  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2041  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2042  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2043  exit_program(1);
2044  }
2045 
2046  if (!strcmp(arg, "vcd")) {
2047  opt_video_codec(o, "c:v", "mpeg1video");
2048  opt_audio_codec(o, "c:a", "mp2");
2049  parse_option(o, "f", "vcd", options);
2050  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2051 
2052  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2053  parse_option(o, "r", frame_rates[norm], options);
2054  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2055 
2056  av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2057  av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2058  av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2059  av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2060 
2061  av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2062  parse_option(o, "ar", "44100", options);
2063  parse_option(o, "ac", "2", options);
2064 
2065  av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2066  av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2067 
2068  /* We have to offset the PTS, so that it is consistent with the SCR.
2069  SCR starts at 36000, but the first two packs contain only padding
2070  and the first pack from the other stream, respectively, may also have
2071  been written before.
2072  So the real data starts at SCR 36000+3*1200. */
2073  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2074  } else if (!strcmp(arg, "svcd")) {
2075 
2076  opt_video_codec(o, "c:v", "mpeg2video");
2077  opt_audio_codec(o, "c:a", "mp2");
2078  parse_option(o, "f", "svcd", options);
2079 
2080  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2081  parse_option(o, "r", frame_rates[norm], options);
2082  parse_option(o, "pix_fmt", "yuv420p", options);
2083  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2084 
2085  av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2086  av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2087  av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2088  av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2089  av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2090 
2091  av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2092  parse_option(o, "ar", "44100", options);
2093 
2094  av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2095 
2096  } else if (!strcmp(arg, "dvd")) {
2097 
2098  opt_video_codec(o, "c:v", "mpeg2video");
2099  opt_audio_codec(o, "c:a", "ac3");
2100  parse_option(o, "f", "dvd", options);
2101 
2102  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2103  parse_option(o, "r", frame_rates[norm], options);
2104  parse_option(o, "pix_fmt", "yuv420p", options);
2105  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2106 
2107  av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2108  av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2109  av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2110  av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2111 
2112  av_dict_set(&o->g->format_opts, "packetsize", "2048", 0); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2113  av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2114 
2115  av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2116  parse_option(o, "ar", "48000", options);
2117 
2118  } else if (!strncmp(arg, "dv", 2)) {
2119 
2120  parse_option(o, "f", "dv", options);
2121 
2122  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2123  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2124  norm == PAL ? "yuv420p" : "yuv411p", options);
2125  parse_option(o, "r", frame_rates[norm], options);
2126 
2127  parse_option(o, "ar", "48000", options);
2128  parse_option(o, "ac", "2", options);
2129 
2130  } else {
2131  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2132  return AVERROR(EINVAL);
2133  }
2134  return 0;
2135 }
2136 
2137 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2138 {
2140  vstats_filename = av_strdup (arg);
2141  return 0;
2142 }
2143 
2144 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2145 {
2146  char filename[40];
2147  time_t today2 = time(NULL);
2148  struct tm *today = localtime(&today2);
2149 
2150  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2151  today->tm_sec);
2152  return opt_vstats_file(NULL, opt, filename);
2153 }
2154 
2155 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2156 {
2157  OptionsContext *o = optctx;
2158  return parse_option(o, "frames:v", arg, options);
2159 }
2160 
2161 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2162 {
2163  OptionsContext *o = optctx;
2164  return parse_option(o, "frames:a", arg, options);
2165 }
2166 
2167 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2168 {
2169  OptionsContext *o = optctx;
2170  return parse_option(o, "frames:d", arg, options);
2171 }
2172 
2173 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2174 {
2175  int ret;
2176  AVDictionary *cbak = codec_opts;
2177  AVDictionary *fbak = format_opts;
2178  codec_opts = NULL;
2179  format_opts = NULL;
2180 
2181  ret = opt_default(NULL, opt, arg);
2182 
2183  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2187  codec_opts = cbak;
2188  format_opts = fbak;
2189 
2190  return ret;
2191 }
2192 
2193 static int opt_preset(void *optctx, const char *opt, const char *arg)
2194 {
2195  OptionsContext *o = optctx;
2196  FILE *f=NULL;
2197  char filename[1000], line[1000], tmp_line[1000];
2198  const char *codec_name = NULL;
2199 
2200  tmp_line[0] = *opt;
2201  tmp_line[1] = 0;
2202  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2203 
2204  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2205  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2206  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2207  }else
2208  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2209  exit_program(1);
2210  }
2211 
2212  while (fgets(line, sizeof(line), f)) {
2213  char *key = tmp_line, *value, *endptr;
2214 
2215  if (strcspn(line, "#\n\r") == 0)
2216  continue;
2217  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2218  if (!av_strtok(key, "=", &value) ||
2219  !av_strtok(value, "\r\n", &endptr)) {
2220  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2221  exit_program(1);
2222  }
2223  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2224 
2225  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2226  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2227  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2228  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2229  else if (opt_default_new(o, key, value) < 0) {
2230  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2231  filename, line, key, value);
2232  exit_program(1);
2233  }
2234  }
2235 
2236  fclose(f);
2237 
2238  return 0;
2239 }
2240 
2241 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2242 {
2243  OptionsContext *o = optctx;
2244  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2245  int ret = parse_option(o, s, arg, options);
2246  av_free(s);
2247  return ret;
2248 }
2249 
2250 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2251 {
2252  OptionsContext *o = optctx;
2253  if(!strcmp(opt, "b")){
2254  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2255  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2256  return 0;
2257  }
2258  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2259  return 0;
2260 }
2261 
2262 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2263 {
2264  OptionsContext *o = optctx;
2265  char *s;
2266  int ret;
2267  if(!strcmp(opt, "qscale")){
2268  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2269  return parse_option(o, "q:v", arg, options);
2270  }
2271  s = av_asprintf("q%s", opt + 6);
2272  ret = parse_option(o, s, arg, options);
2273  av_free(s);
2274  return ret;
2275 }
2276 
2277 static int opt_profile(void *optctx, const char *opt, const char *arg)
2278 {
2279  OptionsContext *o = optctx;
2280  if(!strcmp(opt, "profile")){
2281  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2282  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2283  return 0;
2284  }
2285  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2286  return 0;
2287 }
2288 
2289 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2290 {
2291  OptionsContext *o = optctx;
2292  return parse_option(o, "filter:v", arg, options);
2293 }
2294 
2295 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2296 {
2297  OptionsContext *o = optctx;
2298  return parse_option(o, "filter:a", arg, options);
2299 }
2300 
2301 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2302 {
2303  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2304  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2305  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2306  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2307 
2310  return 0;
2311 }
2312 
2313 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2314 {
2315  OptionsContext *o = optctx;
2316  char *tcr = av_asprintf("timecode=%s", arg);
2317  int ret = parse_option(o, "metadata:g", tcr, options);
2318  if (ret >= 0)
2319  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2320  av_free(tcr);
2321  return 0;
2322 }
2323 
2324 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2325 {
2326  OptionsContext *o = optctx;
2327  char layout_str[32];
2328  char *stream_str;
2329  char *ac_str;
2330  int ret, channels, ac_str_size;
2331  uint64_t layout;
2332 
2333  layout = av_get_channel_layout(arg);
2334  if (!layout) {
2335  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2336  return AVERROR(EINVAL);
2337  }
2338  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2339  ret = opt_default_new(o, opt, layout_str);
2340  if (ret < 0)
2341  return ret;
2342 
2343  /* set 'ac' option based on channel layout */
2344  channels = av_get_channel_layout_nb_channels(layout);
2345  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2346  stream_str = strchr(opt, ':');
2347  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2348  ac_str = av_mallocz(ac_str_size);
2349  if (!ac_str)
2350  return AVERROR(ENOMEM);
2351  av_strlcpy(ac_str, "ac", 3);
2352  if (stream_str)
2353  av_strlcat(ac_str, stream_str, ac_str_size);
2354  ret = parse_option(o, ac_str, layout_str, options);
2355  av_free(ac_str);
2356 
2357  return ret;
2358 }
2359 
2360 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2361 {
2362  OptionsContext *o = optctx;
2363  return parse_option(o, "q:a", arg, options);
2364 }
2365 
2366 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2367 {
2369  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2370  return AVERROR(ENOMEM);
2373  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2374  return AVERROR(ENOMEM);
2375  return 0;
2376 }
2377 
2378 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2379 {
2380  uint8_t *graph_desc = read_file(arg);
2381  if (!graph_desc)
2382  return AVERROR(EINVAL);
2383 
2385  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2386  return AVERROR(ENOMEM);
2388  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2389  return 0;
2390 }
2391 
2392 void show_help_default(const char *opt, const char *arg)
2393 {
2394  /* per-file options have at least one of those set */
2395  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2396  int show_advanced = 0, show_avoptions = 0;
2397 
2398  if (opt && *opt) {
2399  if (!strcmp(opt, "long"))
2400  show_advanced = 1;
2401  else if (!strcmp(opt, "full"))
2402  show_advanced = show_avoptions = 1;
2403  else
2404  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2405  }
2406 
2407  show_usage();
2408 
2409  printf("Getting help:\n"
2410  " -h -- print basic options\n"
2411  " -h long -- print more options\n"
2412  " -h full -- print all options (including all format and codec specific options, very long)\n"
2413  " See man %s for detailed description of the options.\n"
2414  "\n", program_name);
2415 
2416  show_help_options(options, "Print help / information / capabilities:",
2417  OPT_EXIT, 0, 0);
2418 
2419  show_help_options(options, "Global options (affect whole program "
2420  "instead of just one file:",
2421  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2422  if (show_advanced)
2423  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2424  per_file | OPT_EXIT, 0);
2425 
2426  show_help_options(options, "Per-file main options:", 0,
2428  OPT_EXIT, per_file);
2429  if (show_advanced)
2430  show_help_options(options, "Advanced per-file options:",
2431  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2432 
2433  show_help_options(options, "Video options:",
2435  if (show_advanced)
2436  show_help_options(options, "Advanced Video options:",
2438 
2439  show_help_options(options, "Audio options:",
2441  if (show_advanced)
2442  show_help_options(options, "Advanced Audio options:",
2444  show_help_options(options, "Subtitle options:",
2445  OPT_SUBTITLE, 0, 0);
2446  printf("\n");
2447 
2448  if (show_avoptions) {
2455  }
2456 }
2457 
2458 void show_usage(void)
2459 {
2460  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2461  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2462  av_log(NULL, AV_LOG_INFO, "\n");
2463 }
2464 
2465 enum OptGroup {
2468 };
2469 
2470 static const OptionGroupDef groups[] = {
2471  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2472  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2473 };
2474 
2475 static int open_files(OptionGroupList *l, const char *inout,
2476  int (*open_file)(OptionsContext*, const char*))
2477 {
2478  int i, ret;
2479 
2480  for (i = 0; i < l->nb_groups; i++) {
2481  OptionGroup *g = &l->groups[i];
2482  OptionsContext o;
2483 
2484  init_options(&o, !strcmp(inout, "input"));
2485  o.g = g;
2486 
2487  ret = parse_optgroup(&o, g);
2488  if (ret < 0) {
2489  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2490  "%s.\n", inout, g->arg);
2491  return ret;
2492  }
2493 
2494  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2495  ret = open_file(&o, g->arg);
2496  uninit_options(&o, !strcmp(inout, "input"));
2497  if (ret < 0) {
2498  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2499  inout, g->arg);
2500  return ret;
2501  }
2502  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2503  }
2504 
2505  return 0;
2506 }
2507 
2508 int ffmpeg_parse_options(int argc, char **argv)
2509 {
2510  OptionParseContext octx;
2511  uint8_t error[128];
2512  int ret;
2513 
2514  memset(&octx, 0, sizeof(octx));
2515 
2516  /* split the commandline into an internal representation */
2517  ret = split_commandline(&octx, argc, argv, options, groups,
2518  FF_ARRAY_ELEMS(groups));
2519  if (ret < 0) {
2520  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2521  goto fail;
2522  }
2523 
2524  /* apply global options */
2525  ret = parse_optgroup(NULL, &octx.global_opts);
2526  if (ret < 0) {
2527  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2528  goto fail;
2529  }
2530 
2531  /* open input files */
2532  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2533  if (ret < 0) {
2534  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2535  goto fail;
2536  }
2537 
2538  /* open output files */
2539  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2540  if (ret < 0) {
2541  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2542  goto fail;
2543  }
2544 
2545 fail:
2546  uninit_parse_context(&octx);
2547  if (ret < 0) {
2548  av_strerror(ret, error, sizeof(error));
2549  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2550  }
2551  return ret;
2552 }
2553 
2554 static int opt_progress(void *optctx, const char *opt, const char *arg)
2555 {
2556  AVIOContext *avio = NULL;
2557  int ret;
2558 
2559  if (!strcmp(arg, "-"))
2560  arg = "pipe:";
2561  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2562  if (ret < 0) {
2563  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2564  arg, av_err2str(ret));
2565  return ret;
2566  }
2567  progress_avio = avio;
2568  return 0;
2569 }
2570 
2571 #define OFFSET(x) offsetof(OptionsContext, x)
2572 const OptionDef options[] = {
2573  /* main options */
2574 #include "cmdutils_common_opts.h"
2575  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2576  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2577  "force format", "fmt" },
2578  { "y", OPT_BOOL, { &file_overwrite },
2579  "overwrite output files" },
2580  { "n", OPT_BOOL, { &no_file_overwrite },
2581  "do not overwrite output files" },
2582  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2583  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2584  "codec name", "codec" },
2585  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2586  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2587  "codec name", "codec" },
2588  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2589  OPT_OUTPUT, { .off = OFFSET(presets) },
2590  "preset name", "preset" },
2591  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2592  OPT_OUTPUT, { .func_arg = opt_map },
2593  "set input stream mapping",
2594  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2595  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2596  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2597  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2598  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2599  "set metadata information of outfile from infile",
2600  "outfile[,metadata]:infile[,metadata]" },
2601  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2602  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2603  "set chapters mapping", "input_file_index" },
2604  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2605  "record or transcode \"duration\" seconds of audio/video",
2606  "duration" },
2607  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2608  "record or transcode stop time", "time_stop" },
2609  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2610  "set the limit file size in bytes", "limit_size" },
2611  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2612  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2613  "set the start time offset", "time_off" },
2614  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2615  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2616  "set the input ts offset", "time_off" },
2617  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2618  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2619  "set the input ts scale", "scale" },
2620  { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2621  "set the recording timestamp ('now' to set the current time)", "time" },
2622  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2623  "add metadata", "string=string" },
2624  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2625  OPT_OUTPUT, { .func_arg = opt_data_frames },
2626  "set the number of data frames to record", "number" },
2627  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2628  "add timings for benchmarking" },
2629  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2630  "add timings for each task" },
2631  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2632  "write program-readable progress information", "url" },
2633  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2634  "enable or disable interaction on standard input" },
2635  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2636  "set max runtime in seconds", "limit" },
2637  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2638  "dump each input packet" },
2639  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2640  "when dumping packets, also dump the payload" },
2641  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2642  OPT_INPUT, { .off = OFFSET(rate_emu) },
2643  "read input at native frame rate", "" },
2644  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2645  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2646  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2647  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2648  "video sync method", "" },
2649  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2650  "audio sync method", "" },
2651  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2652  "audio drift threshold", "threshold" },
2653  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2654  "copy timestamps" },
2655  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
2656  "copy input stream time base when stream copying", "mode" },
2657  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2658  OPT_OUTPUT, { .off = OFFSET(shortest) },
2659  "finish encoding within shortest input" },
2660  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2661  OPT_OUTPUT, { .off = OFFSET(apad) },
2662  "audio pad", "" },
2663  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2664  "timestamp discontinuity delta threshold", "threshold" },
2665  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2666  "timestamp error delta threshold", "threshold" },
2667  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2668  "exit on error", "error" },
2669  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2670  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2671  "copy initial non-keyframes" },
2672  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2673  "copy or discard frames before start time" },
2674  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2675  "set the number of frames to record", "number" },
2676  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2677  OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2678  "force codec tag/fourcc", "fourcc/tag" },
2679  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2680  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2681  "use fixed quality scale (VBR)", "q" },
2682  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2683  OPT_OUTPUT, { .func_arg = opt_qscale },
2684  "use fixed quality scale (VBR)", "q" },
2685  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2686  "set profile", "profile" },
2687  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2688  "set stream filtergraph", "filter_graph" },
2689  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2690  "read stream filtergraph description from a file", "filename" },
2691  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2692  "reinit filtergraph on input parameter changes", "" },
2693  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2694  "create a complex filtergraph", "graph_description" },
2695  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2696  "create a complex filtergraph", "graph_description" },
2697  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2698  "read complex filtergraph description from a file", "filename" },
2699  { "stats", OPT_BOOL, { &print_stats },
2700  "print progress report during encoding", },
2701  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2702  OPT_OUTPUT, { .func_arg = opt_attach },
2703  "add an attachment to the output file", "filename" },
2704  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2705  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2706  "extract an attachment into a file", "filename" },
2707  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2708  "print timestamp debugging info" },
2709 
2710  /* video options */
2711  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2712  "set the number of video frames to record", "number" },
2713  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2714  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2715  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2717  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2718  "set frame size (WxH or abbreviation)", "size" },
2719  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2720  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2721  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2722  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2723  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2724  "set pixel format", "format" },
2725  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2726  "set the number of bits per raw sample", "number" },
2727  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2728  "deprecated use -g 1" },
2730  "disable video" },
2731  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2732  "discard threshold", "n" },
2733  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2734  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2735  "rate control override for specific intervals", "override" },
2736  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2737  OPT_OUTPUT, { .func_arg = opt_video_codec },
2738  "force video codec ('copy' to copy stream)", "codec" },
2739  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2740  "Removed" },
2741  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2742  "Removed" },
2743  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2744  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2745  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2746  "select the pass number (1 to 3)", "n" },
2747  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2748  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2749  "select two pass log file name prefix", "prefix" },
2750  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2751  "this option is deprecated, use the yadif filter instead" },
2752  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2753  "calculate PSNR of compressed frames" },
2754  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2755  "dump video coding statistics to file" },
2756  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2757  "dump video coding statistics to file", "file" },
2758  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2759  "set video filters", "filter_graph" },
2760  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2761  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2762  "specify intra matrix coeffs", "matrix" },
2763  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2764  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2765  "specify inter matrix coeffs", "matrix" },
2766  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2767  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2768  "top=1/bottom=0/auto=-1 field first", "" },
2769  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2770  "intra_dc_precision", "precision" },
2771  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2772  OPT_OUTPUT, { .func_arg = opt_old2new },
2773  "force video tag/fourcc", "fourcc/tag" },
2774  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2775  "show QP histogram" },
2776  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2777  OPT_OUTPUT, { .off = OFFSET(force_fps) },
2778  "force the selected framerate, disable the best supported framerate selection" },
2779  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2780  OPT_OUTPUT, { .func_arg = opt_streamid },
2781  "set the value of an outfile streamid", "streamIndex:value" },
2782  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2783  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2784  "force key frames at specified timestamps", "timestamps" },
2785  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2786  "video bitrate (please use -b:v)", "bitrate" },
2787 
2788  /* audio options */
2789  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2790  "set the number of audio frames to record", "number" },
2791  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2792  "set audio quality (codec-specific)", "quality", },
2793  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2794  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2795  "set audio sampling rate (in Hz)", "rate" },
2796  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2797  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2798  "set number of audio channels", "channels" },
2800  "disable audio" },
2801  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2802  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2803  "force audio codec ('copy' to copy stream)", "codec" },
2804  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2805  OPT_OUTPUT, { .func_arg = opt_old2new },
2806  "force audio tag/fourcc", "fourcc/tag" },
2807  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2808  "change audio volume (256=normal)" , "volume" },
2809  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2811  "set sample format", "format" },
2812  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2813  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2814  "set channel layout", "layout" },
2815  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2816  "set audio filters", "filter_graph" },
2817  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2818  "set the maximum number of channels to try to guess the channel layout" },
2819 
2820  /* subtitle options */
2822  "disable subtitle" },
2823  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2824  "force subtitle codec ('copy' to copy stream)", "codec" },
2825  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2826  , "force subtitle tag/fourcc", "fourcc/tag" },
2827  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2828  "fix subtitles duration" },
2829  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2830  "set canvas size (WxH or abbreviation)", "size" },
2831 
2832  /* grab options */
2833  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2834  "deprecated, use -channel", "channel" },
2835  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2836  "deprecated, use -standard", "standard" },
2837  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2838 
2839  /* muxer options */
2840  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2841  "set the maximum demux-decode delay", "seconds" },
2842  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2843  "set the initial demux-decode delay", "seconds" },
2844  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2845  "override the options from ffserver", "" },
2846 
2847  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2848  "A comma-separated list of bitstream filters", "bitstream_filters" },
2849  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2850  "deprecated", "audio bitstream_filters" },
2851  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2852  "deprecated", "video bitstream_filters" },
2853 
2854  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2855  "set the audio options to the indicated preset", "preset" },
2856  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2857  "set the video options to the indicated preset", "preset" },
2858  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2859  "set the subtitle options to the indicated preset", "preset" },
2860  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2861  "set options from indicated preset file", "filename" },
2862  /* data codec support */
2863  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2864  "force data codec ('copy' to copy stream)", "codec" },
2865  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2866  "disable data" },
2867 
2868  { NULL, },
2869 };