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