Libav
avconv_opt.c
Go to the documentation of this file.
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; 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 "avconv.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 const HWAccel hwaccels[] = {
57 #if HAVE_VDPAU_X11
59 #endif
60  { 0 },
61 };
62 
64 
67 
68 int audio_volume = 256;
71 int do_benchmark = 0;
72 int do_hex_dump = 0;
73 int do_pkt_dump = 0;
74 int copy_ts = 0;
75 int copy_tb = 1;
76 int exit_on_error = 0;
77 int print_stats = 1;
78 int qp_hist = 0;
79 
80 static int file_overwrite = 0;
81 static int file_skip = 0;
82 static int video_discard = 0;
83 static int intra_dc_precision = 8;
84 static int using_stdin = 0;
85 static int input_sync;
86 
88 {
89  const OptionDef *po = options;
90  int i;
91 
92  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
93  while (po->name) {
94  void *dst = (uint8_t*)o + po->u.off;
95 
96  if (po->flags & OPT_SPEC) {
97  SpecifierOpt **so = dst;
98  int i, *count = (int*)(so + 1);
99  for (i = 0; i < *count; i++) {
100  av_freep(&(*so)[i].specifier);
101  if (po->flags & OPT_STRING)
102  av_freep(&(*so)[i].u.str);
103  }
104  av_freep(so);
105  *count = 0;
106  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
107  av_freep(dst);
108  po++;
109  }
110 
111  for (i = 0; i < o->nb_stream_maps; i++)
113  av_freep(&o->stream_maps);
115  av_freep(&o->streamid_map);
116 }
117 
119 {
120  memset(o, 0, sizeof(*o));
121 
122  o->mux_max_delay = 0.7;
124  o->recording_time = INT64_MAX;
125  o->limit_filesize = UINT64_MAX;
126  o->chapters_input_file = INT_MAX;
127  o->accurate_seek = 1;
128 }
129 
130 /* return a copy of the input with the stream specifiers removed from the keys */
132 {
133  AVDictionaryEntry *e = NULL;
134  AVDictionary *ret = NULL;
135 
136  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
137  char *p = strchr(e->key, ':');
138 
139  if (p)
140  *p = 0;
141  av_dict_set(&ret, e->key, e->value, 0);
142  if (p)
143  *p = ':';
144  }
145  return ret;
146 }
147 
148 static double parse_frame_aspect_ratio(const char *arg)
149 {
150  int x = 0, y = 0;
151  double ar = 0;
152  const char *p;
153  char *end;
154 
155  p = strchr(arg, ':');
156  if (p) {
157  x = strtol(arg, &end, 10);
158  if (end == p)
159  y = strtol(end + 1, &end, 10);
160  if (x > 0 && y > 0)
161  ar = (double)x / (double)y;
162  } else
163  ar = strtod(arg, NULL);
164 
165  if (!ar) {
166  av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
167  exit_program(1);
168  }
169  return ar;
170 }
171 
172 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
173 {
174  OptionsContext *o = optctx;
175  return parse_option(o, "codec:a", arg, options);
176 }
177 
178 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
179 {
180  OptionsContext *o = optctx;
181  return parse_option(o, "codec:v", arg, options);
182 }
183 
184 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
185 {
186  OptionsContext *o = optctx;
187  return parse_option(o, "codec:s", arg, options);
188 }
189 
190 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
191 {
192  OptionsContext *o = optctx;
193  return parse_option(o, "codec:d", arg, options);
194 }
195 
196 static int opt_map(void *optctx, const char *opt, const char *arg)
197 {
198  OptionsContext *o = optctx;
199  StreamMap *m = NULL;
200  int i, negative = 0, file_idx;
201  int sync_file_idx = -1, sync_stream_idx;
202  char *p, *sync;
203  char *map;
204 
205  if (*arg == '-') {
206  negative = 1;
207  arg++;
208  }
209  map = av_strdup(arg);
210 
211  /* parse sync stream first, just pick first matching stream */
212  if (sync = strchr(map, ',')) {
213  *sync = 0;
214  sync_file_idx = strtol(sync + 1, &sync, 0);
215  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
216  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
217  exit_program(1);
218  }
219  if (*sync)
220  sync++;
221  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
222  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
223  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
224  sync_stream_idx = i;
225  break;
226  }
227  if (i == input_files[sync_file_idx]->nb_streams) {
228  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
229  "match any streams.\n", arg);
230  exit_program(1);
231  }
232  }
233 
234 
235  if (map[0] == '[') {
236  /* this mapping refers to lavfi output */
237  const char *c = map + 1;
239  m = &o->stream_maps[o->nb_stream_maps - 1];
240  m->linklabel = av_get_token(&c, "]");
241  if (!m->linklabel) {
242  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
243  exit_program(1);
244  }
245  } else {
246  file_idx = strtol(map, &p, 0);
247  if (file_idx >= nb_input_files || file_idx < 0) {
248  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
249  exit_program(1);
250  }
251  if (negative)
252  /* disable some already defined maps */
253  for (i = 0; i < o->nb_stream_maps; i++) {
254  m = &o->stream_maps[i];
255  if (file_idx == m->file_index &&
258  *p == ':' ? p + 1 : p) > 0)
259  m->disabled = 1;
260  }
261  else
262  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
263  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
264  *p == ':' ? p + 1 : p) <= 0)
265  continue;
267  m = &o->stream_maps[o->nb_stream_maps - 1];
268 
269  m->file_index = file_idx;
270  m->stream_index = i;
271 
272  if (sync_file_idx >= 0) {
273  m->sync_file_index = sync_file_idx;
274  m->sync_stream_index = sync_stream_idx;
275  } else {
276  m->sync_file_index = file_idx;
277  m->sync_stream_index = i;
278  }
279  }
280  }
281 
282  if (!m) {
283  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
284  exit_program(1);
285  }
286 
287  av_freep(&map);
288  return 0;
289 }
290 
291 static int opt_attach(void *optctx, const char *opt, const char *arg)
292 {
293  OptionsContext *o = optctx;
295  o->attachments[o->nb_attachments - 1] = arg;
296  return 0;
297 }
298 
306 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
307 {
308  if (*arg) {
309  *type = *arg;
310  switch (*arg) {
311  case 'g':
312  break;
313  case 's':
314  if (*(++arg) && *arg != ':') {
315  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
316  exit_program(1);
317  }
318  *stream_spec = *arg == ':' ? arg + 1 : "";
319  break;
320  case 'c':
321  case 'p':
322  if (*(++arg) == ':')
323  *index = strtol(++arg, NULL, 0);
324  break;
325  default:
326  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
327  exit_program(1);
328  }
329  } else
330  *type = 'g';
331 }
332 
333 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
334 {
335  AVDictionary **meta_in = NULL;
336  AVDictionary **meta_out;
337  int i, ret = 0;
338  char type_in, type_out;
339  const char *istream_spec = NULL, *ostream_spec = NULL;
340  int idx_in = 0, idx_out = 0;
341 
342  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
343  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
344 
345  if (type_in == 'g' || type_out == 'g')
346  o->metadata_global_manual = 1;
347  if (type_in == 's' || type_out == 's')
349  if (type_in == 'c' || type_out == 'c')
351 
352  /* ic is NULL when just disabling automatic mappings */
353  if (!ic)
354  return 0;
355 
356 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
357  if ((index) < 0 || (index) >= (nb_elems)) {\
358  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
359  (desc), (index));\
360  exit_program(1);\
361  }
362 
363 #define SET_DICT(type, meta, context, index)\
364  switch (type) {\
365  case 'g':\
366  meta = &context->metadata;\
367  break;\
368  case 'c':\
369  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
370  meta = &context->chapters[index]->metadata;\
371  break;\
372  case 'p':\
373  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
374  meta = &context->programs[index]->metadata;\
375  break;\
376  case 's':\
377  break; /* handled separately below */ \
378  default: av_assert0(0);\
379  }\
380 
381  SET_DICT(type_in, meta_in, ic, idx_in);
382  SET_DICT(type_out, meta_out, oc, idx_out);
383 
384  /* for input streams choose first matching stream */
385  if (type_in == 's') {
386  for (i = 0; i < ic->nb_streams; i++) {
387  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
388  meta_in = &ic->streams[i]->metadata;
389  break;
390  } else if (ret < 0)
391  exit_program(1);
392  }
393  if (!meta_in) {
394  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
395  exit_program(1);
396  }
397  }
398 
399  if (type_out == 's') {
400  for (i = 0; i < oc->nb_streams; i++) {
401  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
402  meta_out = &oc->streams[i]->metadata;
403  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
404  } else if (ret < 0)
405  exit_program(1);
406  }
407  } else
408  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
409 
410  return 0;
411 }
412 
413 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
414 {
415  const AVCodecDescriptor *desc;
416  const char *codec_string = encoder ? "encoder" : "decoder";
417  AVCodec *codec;
418 
419  codec = encoder ?
422 
423  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
424  codec = encoder ? avcodec_find_encoder(desc->id) :
425  avcodec_find_decoder(desc->id);
426  if (codec)
427  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
428  codec_string, codec->name, desc->name);
429  }
430 
431  if (!codec) {
432  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
433  exit_program(1);
434  }
435  if (codec->type != type) {
436  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
437  exit_program(1);
438  }
439  return codec;
440 }
441 
443 {
444  char *codec_name = NULL;
445 
446  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
447  if (codec_name) {
448  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
449  st->codec->codec_id = codec->id;
450  return codec;
451  } else
452  return avcodec_find_decoder(st->codec->codec_id);
453 }
454 
455 /* Add all the streams from the given input file to the global
456  * list of input streams. */
458 {
459  int i;
460 
461  for (i = 0; i < ic->nb_streams; i++) {
462  AVStream *st = ic->streams[i];
463  AVCodecContext *dec = st->codec;
464  InputStream *ist = av_mallocz(sizeof(*ist));
465  char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
466 
467  if (!ist)
468  exit_program(1);
469 
471  input_streams[nb_input_streams - 1] = ist;
472 
473  ist->st = st;
474  ist->file_index = nb_input_files;
475  ist->discard = 1;
476  st->discard = AVDISCARD_ALL;
477 
478  ist->ts_scale = 1.0;
479  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
480 
481  ist->dec = choose_decoder(o, ic, st);
482  ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
483 
484  switch (dec->codec_type) {
485  case AVMEDIA_TYPE_VIDEO:
486  ist->resample_height = dec->height;
487  ist->resample_width = dec->width;
488  ist->resample_pix_fmt = dec->pix_fmt;
489 
490  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
491  if (framerate && av_parse_video_rate(&ist->framerate,
492  framerate) < 0) {
493  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
494  framerate);
495  exit_program(1);
496  }
497 
498  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
499  if (hwaccel) {
500  if (!strcmp(hwaccel, "none"))
501  ist->hwaccel_id = HWACCEL_NONE;
502  else if (!strcmp(hwaccel, "auto"))
503  ist->hwaccel_id = HWACCEL_AUTO;
504  else {
505  int i;
506  for (i = 0; hwaccels[i].name; i++) {
507  if (!strcmp(hwaccels[i].name, hwaccel)) {
508  ist->hwaccel_id = hwaccels[i].id;
509  break;
510  }
511  }
512 
513  if (!ist->hwaccel_id) {
514  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
515  hwaccel);
516  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
517  for (i = 0; hwaccels[i].name; i++)
518  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
519  av_log(NULL, AV_LOG_FATAL, "\n");
520  exit_program(1);
521  }
522  }
523  }
524 
525  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
526  if (hwaccel_device) {
527  ist->hwaccel_device = av_strdup(hwaccel_device);
528  if (!ist->hwaccel_device)
529  exit_program(1);
530  }
532 
533  break;
534  case AVMEDIA_TYPE_AUDIO:
536 
537  ist->resample_sample_fmt = dec->sample_fmt;
538  ist->resample_sample_rate = dec->sample_rate;
539  ist->resample_channels = dec->channels;
541 
542  break;
543  case AVMEDIA_TYPE_DATA:
547  break;
548  default:
549  abort();
550  }
551  }
552 }
553 
554 static void assert_file_overwrite(const char *filename)
555 {
556  if (file_overwrite && file_skip) {
557  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
558  exit_program(1);
559  }
560 
561  if (!file_overwrite &&
562  (strchr(filename, ':') == NULL || filename[1] == ':' ||
563  av_strstart(filename, "file:", NULL))) {
564  if (avio_check(filename, 0) == 0) {
565  if (!using_stdin && !file_skip) {
566  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
567  fflush(stderr);
568  if (!read_yesno()) {
569  fprintf(stderr, "Not overwriting - exiting\n");
570  exit_program(1);
571  }
572  }
573  else {
574  fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
575  exit_program(1);
576  }
577  }
578  }
579 }
580 
581 static void dump_attachment(AVStream *st, const char *filename)
582 {
583  int ret;
584  AVIOContext *out = NULL;
586 
587  if (!st->codec->extradata_size) {
588  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
589  nb_input_files - 1, st->index);
590  return;
591  }
592  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
593  filename = e->value;
594  if (!*filename) {
595  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
596  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
597  exit_program(1);
598  }
599 
600  assert_file_overwrite(filename);
601 
602  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
603  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
604  filename);
605  exit_program(1);
606  }
607 
608  avio_write(out, st->codec->extradata, st->codec->extradata_size);
609  avio_flush(out);
610  avio_close(out);
611 }
612 
613 static int open_input_file(OptionsContext *o, const char *filename)
614 {
615  InputFile *f;
616  AVFormatContext *ic;
618  int err, i, ret;
619  int64_t timestamp;
620  uint8_t buf[128];
621  AVDictionary **opts;
622  AVDictionary *unused_opts = NULL;
623  AVDictionaryEntry *e = NULL;
624  int orig_nb_streams; // number of streams before avformat_find_stream_info
625 
626  if (o->format) {
627  if (!(file_iformat = av_find_input_format(o->format))) {
628  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
629  exit_program(1);
630  }
631  }
632 
633  if (!strcmp(filename, "-"))
634  filename = "pipe:";
635 
636  using_stdin |= !strncmp(filename, "pipe:", 5) ||
637  !strcmp(filename, "/dev/stdin");
638 
639  /* get default parameters from command line */
640  ic = avformat_alloc_context();
641  if (!ic) {
642  print_error(filename, AVERROR(ENOMEM));
643  exit_program(1);
644  }
645  if (o->nb_audio_sample_rate) {
646  snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
647  av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
648  }
649  if (o->nb_audio_channels) {
650  /* because we set audio_channels based on both the "ac" and
651  * "channel_layout" options, we need to check that the specified
652  * demuxer actually has the "channels" option before setting it */
653  if (file_iformat && file_iformat->priv_class &&
654  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
656  snprintf(buf, sizeof(buf), "%d",
657  o->audio_channels[o->nb_audio_channels - 1].u.i);
658  av_dict_set(&o->g->format_opts, "channels", buf, 0);
659  }
660  }
661  if (o->nb_frame_rates) {
662  /* set the format-level framerate option;
663  * this is important for video grabbers, e.g. x11 */
664  if (file_iformat && file_iformat->priv_class &&
665  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
667  av_dict_set(&o->g->format_opts, "framerate",
668  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
669  }
670  }
671  if (o->nb_frame_sizes) {
672  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
673  }
674  if (o->nb_frame_pix_fmts)
675  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
676 
677  ic->flags |= AVFMT_FLAG_NONBLOCK;
679 
680  /* open the input file with generic libav function */
681  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
682  if (err < 0) {
683  print_error(filename, err);
684  exit_program(1);
685  }
687 
688  /* apply forced codec ids */
689  for (i = 0; i < ic->nb_streams; i++)
690  choose_decoder(o, ic, ic->streams[i]);
691 
692  /* Set AVCodecContext options for avformat_find_stream_info */
693  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
694  orig_nb_streams = ic->nb_streams;
695 
696  /* If not enough info to get the stream parameters, we decode the
697  first frames to get it. (used in mpeg case for example) */
698  ret = avformat_find_stream_info(ic, opts);
699  if (ret < 0) {
700  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
702  exit_program(1);
703  }
704 
705  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
706  /* add the stream start time */
707  if (ic->start_time != AV_NOPTS_VALUE)
708  timestamp += ic->start_time;
709 
710  /* if seeking requested, we execute it */
711  if (o->start_time != AV_NOPTS_VALUE) {
712  ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
713  if (ret < 0) {
714  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
715  filename, (double)timestamp / AV_TIME_BASE);
716  }
717  }
718 
719  /* update the current parameters so that they match the one of the input stream */
720  add_input_streams(o, ic);
721 
722  /* dump the file content */
723  av_dump_format(ic, nb_input_files, filename, 0);
724 
726  f = av_mallocz(sizeof(*f));
727  if (!f)
728  exit_program(1);
729  input_files[nb_input_files - 1] = f;
730 
731  f->ctx = ic;
733  f->start_time = o->start_time;
735  f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
736  f->nb_streams = ic->nb_streams;
737  f->rate_emu = o->rate_emu;
739 
740  /* check if all codec options have been used */
741  unused_opts = strip_specifiers(o->g->codec_opts);
742  for (i = f->ist_index; i < nb_input_streams; i++) {
743  e = NULL;
744  while ((e = av_dict_get(input_streams[i]->opts, "", e,
746  av_dict_set(&unused_opts, e->key, NULL, 0);
747  }
748 
749  e = NULL;
750  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
751  const AVClass *class = avcodec_get_class();
752  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
754  if (!option)
755  continue;
756  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
757  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
758  "input file #%d (%s) is not a decoding option.\n", e->key,
759  option->help ? option->help : "", nb_input_files - 1,
760  filename);
761  exit_program(1);
762  }
763 
764  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
765  "input file #%d (%s) has not been used for any stream. The most "
766  "likely reason is either wrong type (e.g. a video option with "
767  "no video streams) or that it is a private option of some decoder "
768  "which was not actually used for any stream.\n", e->key,
769  option->help ? option->help : "", nb_input_files - 1, filename);
770  }
771  av_dict_free(&unused_opts);
772 
773  for (i = 0; i < o->nb_dump_attachment; i++) {
774  int j;
775 
776  for (j = 0; j < ic->nb_streams; j++) {
777  AVStream *st = ic->streams[j];
778 
779  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
781  }
782  }
783 
784  for (i = 0; i < orig_nb_streams; i++)
785  av_dict_free(&opts[i]);
786  av_freep(&opts);
787 
788  return 0;
789 }
790 
792 {
793  AVIOContext *line;
794  uint8_t *buf;
795  char c;
796 
797  if (avio_open_dyn_buf(&line) < 0) {
798  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
799  exit_program(1);
800  }
801 
802  while ((c = avio_r8(s)) && c != '\n')
803  avio_w8(line, c);
804  avio_w8(line, 0);
805  avio_close_dyn_buf(line, &buf);
806 
807  return buf;
808 }
809 
810 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
811 {
812  int i, ret = 1;
813  char filename[1000];
814  const char *base[3] = { getenv("AVCONV_DATADIR"),
815  getenv("HOME"),
817  };
818 
819  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
820  if (!base[i])
821  continue;
822  if (codec_name) {
823  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
824  i != 1 ? "" : "/.avconv", codec_name, preset_name);
825  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
826  }
827  if (ret) {
828  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
829  i != 1 ? "" : "/.avconv", preset_name);
830  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
831  }
832  }
833  return ret;
834 }
835 
837 {
838  char *codec_name = NULL;
839 
840  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
841  if (!codec_name) {
843  NULL, ost->st->codec->codec_type);
844  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
845  } else if (!strcmp(codec_name, "copy"))
846  ost->stream_copy = 1;
847  else {
848  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
849  ost->st->codec->codec_id = ost->enc->id;
850  }
851 }
852 
854 {
855  OutputStream *ost;
856  AVStream *st = avformat_new_stream(oc, NULL);
857  int idx = oc->nb_streams - 1, ret = 0;
858  char *bsf = NULL, *next, *codec_tag = NULL;
859  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
860  double qscale = -1;
861 
862  if (!st) {
863  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
864  exit_program(1);
865  }
866 
867  if (oc->nb_streams - 1 < o->nb_streamid_map)
868  st->id = o->streamid_map[oc->nb_streams - 1];
869 
871  if (!(ost = av_mallocz(sizeof(*ost))))
872  exit_program(1);
874 
875  ost->file_index = nb_output_files - 1;
876  ost->index = idx;
877  ost->st = st;
878  st->codec->codec_type = type;
879  choose_encoder(o, oc, ost);
880  if (ost->enc) {
881  AVIOContext *s = NULL;
882  char *buf = NULL, *arg = NULL, *preset = NULL;
883 
884  ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
885 
886  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
887  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
888  do {
889  buf = get_line(s);
890  if (!buf[0] || buf[0] == '#') {
891  av_free(buf);
892  continue;
893  }
894  if (!(arg = strchr(buf, '='))) {
895  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
896  exit_program(1);
897  }
898  *arg++ = 0;
899  av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
900  av_free(buf);
901  } while (!s->eof_reached);
902  avio_close(s);
903  }
904  if (ret) {
906  "Preset %s specified for stream %d:%d, but could not be opened.\n",
907  preset, ost->file_index, ost->index);
908  exit_program(1);
909  }
910  } else {
911  ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
912  }
913 
915  st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
916 
917  ost->max_frames = INT64_MAX;
918  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
919 
920  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
921  while (bsf) {
922  if (next = strchr(bsf, ','))
923  *next++ = 0;
924  if (!(bsfc = av_bitstream_filter_init(bsf))) {
925  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
926  exit_program(1);
927  }
928  if (bsfc_prev)
929  bsfc_prev->next = bsfc;
930  else
931  ost->bitstream_filters = bsfc;
932 
933  bsfc_prev = bsfc;
934  bsf = next;
935  }
936 
937  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
938  if (codec_tag) {
939  uint32_t tag = strtol(codec_tag, &next, 0);
940  if (*next)
941  tag = AV_RL32(codec_tag);
942  st->codec->codec_tag = tag;
943  }
944 
945  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
946  if (qscale >= 0) {
947  st->codec->flags |= CODEC_FLAG_QSCALE;
948  st->codec->global_quality = FF_QP2LAMBDA * qscale;
949  }
950 
951  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
953 
954  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
955 
956  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
957 
958  ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
960 
961  return ost;
962 }
963 
964 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
965 {
966  int i;
967  const char *p = str;
968  for (i = 0;; i++) {
969  dest[i] = atoi(p);
970  if (i == 63)
971  break;
972  p = strchr(p, ',');
973  if (!p) {
974  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
975  exit_program(1);
976  }
977  p++;
978  }
979 }
980 
981 /* read file contents into a string */
982 static uint8_t *read_file(const char *filename)
983 {
984  AVIOContext *pb = NULL;
985  AVIOContext *dyn_buf = NULL;
986  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
987  uint8_t buf[1024], *str;
988 
989  if (ret < 0) {
990  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
991  return NULL;
992  }
993 
994  ret = avio_open_dyn_buf(&dyn_buf);
995  if (ret < 0) {
996  avio_closep(&pb);
997  return NULL;
998  }
999  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1000  avio_write(dyn_buf, buf, ret);
1001  avio_w8(dyn_buf, 0);
1002  avio_closep(&pb);
1003 
1004  ret = avio_close_dyn_buf(dyn_buf, &str);
1005  if (ret < 0)
1006  return NULL;
1007  return str;
1008 }
1009 
1011  OutputStream *ost)
1012 {
1013  AVStream *st = ost->st;
1014  char *filter = NULL, *filter_script = NULL;
1015 
1016  MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1017  MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1018 
1019  if (filter_script && filter) {
1020  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1021  "output stream #%d:%d.\n", nb_output_files, st->index);
1022  exit_program(1);
1023  }
1024 
1025  if (filter_script)
1026  return read_file(filter_script);
1027  else if (filter)
1028  return av_strdup(filter);
1029 
1030  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1031  "null" : "anull");
1032 }
1033 
1035 {
1036  AVStream *st;
1037  OutputStream *ost;
1038  AVCodecContext *video_enc;
1039  char *frame_aspect_ratio = NULL;
1040 
1041  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1042  st = ost->st;
1043  video_enc = st->codec;
1044 
1045  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1046  if (frame_aspect_ratio)
1047  ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1048 
1049  if (!ost->stream_copy) {
1050  const char *p = NULL;
1051  char *frame_rate = NULL, *frame_size = NULL;
1052  char *frame_pix_fmt = NULL;
1053  char *intra_matrix = NULL, *inter_matrix = NULL;
1054  int do_pass = 0;
1055  int i;
1056 
1057  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1058  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1059  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1060  exit_program(1);
1061  }
1062 
1063  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1064  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1065  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1066  exit_program(1);
1067  }
1068 
1069  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1070  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1071  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1072  exit_program(1);
1073  }
1074  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1075 
1076  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1077  if (intra_matrix) {
1078  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1079  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1080  exit_program(1);
1081  }
1082  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1083  }
1084  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1085  if (inter_matrix) {
1086  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1087  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1088  exit_program(1);
1089  }
1090  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1091  }
1092 
1093  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1094  for (i = 0; p; i++) {
1095  int start, end, q;
1096  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1097  if (e != 3) {
1098  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1099  exit_program(1);
1100  }
1101  video_enc->rc_override =
1102  av_realloc(video_enc->rc_override,
1103  sizeof(RcOverride) * (i + 1));
1104  video_enc->rc_override[i].start_frame = start;
1105  video_enc->rc_override[i].end_frame = end;
1106  if (q > 0) {
1107  video_enc->rc_override[i].qscale = q;
1108  video_enc->rc_override[i].quality_factor = 1.0;
1109  }
1110  else {
1111  video_enc->rc_override[i].qscale = 0;
1112  video_enc->rc_override[i].quality_factor = -q/100.0;
1113  }
1114  p = strchr(p, '/');
1115  if (p) p++;
1116  }
1117  video_enc->rc_override_count = i;
1118  video_enc->intra_dc_precision = intra_dc_precision - 8;
1119 
1120  /* two pass mode */
1121  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1122  if (do_pass) {
1123  if (do_pass == 1) {
1124  video_enc->flags |= CODEC_FLAG_PASS1;
1125  } else {
1126  video_enc->flags |= CODEC_FLAG_PASS2;
1127  }
1128  }
1129 
1130  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1131  if (ost->logfile_prefix &&
1132  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1133  exit_program(1);
1134 
1135  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1136  if (ost->forced_keyframes)
1138 
1139  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1140 
1141  ost->top_field_first = -1;
1142  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1143 
1144 
1145  ost->avfilter = get_ost_filters(o, oc, ost);
1146  if (!ost->avfilter)
1147  exit_program(1);
1148  } else {
1149  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1150  }
1151 
1152  return ost;
1153 }
1154 
1156 {
1157  AVStream *st;
1158  OutputStream *ost;
1159  AVCodecContext *audio_enc;
1160 
1161  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1162  st = ost->st;
1163 
1164  audio_enc = st->codec;
1165  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1166 
1167  if (!ost->stream_copy) {
1168  char *sample_fmt = NULL;
1169 
1170  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1171 
1172  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1173  if (sample_fmt &&
1174  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1175  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1176  exit_program(1);
1177  }
1178 
1179  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1180 
1181  ost->avfilter = get_ost_filters(o, oc, ost);
1182  if (!ost->avfilter)
1183  exit_program(1);
1184  }
1185 
1186  return ost;
1187 }
1188 
1190 {
1191  OutputStream *ost;
1192 
1193  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1194  if (!ost->stream_copy) {
1195  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1196  exit_program(1);
1197  }
1198 
1199  return ost;
1200 }
1201 
1203 {
1205  ost->stream_copy = 1;
1206  ost->finished = 1;
1207  return ost;
1208 }
1209 
1211 {
1212  AVStream *st;
1213  OutputStream *ost;
1214  AVCodecContext *subtitle_enc;
1215 
1217  st = ost->st;
1218  subtitle_enc = st->codec;
1219 
1220  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1221 
1222  return ost;
1223 }
1224 
1225 /* arg format is "output-stream-index:streamid-value". */
1226 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1227 {
1228  OptionsContext *o = optctx;
1229  int idx;
1230  char *p;
1231  char idx_str[16];
1232 
1233  av_strlcpy(idx_str, arg, sizeof(idx_str));
1234  p = strchr(idx_str, ':');
1235  if (!p) {
1237  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1238  arg, opt);
1239  exit_program(1);
1240  }
1241  *p++ = '\0';
1242  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1243  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1244  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1245  return 0;
1246 }
1247 
1248 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1249 {
1250  AVFormatContext *is = ifile->ctx;
1251  AVFormatContext *os = ofile->ctx;
1252  AVChapter **tmp;
1253  int i;
1254 
1255  tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1256  if (!tmp)
1257  return AVERROR(ENOMEM);
1258  os->chapters = tmp;
1259 
1260  for (i = 0; i < is->nb_chapters; i++) {
1261  AVChapter *in_ch = is->chapters[i], *out_ch;
1262  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1263  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1264  AV_TIME_BASE_Q, in_ch->time_base);
1265  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1267 
1268 
1269  if (in_ch->end < ts_off)
1270  continue;
1271  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1272  break;
1273 
1274  out_ch = av_mallocz(sizeof(AVChapter));
1275  if (!out_ch)
1276  return AVERROR(ENOMEM);
1277 
1278  out_ch->id = in_ch->id;
1279  out_ch->time_base = in_ch->time_base;
1280  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1281  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1282 
1283  if (copy_metadata)
1284  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1285 
1286  os->chapters[os->nb_chapters++] = out_ch;
1287  }
1288  return 0;
1289 }
1290 
1292  AVFormatContext *oc)
1293 {
1294  OutputStream *ost;
1295 
1297  ofilter->out_tmp->pad_idx)) {
1298  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1299  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1300  default:
1301  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1302  "currently.\n");
1303  exit_program(1);
1304  }
1305 
1306  ost->source_index = -1;
1307  ost->filter = ofilter;
1308 
1309  ofilter->ost = ost;
1310 
1311  if (ost->stream_copy) {
1312  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1313  "which is fed from a complex filtergraph. Filtering and streamcopy "
1314  "cannot be used together.\n", ost->file_index, ost->index);
1315  exit_program(1);
1316  }
1317 
1318  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1319  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1320  exit_program(1);
1321  }
1322  avfilter_inout_free(&ofilter->out_tmp);
1323 }
1324 
1326 {
1327  int i, ret = 0;
1328 
1329  for (i = 0; i < nb_filtergraphs; i++)
1330  if (!filtergraphs[i]->graph &&
1331  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1332  return ret;
1333  return 0;
1334 }
1335 
1336 static int open_output_file(OptionsContext *o, const char *filename)
1337 {
1338  AVFormatContext *oc;
1339  int i, j, err;
1340  AVOutputFormat *file_oformat;
1341  OutputFile *of;
1342  OutputStream *ost;
1343  InputStream *ist;
1344  AVDictionary *unused_opts = NULL;
1345  AVDictionaryEntry *e = NULL;
1346 
1347  if (configure_complex_filters() < 0) {
1348  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1349  exit_program(1);
1350  }
1351 
1353  of = av_mallocz(sizeof(*of));
1354  if (!of)
1355  exit_program(1);
1356  output_files[nb_output_files - 1] = of;
1357 
1359  of->recording_time = o->recording_time;
1360  of->start_time = o->start_time;
1361  of->limit_filesize = o->limit_filesize;
1362  of->shortest = o->shortest;
1363  av_dict_copy(&of->opts, o->g->format_opts, 0);
1364 
1365  if (!strcmp(filename, "-"))
1366  filename = "pipe:";
1367 
1368  oc = avformat_alloc_context();
1369  if (!oc) {
1370  print_error(filename, AVERROR(ENOMEM));
1371  exit_program(1);
1372  }
1373  of->ctx = oc;
1374  if (o->recording_time != INT64_MAX)
1375  oc->duration = o->recording_time;
1376 
1377  if (o->format) {
1378  file_oformat = av_guess_format(o->format, NULL, NULL);
1379  if (!file_oformat) {
1380  av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1381  exit_program(1);
1382  }
1383  } else {
1384  file_oformat = av_guess_format(NULL, filename, NULL);
1385  if (!file_oformat) {
1386  av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1387  filename);
1388  exit_program(1);
1389  }
1390  }
1391 
1392  oc->oformat = file_oformat;
1393  oc->interrupt_callback = int_cb;
1394  av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1395 
1396  /* create streams for all unlabeled output pads */
1397  for (i = 0; i < nb_filtergraphs; i++) {
1398  FilterGraph *fg = filtergraphs[i];
1399  for (j = 0; j < fg->nb_outputs; j++) {
1400  OutputFilter *ofilter = fg->outputs[j];
1401 
1402  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1403  continue;
1404 
1406  ofilter->out_tmp->pad_idx)) {
1407  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1408  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1409  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1410  }
1411  init_output_filter(ofilter, o, oc);
1412  }
1413  }
1414 
1415  if (!o->nb_stream_maps) {
1416  /* pick the "best" stream of each type */
1417 #define NEW_STREAM(type, index)\
1418  if (index >= 0) {\
1419  ost = new_ ## type ## _stream(o, oc);\
1420  ost->source_index = index;\
1421  ost->sync_ist = input_streams[index];\
1422  input_streams[index]->discard = 0;\
1423  input_streams[index]->st->discard = AVDISCARD_NONE;\
1424  }
1425 
1426  /* video: highest resolution */
1427  if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1428  int area = 0, idx = -1;
1429  for (i = 0; i < nb_input_streams; i++) {
1430  ist = input_streams[i];
1431  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1432  ist->st->codec->width * ist->st->codec->height > area) {
1433  area = ist->st->codec->width * ist->st->codec->height;
1434  idx = i;
1435  }
1436  }
1437  NEW_STREAM(video, idx);
1438  }
1439 
1440  /* audio: most channels */
1441  if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1442  int channels = 0, idx = -1;
1443  for (i = 0; i < nb_input_streams; i++) {
1444  ist = input_streams[i];
1445  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1446  ist->st->codec->channels > channels) {
1447  channels = ist->st->codec->channels;
1448  idx = i;
1449  }
1450  }
1451  NEW_STREAM(audio, idx);
1452  }
1453 
1454  /* subtitles: pick first */
1456  for (i = 0; i < nb_input_streams; i++)
1457  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1458  NEW_STREAM(subtitle, i);
1459  break;
1460  }
1461  }
1462  /* do something with data? */
1463  } else {
1464  for (i = 0; i < o->nb_stream_maps; i++) {
1465  StreamMap *map = &o->stream_maps[i];
1466 
1467  if (map->disabled)
1468  continue;
1469 
1470  if (map->linklabel) {
1471  FilterGraph *fg;
1472  OutputFilter *ofilter = NULL;
1473  int j, k;
1474 
1475  for (j = 0; j < nb_filtergraphs; j++) {
1476  fg = filtergraphs[j];
1477  for (k = 0; k < fg->nb_outputs; k++) {
1478  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1479  if (out && !strcmp(out->name, map->linklabel)) {
1480  ofilter = fg->outputs[k];
1481  goto loop_end;
1482  }
1483  }
1484  }
1485 loop_end:
1486  if (!ofilter) {
1487  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1488  "in any defined filter graph.\n", map->linklabel);
1489  exit_program(1);
1490  }
1491  init_output_filter(ofilter, o, oc);
1492  } else {
1494  switch (ist->st->codec->codec_type) {
1495  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1496  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1497  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1498  case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1499  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1500  default:
1501  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1502  map->file_index, map->stream_index);
1503  exit_program(1);
1504  }
1505 
1506  ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1507  ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1508  map->sync_stream_index];
1509  ist->discard = 0;
1510  ist->st->discard = AVDISCARD_NONE;
1511  }
1512  }
1513  }
1514 
1515  /* handle attached files */
1516  for (i = 0; i < o->nb_attachments; i++) {
1517  AVIOContext *pb;
1518  uint8_t *attachment;
1519  const char *p;
1520  int64_t len;
1521 
1522  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1523  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1524  o->attachments[i]);
1525  exit_program(1);
1526  }
1527  if ((len = avio_size(pb)) <= 0) {
1528  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1529  o->attachments[i]);
1530  exit_program(1);
1531  }
1532  if (!(attachment = av_malloc(len))) {
1533  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1534  o->attachments[i]);
1535  exit_program(1);
1536  }
1537  avio_read(pb, attachment, len);
1538 
1539  ost = new_attachment_stream(o, oc);
1540  ost->stream_copy = 0;
1541  ost->source_index = -1;
1542  ost->attachment_filename = o->attachments[i];
1543  ost->st->codec->extradata = attachment;
1544  ost->st->codec->extradata_size = len;
1545 
1546  p = strrchr(o->attachments[i], '/');
1547  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1548  avio_close(pb);
1549  }
1550 
1551  /* check if all codec options have been used */
1552  unused_opts = strip_specifiers(o->g->codec_opts);
1553  for (i = of->ost_index; i < nb_output_streams; i++) {
1554  e = NULL;
1555  while ((e = av_dict_get(output_streams[i]->opts, "", e,
1557  av_dict_set(&unused_opts, e->key, NULL, 0);
1558  }
1559 
1560  e = NULL;
1561  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1562  const AVClass *class = avcodec_get_class();
1563  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1565  if (!option)
1566  continue;
1567  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1568  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1569  "output file #%d (%s) is not an encoding option.\n", e->key,
1570  option->help ? option->help : "", nb_output_files - 1,
1571  filename);
1572  exit_program(1);
1573  }
1574 
1575  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1576  "output file #%d (%s) has not been used for any stream. The most "
1577  "likely reason is either wrong type (e.g. a video option with "
1578  "no video streams) or that it is a private option of some encoder "
1579  "which was not actually used for any stream.\n", e->key,
1580  option->help ? option->help : "", nb_output_files - 1, filename);
1581  }
1582  av_dict_free(&unused_opts);
1583 
1584  /* check filename in case of an image number is expected */
1585  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1586  if (!av_filename_number_test(oc->filename)) {
1587  print_error(oc->filename, AVERROR(EINVAL));
1588  exit_program(1);
1589  }
1590  }
1591 
1592  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1593  /* test if it already exists to avoid losing precious files */
1594  assert_file_overwrite(filename);
1595 
1596  /* open the file */
1597  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1598  &oc->interrupt_callback,
1599  &of->opts)) < 0) {
1600  print_error(filename, err);
1601  exit_program(1);
1602  }
1603  }
1604 
1605  if (o->mux_preload) {
1606  uint8_t buf[64];
1607  snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1608  av_dict_set(&of->opts, "preload", buf, 0);
1609  }
1610  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1611  oc->flags |= AVFMT_FLAG_NONBLOCK;
1612 
1613  /* copy metadata */
1614  for (i = 0; i < o->nb_metadata_map; i++) {
1615  char *p;
1616  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1617 
1618  if (in_file_index >= nb_input_files) {
1619  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1620  exit_program(1);
1621  }
1622  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1623  in_file_index >= 0 ?
1624  input_files[in_file_index]->ctx : NULL, o);
1625  }
1626 
1627  /* copy chapters */
1628  if (o->chapters_input_file >= nb_input_files) {
1629  if (o->chapters_input_file == INT_MAX) {
1630  /* copy chapters from the first input file that has them*/
1631  o->chapters_input_file = -1;
1632  for (i = 0; i < nb_input_files; i++)
1633  if (input_files[i]->ctx->nb_chapters) {
1634  o->chapters_input_file = i;
1635  break;
1636  }
1637  } else {
1638  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1639  o->chapters_input_file);
1640  exit_program(1);
1641  }
1642  }
1643  if (o->chapters_input_file >= 0)
1646 
1647  /* copy global metadata by default */
1651  if (!o->metadata_streams_manual)
1652  for (i = of->ost_index; i < nb_output_streams; i++) {
1653  InputStream *ist;
1654  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1655  continue;
1657  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1658  }
1659 
1660  /* process manually set metadata */
1661  for (i = 0; i < o->nb_metadata; i++) {
1662  AVDictionary **m;
1663  char type, *val;
1664  const char *stream_spec;
1665  int index = 0, j, ret;
1666 
1667  val = strchr(o->metadata[i].u.str, '=');
1668  if (!val) {
1669  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1670  o->metadata[i].u.str);
1671  exit_program(1);
1672  }
1673  *val++ = 0;
1674 
1675  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1676  if (type == 's') {
1677  for (j = 0; j < oc->nb_streams; j++) {
1678  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1679  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1680  } else if (ret < 0)
1681  exit_program(1);
1682  }
1683  }
1684  else {
1685  switch (type) {
1686  case 'g':
1687  m = &oc->metadata;
1688  break;
1689  case 'c':
1690  if (index < 0 || index >= oc->nb_chapters) {
1691  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1692  exit_program(1);
1693  }
1694  m = &oc->chapters[index]->metadata;
1695  break;
1696  default:
1697  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1698  exit_program(1);
1699  }
1700  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1701  }
1702  }
1703 
1704  return 0;
1705 }
1706 
1707 static int opt_target(void *optctx, const char *opt, const char *arg)
1708 {
1709  OptionsContext *o = optctx;
1710  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1711  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1712 
1713  if (!strncmp(arg, "pal-", 4)) {
1714  norm = PAL;
1715  arg += 4;
1716  } else if (!strncmp(arg, "ntsc-", 5)) {
1717  norm = NTSC;
1718  arg += 5;
1719  } else if (!strncmp(arg, "film-", 5)) {
1720  norm = FILM;
1721  arg += 5;
1722  } else {
1723  /* Try to determine PAL/NTSC by peeking in the input files */
1724  if (nb_input_files) {
1725  int i, j, fr;
1726  for (j = 0; j < nb_input_files; j++) {
1727  for (i = 0; i < input_files[j]->nb_streams; i++) {
1728  AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1729  if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1730  !c->time_base.num)
1731  continue;
1732  fr = c->time_base.den * 1000 / c->time_base.num;
1733  if (fr == 25000) {
1734  norm = PAL;
1735  break;
1736  } else if ((fr == 29970) || (fr == 23976)) {
1737  norm = NTSC;
1738  break;
1739  }
1740  }
1741  if (norm != UNKNOWN)
1742  break;
1743  }
1744  }
1745  if (norm != UNKNOWN)
1746  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1747  }
1748 
1749  if (norm == UNKNOWN) {
1750  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1751  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1752  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1753  exit_program(1);
1754  }
1755 
1756  if (!strcmp(arg, "vcd")) {
1757  opt_video_codec(o, "c:v", "mpeg1video");
1758  opt_audio_codec(o, "c:a", "mp2");
1759  parse_option(o, "f", "vcd", options);
1760 
1761  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1762  parse_option(o, "r", frame_rates[norm], options);
1763  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1764 
1765  opt_default(NULL, "b", "1150000");
1766  opt_default(NULL, "maxrate", "1150000");
1767  opt_default(NULL, "minrate", "1150000");
1768  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1769 
1770  opt_default(NULL, "b:a", "224000");
1771  parse_option(o, "ar", "44100", options);
1772  parse_option(o, "ac", "2", options);
1773 
1774  opt_default(NULL, "packetsize", "2324");
1775  opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1776 
1777  /* We have to offset the PTS, so that it is consistent with the SCR.
1778  SCR starts at 36000, but the first two packs contain only padding
1779  and the first pack from the other stream, respectively, may also have
1780  been written before.
1781  So the real data starts at SCR 36000+3*1200. */
1782  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1783  } else if (!strcmp(arg, "svcd")) {
1784 
1785  opt_video_codec(o, "c:v", "mpeg2video");
1786  opt_audio_codec(o, "c:a", "mp2");
1787  parse_option(o, "f", "svcd", options);
1788 
1789  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1790  parse_option(o, "r", frame_rates[norm], options);
1791  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1792 
1793  opt_default(NULL, "b", "2040000");
1794  opt_default(NULL, "maxrate", "2516000");
1795  opt_default(NULL, "minrate", "0"); // 1145000;
1796  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1797  opt_default(NULL, "scan_offset", "1");
1798 
1799 
1800  opt_default(NULL, "b:a", "224000");
1801  parse_option(o, "ar", "44100", options);
1802 
1803  opt_default(NULL, "packetsize", "2324");
1804 
1805  } else if (!strcmp(arg, "dvd")) {
1806 
1807  opt_video_codec(o, "c:v", "mpeg2video");
1808  opt_audio_codec(o, "c:a", "ac3");
1809  parse_option(o, "f", "dvd", options);
1810 
1811  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1812  parse_option(o, "r", frame_rates[norm], options);
1813  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1814 
1815  opt_default(NULL, "b", "6000000");
1816  opt_default(NULL, "maxrate", "9000000");
1817  opt_default(NULL, "minrate", "0"); // 1500000;
1818  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1819 
1820  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1821  opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1822 
1823  opt_default(NULL, "b:a", "448000");
1824  parse_option(o, "ar", "48000", options);
1825 
1826  } else if (!strncmp(arg, "dv", 2)) {
1827 
1828  parse_option(o, "f", "dv", options);
1829 
1830  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1831  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1832  norm == PAL ? "yuv420p" : "yuv411p", options);
1833  parse_option(o, "r", frame_rates[norm], options);
1834 
1835  parse_option(o, "ar", "48000", options);
1836  parse_option(o, "ac", "2", options);
1837 
1838  } else {
1839  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1840  return AVERROR(EINVAL);
1841  }
1842 
1843  av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1845 
1846  return 0;
1847 }
1848 
1849 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1850 {
1852  vstats_filename = av_strdup (arg);
1853  return 0;
1854 }
1855 
1856 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1857 {
1858  char filename[40];
1859  time_t today2 = time(NULL);
1860  struct tm *today = localtime(&today2);
1861 
1862  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1863  today->tm_sec);
1864  return opt_vstats_file(NULL, opt, filename);
1865 }
1866 
1867 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1868 {
1869  OptionsContext *o = optctx;
1870  return parse_option(o, "frames:v", arg, options);
1871 }
1872 
1873 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1874 {
1875  OptionsContext *o = optctx;
1876  return parse_option(o, "frames:a", arg, options);
1877 }
1878 
1879 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1880 {
1881  OptionsContext *o = optctx;
1882  return parse_option(o, "frames:d", arg, options);
1883 }
1884 
1885 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1886 {
1887  OptionsContext *o = optctx;
1888  return parse_option(o, "tag:v", arg, options);
1889 }
1890 
1891 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1892 {
1893  OptionsContext *o = optctx;
1894  return parse_option(o, "tag:a", arg, options);
1895 }
1896 
1897 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1898 {
1899  OptionsContext *o = optctx;
1900  return parse_option(o, "tag:s", arg, options);
1901 }
1902 
1903 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1904 {
1905  OptionsContext *o = optctx;
1906  return parse_option(o, "filter:v", arg, options);
1907 }
1908 
1909 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1910 {
1911  OptionsContext *o = optctx;
1912  return parse_option(o, "filter:a", arg, options);
1913 }
1914 
1915 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1916 {
1917  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1918  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1919  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1920 
1923  return 0;
1924 }
1925 
1926 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1927 {
1928  OptionsContext *o = optctx;
1929  char layout_str[32];
1930  char *stream_str;
1931  char *ac_str;
1932  int ret, channels, ac_str_size;
1933  uint64_t layout;
1934 
1935  layout = av_get_channel_layout(arg);
1936  if (!layout) {
1937  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1938  return AVERROR(EINVAL);
1939  }
1940  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1941  ret = opt_default(NULL, opt, layout_str);
1942  if (ret < 0)
1943  return ret;
1944 
1945  /* set 'ac' option based on channel layout */
1946  channels = av_get_channel_layout_nb_channels(layout);
1947  snprintf(layout_str, sizeof(layout_str), "%d", channels);
1948  stream_str = strchr(opt, ':');
1949  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1950  ac_str = av_mallocz(ac_str_size);
1951  if (!ac_str)
1952  return AVERROR(ENOMEM);
1953  av_strlcpy(ac_str, "ac", 3);
1954  if (stream_str)
1955  av_strlcat(ac_str, stream_str, ac_str_size);
1956  ret = parse_option(o, ac_str, layout_str, options);
1957  av_free(ac_str);
1958 
1959  return ret;
1960 }
1961 
1962 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1963 {
1964  OptionsContext *o = optctx;
1965  return parse_option(o, "q:a", arg, options);
1966 }
1967 
1968 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1969 {
1971  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1972  return AVERROR(ENOMEM);
1975  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1976  return AVERROR(ENOMEM);
1977  return 0;
1978 }
1979 
1980 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1981 {
1982  uint8_t *graph_desc = read_file(arg);
1983  if (!graph_desc)
1984  return AVERROR(EINVAL);
1985 
1987  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1988  return AVERROR(ENOMEM);
1990  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1991  return 0;
1992 }
1993 
1994 void show_help_default(const char *opt, const char *arg)
1995 {
1996  /* per-file options have at least one of those set */
1997  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1998  int show_advanced = 0, show_avoptions = 0;
1999 
2000  if (opt && *opt) {
2001  if (!strcmp(opt, "long"))
2002  show_advanced = 1;
2003  else if (!strcmp(opt, "full"))
2004  show_advanced = show_avoptions = 1;
2005  else
2006  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2007  }
2008 
2009  show_usage();
2010 
2011  printf("Getting help:\n"
2012  " -h -- print basic options\n"
2013  " -h long -- print more options\n"
2014  " -h full -- print all options (including all format and codec specific options, very long)\n"
2015  " See man %s for detailed description of the options.\n"
2016  "\n", program_name);
2017 
2018  show_help_options(options, "Print help / information / capabilities:",
2019  OPT_EXIT, 0, 0);
2020 
2021  show_help_options(options, "Global options (affect whole program "
2022  "instead of just one file:",
2023  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2024  if (show_advanced)
2025  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2026  per_file | OPT_EXIT, 0);
2027 
2028  show_help_options(options, "Per-file main options:", 0,
2030  OPT_EXIT, per_file);
2031  if (show_advanced)
2032  show_help_options(options, "Advanced per-file options:",
2033  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2034 
2035  show_help_options(options, "Video options:",
2037  if (show_advanced)
2038  show_help_options(options, "Advanced Video options:",
2040 
2041  show_help_options(options, "Audio options:",
2043  if (show_advanced)
2044  show_help_options(options, "Advanced Audio options:",
2046  show_help_options(options, "Subtitle options:",
2047  OPT_SUBTITLE, 0, 0);
2048  printf("\n");
2049 
2050  if (show_avoptions) {
2056  }
2057 }
2058 
2059 void show_usage(void)
2060 {
2061  printf("Hyper fast Audio and Video encoder\n");
2062  printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2063  printf("\n");
2064 }
2065 
2066 enum OptGroup {
2069 };
2070 
2071 static const OptionGroupDef groups[] = {
2072  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2073  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2074 };
2075 
2076 static int open_files(OptionGroupList *l, const char *inout,
2077  int (*open_file)(OptionsContext*, const char*))
2078 {
2079  int i, ret;
2080 
2081  for (i = 0; i < l->nb_groups; i++) {
2082  OptionGroup *g = &l->groups[i];
2083  OptionsContext o;
2084 
2085  init_options(&o);
2086  o.g = g;
2087 
2088  ret = parse_optgroup(&o, g);
2089  if (ret < 0) {
2090  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2091  "%s.\n", inout, g->arg);
2092  return ret;
2093  }
2094 
2095  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2096  ret = open_file(&o, g->arg);
2097  uninit_options(&o);
2098  if (ret < 0) {
2099  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2100  inout, g->arg);
2101  return ret;
2102  }
2103  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2104  }
2105 
2106  return 0;
2107 }
2108 
2109 int avconv_parse_options(int argc, char **argv)
2110 {
2112  uint8_t error[128];
2113  int ret;
2114 
2115  memset(&octx, 0, sizeof(octx));
2116 
2117  /* split the commandline into an internal representation */
2118  ret = split_commandline(&octx, argc, argv, options, groups,
2119  FF_ARRAY_ELEMS(groups));
2120  if (ret < 0) {
2121  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2122  goto fail;
2123  }
2124 
2125  /* apply global options */
2126  ret = parse_optgroup(NULL, &octx.global_opts);
2127  if (ret < 0) {
2128  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2129  goto fail;
2130  }
2131 
2132  /* open input files */
2133  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2134  if (ret < 0) {
2135  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2136  goto fail;
2137  }
2138 
2139  /* open output files */
2140  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2141  if (ret < 0) {
2142  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2143  goto fail;
2144  }
2145 
2146 fail:
2147  uninit_parse_context(&octx);
2148  if (ret < 0) {
2149  av_strerror(ret, error, sizeof(error));
2150  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2151  }
2152  return ret;
2153 }
2154 
2155 #define OFFSET(x) offsetof(OptionsContext, x)
2156 const OptionDef options[] = {
2157  /* main options */
2158 #include "cmdutils_common_opts.h"
2159  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2160  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2161  "force format", "fmt" },
2162  { "y", OPT_BOOL, { &file_overwrite },
2163  "overwrite output files" },
2164  { "n", OPT_BOOL, { &file_skip },
2165  "never overwrite output files" },
2166  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2167  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2168  "codec name", "codec" },
2169  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2170  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2171  "codec name", "codec" },
2172  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2173  OPT_OUTPUT, { .off = OFFSET(presets) },
2174  "preset name", "preset" },
2175  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2176  OPT_OUTPUT, { .func_arg = opt_map },
2177  "set input stream mapping",
2178  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2179  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2180  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2181  "set metadata information of outfile from infile",
2182  "outfile[,metadata]:infile[,metadata]" },
2183  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2184  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2185  "set chapters mapping", "input_file_index" },
2186  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2187  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2188  "record or transcode \"duration\" seconds of audio/video",
2189  "duration" },
2190  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2191  "set the limit file size in bytes", "limit_size" },
2192  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2193  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2194  "set the start time offset", "time_off" },
2195  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2196  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2197  "enable/disable accurate seeking with -ss" },
2198  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2199  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2200  "set the input ts offset", "time_off" },
2201  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2202  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2203  "set the input ts scale", "scale" },
2204  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2205  "add metadata", "string=string" },
2206  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2207  OPT_OUTPUT, { .func_arg = opt_data_frames },
2208  "set the number of data frames to record", "number" },
2209  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2210  "add timings for benchmarking" },
2211  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2212  "set max runtime in seconds", "limit" },
2213  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2214  "dump each input packet" },
2215  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2216  "when dumping packets, also dump the payload" },
2217  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2218  OPT_INPUT, { .off = OFFSET(rate_emu) },
2219  "read input at native frame rate", "" },
2220  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2221  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2222  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2223  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2224  "video sync method", "" },
2225  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2226  "audio sync method", "" },
2227  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2228  "audio drift threshold", "threshold" },
2229  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2230  "copy timestamps" },
2231  { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2232  "copy input stream time base when stream copying" },
2233  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2234  OPT_OUTPUT, { .off = OFFSET(shortest) },
2235  "finish encoding within shortest input" },
2236  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2237  "timestamp discontinuity delta threshold", "threshold" },
2238  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2239  "exit on error", "error" },
2240  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2241  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2242  "copy initial non-keyframes" },
2243  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2244  "set the number of frames to record", "number" },
2245  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2246  OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2247  "force codec tag/fourcc", "fourcc/tag" },
2248  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2249  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2250  "use fixed quality scale (VBR)", "q" },
2251  { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2252  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2253  "use fixed quality scale (VBR)", "q" },
2254  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2255  "set stream filterchain", "filter_list" },
2256  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2257  "read stream filtergraph description from a file", "filename" },
2258  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2259  "create a complex filtergraph", "graph_description" },
2260  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2261  "read complex filtergraph description from a file", "filename" },
2262  { "stats", OPT_BOOL, { &print_stats },
2263  "print progress report during encoding", },
2264  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2265  OPT_OUTPUT, { .func_arg = opt_attach },
2266  "add an attachment to the output file", "filename" },
2267  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2268  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2269  "extract an attachment into a file", "filename" },
2270 
2271  /* video options */
2272  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2273  "set the number of video frames to record", "number" },
2274  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2275  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2276  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2277  { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2278  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2279  "set frame size (WxH or abbreviation)", "size" },
2280  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2281  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2282  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2283  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2284  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2285  "set pixel format", "format" },
2286  { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2287  "disable video" },
2288  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2289  "discard threshold", "n" },
2290  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2291  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2292  "rate control override for specific intervals", "override" },
2293  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2294  OPT_OUTPUT, { .func_arg = opt_video_codec },
2295  "force video codec ('copy' to copy stream)", "codec" },
2296  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2297  "select the pass number (1 or 2)", "n" },
2298  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2299  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2300  "select two pass log file name prefix", "prefix" },
2301  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2302  "dump video coding statistics to file" },
2303  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2304  "dump video coding statistics to file", "file" },
2305  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2306  "video filters", "filter list" },
2307  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2308  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2309  "specify intra matrix coeffs", "matrix" },
2310  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2311  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2312  "specify inter matrix coeffs", "matrix" },
2313  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2314  OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2315  "top=1/bottom=0/auto=-1 field first", "" },
2316  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2317  "intra_dc_precision", "precision" },
2318  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2319  OPT_OUTPUT, { .func_arg = opt_video_tag },
2320  "force video tag/fourcc", "fourcc/tag" },
2321  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2322  "show QP histogram" },
2323  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2324  OPT_OUTPUT, { .off = OFFSET(force_fps) },
2325  "force the selected framerate, disable the best supported framerate selection" },
2326  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2327  OPT_OUTPUT, { .func_arg = opt_streamid },
2328  "set the value of an outfile streamid", "streamIndex:value" },
2329  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2330  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2331  "force key frames at specified timestamps", "timestamps" },
2332  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2333  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2334  "use HW accelerated decoding", "hwaccel name" },
2335  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2336  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2337  "select a device for HW acceleration" "devicename" },
2338 
2339  /* audio options */
2340  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2341  "set the number of audio frames to record", "number" },
2342  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2343  "set audio quality (codec-specific)", "quality", },
2344  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2345  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2346  "set audio sampling rate (in Hz)", "rate" },
2347  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2348  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2349  "set number of audio channels", "channels" },
2350  { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2351  "disable audio" },
2352  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2353  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2354  "force audio codec ('copy' to copy stream)", "codec" },
2355  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2356  OPT_OUTPUT, { .func_arg = opt_audio_tag },
2357  "force audio tag/fourcc", "fourcc/tag" },
2358  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2359  "change audio volume (256=normal)" , "volume" },
2360  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2362  "set sample format", "format" },
2363  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2364  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2365  "set channel layout", "layout" },
2366  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2367  "audio filters", "filter list" },
2368 
2369  /* subtitle options */
2370  { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2371  "disable subtitle" },
2372  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2373  "force subtitle codec ('copy' to copy stream)", "codec" },
2374  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2375  , "force subtitle tag/fourcc", "fourcc/tag" },
2376 
2377  /* grab options */
2378  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2379 
2380  /* muxer options */
2381  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2382  "set the maximum demux-decode delay", "seconds" },
2383  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2384  "set the initial demux-decode delay", "seconds" },
2385 
2386  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2387  "A comma-separated list of bitstream filters", "bitstream_filters" },
2388 
2389  /* data codec support */
2390  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2391  "force data codec ('copy' to copy stream)", "codec" },
2392 
2393  { NULL, },
2394 };