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