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  continue;
1731  fr = c->time_base.den * 1000 / c->time_base.num;
1732  if (fr == 25000) {
1733  norm = PAL;
1734  break;
1735  } else if ((fr == 29970) || (fr == 23976)) {
1736  norm = NTSC;
1737  break;
1738  }
1739  }
1740  if (norm != UNKNOWN)
1741  break;
1742  }
1743  }
1744  if (norm != UNKNOWN)
1745  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1746  }
1747 
1748  if (norm == UNKNOWN) {
1749  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1750  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1751  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1752  exit_program(1);
1753  }
1754 
1755  if (!strcmp(arg, "vcd")) {
1756  opt_video_codec(o, "c:v", "mpeg1video");
1757  opt_audio_codec(o, "c:a", "mp2");
1758  parse_option(o, "f", "vcd", options);
1759 
1760  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1761  parse_option(o, "r", frame_rates[norm], options);
1762  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1763 
1764  opt_default(NULL, "b", "1150000");
1765  opt_default(NULL, "maxrate", "1150000");
1766  opt_default(NULL, "minrate", "1150000");
1767  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1768 
1769  opt_default(NULL, "b:a", "224000");
1770  parse_option(o, "ar", "44100", options);
1771  parse_option(o, "ac", "2", options);
1772 
1773  opt_default(NULL, "packetsize", "2324");
1774  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1775 
1776  /* We have to offset the PTS, so that it is consistent with the SCR.
1777  SCR starts at 36000, but the first two packs contain only padding
1778  and the first pack from the other stream, respectively, may also have
1779  been written before.
1780  So the real data starts at SCR 36000+3*1200. */
1781  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1782  } else if (!strcmp(arg, "svcd")) {
1783 
1784  opt_video_codec(o, "c:v", "mpeg2video");
1785  opt_audio_codec(o, "c:a", "mp2");
1786  parse_option(o, "f", "svcd", options);
1787 
1788  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1789  parse_option(o, "r", frame_rates[norm], options);
1790  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1791 
1792  opt_default(NULL, "b", "2040000");
1793  opt_default(NULL, "maxrate", "2516000");
1794  opt_default(NULL, "minrate", "0"); // 1145000;
1795  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1796  opt_default(NULL, "flags", "+scan_offset");
1797 
1798 
1799  opt_default(NULL, "b:a", "224000");
1800  parse_option(o, "ar", "44100", options);
1801 
1802  opt_default(NULL, "packetsize", "2324");
1803 
1804  } else if (!strcmp(arg, "dvd")) {
1805 
1806  opt_video_codec(o, "c:v", "mpeg2video");
1807  opt_audio_codec(o, "c:a", "ac3");
1808  parse_option(o, "f", "dvd", options);
1809 
1810  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1811  parse_option(o, "r", frame_rates[norm], options);
1812  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1813 
1814  opt_default(NULL, "b", "6000000");
1815  opt_default(NULL, "maxrate", "9000000");
1816  opt_default(NULL, "minrate", "0"); // 1500000;
1817  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1818 
1819  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1820  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1821 
1822  opt_default(NULL, "b:a", "448000");
1823  parse_option(o, "ar", "48000", options);
1824 
1825  } else if (!strncmp(arg, "dv", 2)) {
1826 
1827  parse_option(o, "f", "dv", options);
1828 
1829  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1830  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1831  norm == PAL ? "yuv420p" : "yuv411p", options);
1832  parse_option(o, "r", frame_rates[norm], options);
1833 
1834  parse_option(o, "ar", "48000", options);
1835  parse_option(o, "ac", "2", options);
1836 
1837  } else {
1838  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1839  return AVERROR(EINVAL);
1840  }
1841  return 0;
1842 }
1843 
1844 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1845 {
1847  vstats_filename = av_strdup (arg);
1848  return 0;
1849 }
1850 
1851 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1852 {
1853  char filename[40];
1854  time_t today2 = time(NULL);
1855  struct tm *today = localtime(&today2);
1856 
1857  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1858  today->tm_sec);
1859  return opt_vstats_file(NULL, opt, filename);
1860 }
1861 
1862 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1863 {
1864  OptionsContext *o = optctx;
1865  return parse_option(o, "frames:v", arg, options);
1866 }
1867 
1868 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1869 {
1870  OptionsContext *o = optctx;
1871  return parse_option(o, "frames:a", arg, options);
1872 }
1873 
1874 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1875 {
1876  OptionsContext *o = optctx;
1877  return parse_option(o, "frames:d", arg, options);
1878 }
1879 
1880 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1881 {
1882  OptionsContext *o = optctx;
1883  return parse_option(o, "tag:v", arg, options);
1884 }
1885 
1886 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1887 {
1888  OptionsContext *o = optctx;
1889  return parse_option(o, "tag:a", arg, options);
1890 }
1891 
1892 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1893 {
1894  OptionsContext *o = optctx;
1895  return parse_option(o, "tag:s", arg, options);
1896 }
1897 
1898 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1899 {
1900  OptionsContext *o = optctx;
1901  return parse_option(o, "filter:v", arg, options);
1902 }
1903 
1904 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1905 {
1906  OptionsContext *o = optctx;
1907  return parse_option(o, "filter:a", arg, options);
1908 }
1909 
1910 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1911 {
1912  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1913  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1914  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1915 
1918  return 0;
1919 }
1920 
1921 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1922 {
1923  OptionsContext *o = optctx;
1924  char layout_str[32];
1925  char *stream_str;
1926  char *ac_str;
1927  int ret, channels, ac_str_size;
1928  uint64_t layout;
1929 
1930  layout = av_get_channel_layout(arg);
1931  if (!layout) {
1932  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1933  return AVERROR(EINVAL);
1934  }
1935  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1936  ret = opt_default(NULL, opt, layout_str);
1937  if (ret < 0)
1938  return ret;
1939 
1940  /* set 'ac' option based on channel layout */
1941  channels = av_get_channel_layout_nb_channels(layout);
1942  snprintf(layout_str, sizeof(layout_str), "%d", channels);
1943  stream_str = strchr(opt, ':');
1944  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1945  ac_str = av_mallocz(ac_str_size);
1946  if (!ac_str)
1947  return AVERROR(ENOMEM);
1948  av_strlcpy(ac_str, "ac", 3);
1949  if (stream_str)
1950  av_strlcat(ac_str, stream_str, ac_str_size);
1951  ret = parse_option(o, ac_str, layout_str, options);
1952  av_free(ac_str);
1953 
1954  return ret;
1955 }
1956 
1957 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1958 {
1959  OptionsContext *o = optctx;
1960  return parse_option(o, "q:a", arg, options);
1961 }
1962 
1963 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1964 {
1966  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1967  return AVERROR(ENOMEM);
1970  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1971  return AVERROR(ENOMEM);
1972  return 0;
1973 }
1974 
1975 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1976 {
1977  uint8_t *graph_desc = read_file(arg);
1978  if (!graph_desc)
1979  return AVERROR(EINVAL);
1980 
1982  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1983  return AVERROR(ENOMEM);
1985  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1986  return 0;
1987 }
1988 
1989 void show_help_default(const char *opt, const char *arg)
1990 {
1991  /* per-file options have at least one of those set */
1992  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1993  int show_advanced = 0, show_avoptions = 0;
1994 
1995  if (opt && *opt) {
1996  if (!strcmp(opt, "long"))
1997  show_advanced = 1;
1998  else if (!strcmp(opt, "full"))
1999  show_advanced = show_avoptions = 1;
2000  else
2001  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2002  }
2003 
2004  show_usage();
2005 
2006  printf("Getting help:\n"
2007  " -h -- print basic options\n"
2008  " -h long -- print more options\n"
2009  " -h full -- print all options (including all format and codec specific options, very long)\n"
2010  " See man %s for detailed description of the options.\n"
2011  "\n", program_name);
2012 
2013  show_help_options(options, "Print help / information / capabilities:",
2014  OPT_EXIT, 0, 0);
2015 
2016  show_help_options(options, "Global options (affect whole program "
2017  "instead of just one file:",
2018  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2019  if (show_advanced)
2020  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2021  per_file | OPT_EXIT, 0);
2022 
2023  show_help_options(options, "Per-file main options:", 0,
2025  OPT_EXIT, per_file);
2026  if (show_advanced)
2027  show_help_options(options, "Advanced per-file options:",
2028  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2029 
2030  show_help_options(options, "Video options:",
2032  if (show_advanced)
2033  show_help_options(options, "Advanced Video options:",
2035 
2036  show_help_options(options, "Audio options:",
2038  if (show_advanced)
2039  show_help_options(options, "Advanced Audio options:",
2041  show_help_options(options, "Subtitle options:",
2042  OPT_SUBTITLE, 0, 0);
2043  printf("\n");
2044 
2045  if (show_avoptions) {
2051  }
2052 }
2053 
2054 void show_usage(void)
2055 {
2056  printf("Hyper fast Audio and Video encoder\n");
2057  printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2058  printf("\n");
2059 }
2060 
2061 enum OptGroup {
2064 };
2065 
2066 static const OptionGroupDef groups[] = {
2067  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2068  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2069 };
2070 
2071 static int open_files(OptionGroupList *l, const char *inout,
2072  int (*open_file)(OptionsContext*, const char*))
2073 {
2074  int i, ret;
2075 
2076  for (i = 0; i < l->nb_groups; i++) {
2077  OptionGroup *g = &l->groups[i];
2078  OptionsContext o;
2079 
2080  init_options(&o);
2081  o.g = g;
2082 
2083  ret = parse_optgroup(&o, g);
2084  if (ret < 0) {
2085  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2086  "%s.\n", inout, g->arg);
2087  return ret;
2088  }
2089 
2090  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2091  ret = open_file(&o, g->arg);
2092  uninit_options(&o);
2093  if (ret < 0) {
2094  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2095  inout, g->arg);
2096  return ret;
2097  }
2098  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2099  }
2100 
2101  return 0;
2102 }
2103 
2104 int avconv_parse_options(int argc, char **argv)
2105 {
2107  uint8_t error[128];
2108  int ret;
2109 
2110  memset(&octx, 0, sizeof(octx));
2111 
2112  /* split the commandline into an internal representation */
2113  ret = split_commandline(&octx, argc, argv, options, groups,
2114  FF_ARRAY_ELEMS(groups));
2115  if (ret < 0) {
2116  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2117  goto fail;
2118  }
2119 
2120  /* apply global options */
2121  ret = parse_optgroup(NULL, &octx.global_opts);
2122  if (ret < 0) {
2123  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2124  goto fail;
2125  }
2126 
2127  /* open input files */
2128  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2129  if (ret < 0) {
2130  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2131  goto fail;
2132  }
2133 
2134  /* open output files */
2135  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2136  if (ret < 0) {
2137  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2138  goto fail;
2139  }
2140 
2141 fail:
2142  uninit_parse_context(&octx);
2143  if (ret < 0) {
2144  av_strerror(ret, error, sizeof(error));
2145  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2146  }
2147  return ret;
2148 }
2149 
2150 #define OFFSET(x) offsetof(OptionsContext, x)
2151 const OptionDef options[] = {
2152  /* main options */
2153 #include "cmdutils_common_opts.h"
2154  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2155  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2156  "force format", "fmt" },
2157  { "y", OPT_BOOL, { &file_overwrite },
2158  "overwrite output files" },
2159  { "n", OPT_BOOL, { &file_skip },
2160  "never overwrite output files" },
2161  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2162  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2163  "codec name", "codec" },
2164  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2165  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2166  "codec name", "codec" },
2167  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2168  OPT_OUTPUT, { .off = OFFSET(presets) },
2169  "preset name", "preset" },
2170  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2171  OPT_OUTPUT, { .func_arg = opt_map },
2172  "set input stream mapping",
2173  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2174  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2175  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2176  "set metadata information of outfile from infile",
2177  "outfile[,metadata]:infile[,metadata]" },
2178  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2179  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2180  "set chapters mapping", "input_file_index" },
2181  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2182  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2183  "record or transcode \"duration\" seconds of audio/video",
2184  "duration" },
2185  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2186  "set the limit file size in bytes", "limit_size" },
2187  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2188  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2189  "set the start time offset", "time_off" },
2190  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2191  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2192  "enable/disable accurate seeking with -ss" },
2193  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2194  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2195  "set the input ts offset", "time_off" },
2196  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2197  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2198  "set the input ts scale", "scale" },
2199  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2200  "add metadata", "string=string" },
2201  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2202  OPT_OUTPUT, { .func_arg = opt_data_frames },
2203  "set the number of data frames to record", "number" },
2204  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2205  "add timings for benchmarking" },
2206  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2207  "set max runtime in seconds", "limit" },
2208  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2209  "dump each input packet" },
2210  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2211  "when dumping packets, also dump the payload" },
2212  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2213  OPT_INPUT, { .off = OFFSET(rate_emu) },
2214  "read input at native frame rate", "" },
2215  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2216  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2217  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2218  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2219  "video sync method", "" },
2220  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2221  "audio sync method", "" },
2222  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2223  "audio drift threshold", "threshold" },
2224  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2225  "copy timestamps" },
2226  { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2227  "copy input stream time base when stream copying" },
2228  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2229  OPT_OUTPUT, { .off = OFFSET(shortest) },
2230  "finish encoding within shortest input" },
2231  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2232  "timestamp discontinuity delta threshold", "threshold" },
2233  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2234  "exit on error", "error" },
2235  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2236  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2237  "copy initial non-keyframes" },
2238  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2239  "set the number of frames to record", "number" },
2240  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2241  OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2242  "force codec tag/fourcc", "fourcc/tag" },
2243  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2244  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2245  "use fixed quality scale (VBR)", "q" },
2246  { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2247  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2248  "use fixed quality scale (VBR)", "q" },
2249  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2250  "set stream filterchain", "filter_list" },
2251  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2252  "read stream filtergraph description from a file", "filename" },
2253  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2254  "create a complex filtergraph", "graph_description" },
2255  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2256  "read complex filtergraph description from a file", "filename" },
2257  { "stats", OPT_BOOL, { &print_stats },
2258  "print progress report during encoding", },
2259  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2260  OPT_OUTPUT, { .func_arg = opt_attach },
2261  "add an attachment to the output file", "filename" },
2262  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2263  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2264  "extract an attachment into a file", "filename" },
2265 
2266  /* video options */
2267  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2268  "set the number of video frames to record", "number" },
2269  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2270  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2271  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2272  { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2273  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2274  "set frame size (WxH or abbreviation)", "size" },
2275  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2276  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2277  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2278  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2279  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2280  "set pixel format", "format" },
2281  { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2282  "disable video" },
2283  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2284  "discard threshold", "n" },
2285  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2286  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2287  "rate control override for specific intervals", "override" },
2288  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2289  OPT_OUTPUT, { .func_arg = opt_video_codec },
2290  "force video codec ('copy' to copy stream)", "codec" },
2291  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2292  "select the pass number (1 or 2)", "n" },
2293  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2294  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2295  "select two pass log file name prefix", "prefix" },
2296  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2297  "dump video coding statistics to file" },
2298  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2299  "dump video coding statistics to file", "file" },
2300  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2301  "video filters", "filter list" },
2302  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2303  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2304  "specify intra matrix coeffs", "matrix" },
2305  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2306  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2307  "specify inter matrix coeffs", "matrix" },
2308  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2309  OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2310  "top=1/bottom=0/auto=-1 field first", "" },
2311  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2312  "intra_dc_precision", "precision" },
2313  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2314  OPT_OUTPUT, { .func_arg = opt_video_tag },
2315  "force video tag/fourcc", "fourcc/tag" },
2316  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2317  "show QP histogram" },
2318  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2319  OPT_OUTPUT, { .off = OFFSET(force_fps) },
2320  "force the selected framerate, disable the best supported framerate selection" },
2321  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2322  OPT_OUTPUT, { .func_arg = opt_streamid },
2323  "set the value of an outfile streamid", "streamIndex:value" },
2324  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2325  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2326  "force key frames at specified timestamps", "timestamps" },
2327  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2328  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2329  "use HW accelerated decoding", "hwaccel name" },
2330  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2331  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2332  "select a device for HW acceleration" "devicename" },
2333 
2334  /* audio options */
2335  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2336  "set the number of audio frames to record", "number" },
2337  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2338  "set audio quality (codec-specific)", "quality", },
2339  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2340  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2341  "set audio sampling rate (in Hz)", "rate" },
2342  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2343  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2344  "set number of audio channels", "channels" },
2345  { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2346  "disable audio" },
2347  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2348  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2349  "force audio codec ('copy' to copy stream)", "codec" },
2350  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2351  OPT_OUTPUT, { .func_arg = opt_audio_tag },
2352  "force audio tag/fourcc", "fourcc/tag" },
2353  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2354  "change audio volume (256=normal)" , "volume" },
2355  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2357  "set sample format", "format" },
2358  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2359  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2360  "set channel layout", "layout" },
2361  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2362  "audio filters", "filter list" },
2363 
2364  /* subtitle options */
2365  { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2366  "disable subtitle" },
2367  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2368  "force subtitle codec ('copy' to copy stream)", "codec" },
2369  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2370  , "force subtitle tag/fourcc", "fourcc/tag" },
2371 
2372  /* grab options */
2373  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2374 
2375  /* muxer options */
2376  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2377  "set the maximum demux-decode delay", "seconds" },
2378  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2379  "set the initial demux-decode delay", "seconds" },
2380 
2381  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2382  "A comma-separated list of bitstream filters", "bitstream_filters" },
2383 
2384  /* data codec support */
2385  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2386  "force data codec ('copy' to copy stream)", "codec" },
2387 
2388  { NULL, },
2389 };