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;
848 
849  return ost;
850 }
851 
852 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
853 {
854  int i;
855  const char *p = str;
856  for (i = 0;; i++) {
857  dest[i] = atoi(p);
858  if (i == 63)
859  break;
860  p = strchr(p, ',');
861  if (!p) {
862  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
863  exit(1);
864  }
865  p++;
866  }
867 }
868 
870 {
871  AVStream *st;
872  OutputStream *ost;
873  AVCodecContext *video_enc;
874 
876  st = ost->st;
877  video_enc = st->codec;
878 
879  if (!ost->stream_copy) {
880  const char *p = NULL;
881  char *frame_rate = NULL, *frame_size = NULL;
882  char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
883  char *intra_matrix = NULL, *inter_matrix = NULL;
884  const char *filters = "null";
885  int do_pass = 0;
886  int i;
887 
888  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
889  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
890  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
891  exit(1);
892  }
893 
894  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
895  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
896  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
897  exit(1);
898  }
899 
900  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
901  if (frame_aspect_ratio)
902  ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
903 
904  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
905  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
906  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
907  exit(1);
908  }
909  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
910 
911  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
912  if (intra_matrix) {
913  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
914  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
915  exit(1);
916  }
917  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
918  }
919  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
920  if (inter_matrix) {
921  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
922  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
923  exit(1);
924  }
925  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
926  }
927 
928  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
929  for (i = 0; p; i++) {
930  int start, end, q;
931  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
932  if (e != 3) {
933  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
934  exit(1);
935  }
936  video_enc->rc_override =
937  av_realloc(video_enc->rc_override,
938  sizeof(RcOverride) * (i + 1));
939  video_enc->rc_override[i].start_frame = start;
940  video_enc->rc_override[i].end_frame = end;
941  if (q > 0) {
942  video_enc->rc_override[i].qscale = q;
943  video_enc->rc_override[i].quality_factor = 1.0;
944  }
945  else {
946  video_enc->rc_override[i].qscale = 0;
947  video_enc->rc_override[i].quality_factor = -q/100.0;
948  }
949  p = strchr(p, '/');
950  if (p) p++;
951  }
952  video_enc->rc_override_count = i;
953  video_enc->intra_dc_precision = intra_dc_precision - 8;
954 
955  /* two pass mode */
956  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
957  if (do_pass) {
958  if (do_pass == 1) {
959  video_enc->flags |= CODEC_FLAG_PASS1;
960  } else {
961  video_enc->flags |= CODEC_FLAG_PASS2;
962  }
963  }
964 
965  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
966  if (ost->logfile_prefix &&
967  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
968  exit(1);
969 
970  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
971  if (ost->forced_keyframes)
973 
974  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
975 
976  ost->top_field_first = -1;
977  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
978 
979  MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
980  ost->avfilter = av_strdup(filters);
981  } else {
982  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
983  }
984 
985  return ost;
986 }
987 
989 {
990  AVStream *st;
991  OutputStream *ost;
992  AVCodecContext *audio_enc;
993 
995  st = ost->st;
996 
997  audio_enc = st->codec;
998  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
999 
1000  if (!ost->stream_copy) {
1001  char *sample_fmt = NULL;
1002  const char *filters = "anull";
1003 
1004  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1005 
1006  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1007  if (sample_fmt &&
1008  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1009  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1010  exit(1);
1011  }
1012 
1013  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1014 
1015  MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1016  ost->avfilter = av_strdup(filters);
1017  }
1018 
1019  return ost;
1020 }
1021 
1023 {
1024  OutputStream *ost;
1025 
1026  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1027  if (!ost->stream_copy) {
1028  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1029  exit(1);
1030  }
1031 
1032  return ost;
1033 }
1034 
1036 {
1038  ost->stream_copy = 1;
1039  return ost;
1040 }
1041 
1043 {
1044  AVStream *st;
1045  OutputStream *ost;
1046  AVCodecContext *subtitle_enc;
1047 
1049  st = ost->st;
1050  subtitle_enc = st->codec;
1051 
1052  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1053 
1054  return ost;
1055 }
1056 
1057 /* arg format is "output-stream-index:streamid-value". */
1058 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1059 {
1060  OptionsContext *o = optctx;
1061  int idx;
1062  char *p;
1063  char idx_str[16];
1064 
1065  av_strlcpy(idx_str, arg, sizeof(idx_str));
1066  p = strchr(idx_str, ':');
1067  if (!p) {
1069  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1070  arg, opt);
1071  exit(1);
1072  }
1073  *p++ = '\0';
1074  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1075  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1076  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1077  return 0;
1078 }
1079 
1080 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1081 {
1082  AVFormatContext *is = ifile->ctx;
1083  AVFormatContext *os = ofile->ctx;
1084  AVChapter **tmp;
1085  int i;
1086 
1087  tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1088  if (!tmp)
1089  return AVERROR(ENOMEM);
1090  os->chapters = tmp;
1091 
1092  for (i = 0; i < is->nb_chapters; i++) {
1093  AVChapter *in_ch = is->chapters[i], *out_ch;
1094  int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1095  AV_TIME_BASE_Q, in_ch->time_base);
1096  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1098 
1099 
1100  if (in_ch->end < ts_off)
1101  continue;
1102  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1103  break;
1104 
1105  out_ch = av_mallocz(sizeof(AVChapter));
1106  if (!out_ch)
1107  return AVERROR(ENOMEM);
1108 
1109  out_ch->id = in_ch->id;
1110  out_ch->time_base = in_ch->time_base;
1111  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1112  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1113 
1114  if (copy_metadata)
1115  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1116 
1117  os->chapters[os->nb_chapters++] = out_ch;
1118  }
1119  return 0;
1120 }
1121 
1123  AVFormatContext *oc)
1124 {
1125  OutputStream *ost;
1126 
1128  ofilter->out_tmp->pad_idx)) {
1129  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1130  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1131  default:
1132  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1133  "currently.\n");
1134  exit(1);
1135  }
1136 
1137  ost->source_index = -1;
1138  ost->filter = ofilter;
1139 
1140  ofilter->ost = ost;
1141 
1142  if (ost->stream_copy) {
1143  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1144  "which is fed from a complex filtergraph. Filtering and streamcopy "
1145  "cannot be used together.\n", ost->file_index, ost->index);
1146  exit(1);
1147  }
1148 
1149  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1150  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1151  exit(1);
1152  }
1153  avfilter_inout_free(&ofilter->out_tmp);
1154 }
1155 
1157 {
1158  int i, ret = 0;
1159 
1160  for (i = 0; i < nb_filtergraphs; i++)
1161  if (!filtergraphs[i]->graph &&
1162  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1163  return ret;
1164  return 0;
1165 }
1166 
1167 static int open_output_file(OptionsContext *o, const char *filename)
1168 {
1169  AVFormatContext *oc;
1170  int i, j, err;
1171  AVOutputFormat *file_oformat;
1172  OutputStream *ost;
1173  InputStream *ist;
1174 
1175  if (configure_complex_filters() < 0) {
1176  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1177  exit(1);
1178  }
1179 
1180  if (!strcmp(filename, "-"))
1181  filename = "pipe:";
1182 
1183  oc = avformat_alloc_context();
1184  if (!oc) {
1185  print_error(filename, AVERROR(ENOMEM));
1186  exit(1);
1187  }
1188 
1189  if (o->format) {
1190  file_oformat = av_guess_format(o->format, NULL, NULL);
1191  if (!file_oformat) {
1192  av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1193  exit(1);
1194  }
1195  } else {
1196  file_oformat = av_guess_format(NULL, filename, NULL);
1197  if (!file_oformat) {
1198  av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1199  filename);
1200  exit(1);
1201  }
1202  }
1203 
1204  oc->oformat = file_oformat;
1205  oc->interrupt_callback = int_cb;
1206  av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1207 
1208  /* create streams for all unlabeled output pads */
1209  for (i = 0; i < nb_filtergraphs; i++) {
1210  FilterGraph *fg = filtergraphs[i];
1211  for (j = 0; j < fg->nb_outputs; j++) {
1212  OutputFilter *ofilter = fg->outputs[j];
1213 
1214  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1215  continue;
1216 
1218  ofilter->out_tmp->pad_idx)) {
1219  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1220  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1221  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1222  }
1223  init_output_filter(ofilter, o, oc);
1224  }
1225  }
1226 
1227  if (!o->nb_stream_maps) {
1228  /* pick the "best" stream of each type */
1229 #define NEW_STREAM(type, index)\
1230  if (index >= 0) {\
1231  ost = new_ ## type ## _stream(o, oc);\
1232  ost->source_index = index;\
1233  ost->sync_ist = input_streams[index];\
1234  input_streams[index]->discard = 0;\
1235  input_streams[index]->st->discard = AVDISCARD_NONE;\
1236  }
1237 
1238  /* video: highest resolution */
1239  if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1240  int area = 0, idx = -1;
1241  for (i = 0; i < nb_input_streams; i++) {
1242  ist = input_streams[i];
1243  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1244  ist->st->codec->width * ist->st->codec->height > area) {
1245  area = ist->st->codec->width * ist->st->codec->height;
1246  idx = i;
1247  }
1248  }
1249  NEW_STREAM(video, idx);
1250  }
1251 
1252  /* audio: most channels */
1253  if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1254  int channels = 0, idx = -1;
1255  for (i = 0; i < nb_input_streams; i++) {
1256  ist = input_streams[i];
1257  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1258  ist->st->codec->channels > channels) {
1259  channels = ist->st->codec->channels;
1260  idx = i;
1261  }
1262  }
1263  NEW_STREAM(audio, idx);
1264  }
1265 
1266  /* subtitles: pick first */
1268  for (i = 0; i < nb_input_streams; i++)
1269  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1270  NEW_STREAM(subtitle, i);
1271  break;
1272  }
1273  }
1274  /* do something with data? */
1275  } else {
1276  for (i = 0; i < o->nb_stream_maps; i++) {
1277  StreamMap *map = &o->stream_maps[i];
1278 
1279  if (map->disabled)
1280  continue;
1281 
1282  if (map->linklabel) {
1283  FilterGraph *fg;
1284  OutputFilter *ofilter = NULL;
1285  int j, k;
1286 
1287  for (j = 0; j < nb_filtergraphs; j++) {
1288  fg = filtergraphs[j];
1289  for (k = 0; k < fg->nb_outputs; k++) {
1290  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1291  if (out && !strcmp(out->name, map->linklabel)) {
1292  ofilter = fg->outputs[k];
1293  goto loop_end;
1294  }
1295  }
1296  }
1297 loop_end:
1298  if (!ofilter) {
1299  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1300  "in any defined filter graph.\n", map->linklabel);
1301  exit(1);
1302  }
1303  init_output_filter(ofilter, o, oc);
1304  } else {
1306  switch (ist->st->codec->codec_type) {
1307  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1308  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1309  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1310  case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1311  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1312  default:
1313  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1314  map->file_index, map->stream_index);
1315  exit(1);
1316  }
1317 
1318  ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1319  ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1320  map->sync_stream_index];
1321  ist->discard = 0;
1322  ist->st->discard = AVDISCARD_NONE;
1323  }
1324  }
1325  }
1326 
1327  /* handle attached files */
1328  for (i = 0; i < o->nb_attachments; i++) {
1329  AVIOContext *pb;
1330  uint8_t *attachment;
1331  const char *p;
1332  int64_t len;
1333 
1334  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1335  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1336  o->attachments[i]);
1337  exit(1);
1338  }
1339  if ((len = avio_size(pb)) <= 0) {
1340  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1341  o->attachments[i]);
1342  exit(1);
1343  }
1344  if (!(attachment = av_malloc(len))) {
1345  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1346  o->attachments[i]);
1347  exit(1);
1348  }
1349  avio_read(pb, attachment, len);
1350 
1351  ost = new_attachment_stream(o, oc);
1352  ost->stream_copy = 0;
1353  ost->source_index = -1;
1354  ost->attachment_filename = o->attachments[i];
1355  ost->st->codec->extradata = attachment;
1356  ost->st->codec->extradata_size = len;
1357 
1358  p = strrchr(o->attachments[i], '/');
1359  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1360  avio_close(pb);
1361  }
1362 
1364  if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1365  exit(1);
1366 
1367  output_files[nb_output_files - 1]->ctx = oc;
1370  if (o->recording_time != INT64_MAX)
1371  oc->duration = o->recording_time;
1375  av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1376 
1377  /* check filename in case of an image number is expected */
1378  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1379  if (!av_filename_number_test(oc->filename)) {
1380  print_error(oc->filename, AVERROR(EINVAL));
1381  exit(1);
1382  }
1383  }
1384 
1385  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1386  /* test if it already exists to avoid losing precious files */
1387  assert_file_overwrite(filename);
1388 
1389  /* open the file */
1390  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1391  &oc->interrupt_callback,
1392  &output_files[nb_output_files - 1]->opts)) < 0) {
1393  print_error(filename, err);
1394  exit(1);
1395  }
1396  }
1397 
1398  if (o->mux_preload) {
1399  uint8_t buf[64];
1400  snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1401  av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1402  }
1403  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1404  oc->flags |= AVFMT_FLAG_NONBLOCK;
1405 
1406  /* copy metadata */
1407  for (i = 0; i < o->nb_metadata_map; i++) {
1408  char *p;
1409  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1410 
1411  if (in_file_index >= nb_input_files) {
1412  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1413  exit(1);
1414  }
1415  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1416  in_file_index >= 0 ?
1417  input_files[in_file_index]->ctx : NULL, o);
1418  }
1419 
1420  /* copy chapters */
1421  if (o->chapters_input_file >= nb_input_files) {
1422  if (o->chapters_input_file == INT_MAX) {
1423  /* copy chapters from the first input file that has them*/
1424  o->chapters_input_file = -1;
1425  for (i = 0; i < nb_input_files; i++)
1426  if (input_files[i]->ctx->nb_chapters) {
1427  o->chapters_input_file = i;
1428  break;
1429  }
1430  } else {
1431  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1432  o->chapters_input_file);
1433  exit(1);
1434  }
1435  }
1436  if (o->chapters_input_file >= 0)
1439 
1440  /* copy global metadata by default */
1444  if (!o->metadata_streams_manual)
1445  for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1446  InputStream *ist;
1447  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1448  continue;
1450  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1451  }
1452 
1453  /* process manually set metadata */
1454  for (i = 0; i < o->nb_metadata; i++) {
1455  AVDictionary **m;
1456  char type, *val;
1457  const char *stream_spec;
1458  int index = 0, j, ret;
1459 
1460  val = strchr(o->metadata[i].u.str, '=');
1461  if (!val) {
1462  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1463  o->metadata[i].u.str);
1464  exit(1);
1465  }
1466  *val++ = 0;
1467 
1468  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1469  if (type == 's') {
1470  for (j = 0; j < oc->nb_streams; j++) {
1471  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1472  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1473  } else if (ret < 0)
1474  exit(1);
1475  }
1476  }
1477  else {
1478  switch (type) {
1479  case 'g':
1480  m = &oc->metadata;
1481  break;
1482  case 'c':
1483  if (index < 0 || index >= oc->nb_chapters) {
1484  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1485  exit(1);
1486  }
1487  m = &oc->chapters[index]->metadata;
1488  break;
1489  default:
1490  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1491  exit(1);
1492  }
1493  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1494  }
1495  }
1496 
1497  return 0;
1498 }
1499 
1500 static int opt_target(void *optctx, const char *opt, const char *arg)
1501 {
1502  OptionsContext *o = optctx;
1503  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1504  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1505 
1506  if (!strncmp(arg, "pal-", 4)) {
1507  norm = PAL;
1508  arg += 4;
1509  } else if (!strncmp(arg, "ntsc-", 5)) {
1510  norm = NTSC;
1511  arg += 5;
1512  } else if (!strncmp(arg, "film-", 5)) {
1513  norm = FILM;
1514  arg += 5;
1515  } else {
1516  /* Try to determine PAL/NTSC by peeking in the input files */
1517  if (nb_input_files) {
1518  int i, j, fr;
1519  for (j = 0; j < nb_input_files; j++) {
1520  for (i = 0; i < input_files[j]->nb_streams; i++) {
1521  AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1522  if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1523  continue;
1524  fr = c->time_base.den * 1000 / c->time_base.num;
1525  if (fr == 25000) {
1526  norm = PAL;
1527  break;
1528  } else if ((fr == 29970) || (fr == 23976)) {
1529  norm = NTSC;
1530  break;
1531  }
1532  }
1533  if (norm != UNKNOWN)
1534  break;
1535  }
1536  }
1537  if (norm != UNKNOWN)
1538  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1539  }
1540 
1541  if (norm == UNKNOWN) {
1542  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1543  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1544  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1545  exit(1);
1546  }
1547 
1548  if (!strcmp(arg, "vcd")) {
1549  opt_video_codec(o, "c:v", "mpeg1video");
1550  opt_audio_codec(o, "c:a", "mp2");
1551  parse_option(o, "f", "vcd", options);
1552 
1553  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1554  parse_option(o, "r", frame_rates[norm], options);
1555  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1556 
1557  opt_default(NULL, "b", "1150000");
1558  opt_default(NULL, "maxrate", "1150000");
1559  opt_default(NULL, "minrate", "1150000");
1560  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1561 
1562  opt_default(NULL, "b:a", "224000");
1563  parse_option(o, "ar", "44100", options);
1564  parse_option(o, "ac", "2", options);
1565 
1566  opt_default(NULL, "packetsize", "2324");
1567  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1568 
1569  /* We have to offset the PTS, so that it is consistent with the SCR.
1570  SCR starts at 36000, but the first two packs contain only padding
1571  and the first pack from the other stream, respectively, may also have
1572  been written before.
1573  So the real data starts at SCR 36000+3*1200. */
1574  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1575  } else if (!strcmp(arg, "svcd")) {
1576 
1577  opt_video_codec(o, "c:v", "mpeg2video");
1578  opt_audio_codec(o, "c:a", "mp2");
1579  parse_option(o, "f", "svcd", options);
1580 
1581  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1582  parse_option(o, "r", frame_rates[norm], options);
1583  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1584 
1585  opt_default(NULL, "b", "2040000");
1586  opt_default(NULL, "maxrate", "2516000");
1587  opt_default(NULL, "minrate", "0"); // 1145000;
1588  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1589  opt_default(NULL, "flags", "+scan_offset");
1590 
1591 
1592  opt_default(NULL, "b:a", "224000");
1593  parse_option(o, "ar", "44100", options);
1594 
1595  opt_default(NULL, "packetsize", "2324");
1596 
1597  } else if (!strcmp(arg, "dvd")) {
1598 
1599  opt_video_codec(o, "c:v", "mpeg2video");
1600  opt_audio_codec(o, "c:a", "ac3");
1601  parse_option(o, "f", "dvd", options);
1602 
1603  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1604  parse_option(o, "r", frame_rates[norm], options);
1605  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1606 
1607  opt_default(NULL, "b", "6000000");
1608  opt_default(NULL, "maxrate", "9000000");
1609  opt_default(NULL, "minrate", "0"); // 1500000;
1610  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1611 
1612  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1613  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1614 
1615  opt_default(NULL, "b:a", "448000");
1616  parse_option(o, "ar", "48000", options);
1617 
1618  } else if (!strncmp(arg, "dv", 2)) {
1619 
1620  parse_option(o, "f", "dv", options);
1621 
1622  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1623  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1624  norm == PAL ? "yuv420p" : "yuv411p", options);
1625  parse_option(o, "r", frame_rates[norm], options);
1626 
1627  parse_option(o, "ar", "48000", options);
1628  parse_option(o, "ac", "2", options);
1629 
1630  } else {
1631  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1632  return AVERROR(EINVAL);
1633  }
1634  return 0;
1635 }
1636 
1637 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1638 {
1640  vstats_filename = av_strdup (arg);
1641  return 0;
1642 }
1643 
1644 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1645 {
1646  char filename[40];
1647  time_t today2 = time(NULL);
1648  struct tm *today = localtime(&today2);
1649 
1650  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1651  today->tm_sec);
1652  return opt_vstats_file(NULL, opt, filename);
1653 }
1654 
1655 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1656 {
1657  OptionsContext *o = optctx;
1658  return parse_option(o, "frames:v", arg, options);
1659 }
1660 
1661 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1662 {
1663  OptionsContext *o = optctx;
1664  return parse_option(o, "frames:a", arg, options);
1665 }
1666 
1667 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1668 {
1669  OptionsContext *o = optctx;
1670  return parse_option(o, "frames:d", arg, options);
1671 }
1672 
1673 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1674 {
1675  OptionsContext *o = optctx;
1676  return parse_option(o, "tag:v", arg, options);
1677 }
1678 
1679 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1680 {
1681  OptionsContext *o = optctx;
1682  return parse_option(o, "tag:a", arg, options);
1683 }
1684 
1685 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1686 {
1687  OptionsContext *o = optctx;
1688  return parse_option(o, "tag:s", arg, options);
1689 }
1690 
1691 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1692 {
1693  OptionsContext *o = optctx;
1694  return parse_option(o, "filter:v", arg, options);
1695 }
1696 
1697 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1698 {
1699  OptionsContext *o = optctx;
1700  return parse_option(o, "filter:a", arg, options);
1701 }
1702 
1703 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1704 {
1705  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1706  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1707  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1708 
1711  return 0;
1712 }
1713 
1714 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1715 {
1716  av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1717  do_deinterlace = 1;
1718  return 0;
1719 }
1720 
1721 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1722 {
1723  int flags = av_parse_cpu_flags(arg);
1724 
1725  if (flags < 0)
1726  return flags;
1727 
1728  av_set_cpu_flags_mask(flags);
1729  return 0;
1730 }
1731 
1732 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1733 {
1734  OptionsContext *o = optctx;
1735  char layout_str[32];
1736  char *stream_str;
1737  char *ac_str;
1738  int ret, channels, ac_str_size;
1739  uint64_t layout;
1740 
1741  layout = av_get_channel_layout(arg);
1742  if (!layout) {
1743  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1744  return AVERROR(EINVAL);
1745  }
1746  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1747  ret = opt_default(NULL, opt, layout_str);
1748  if (ret < 0)
1749  return ret;
1750 
1751  /* set 'ac' option based on channel layout */
1752  channels = av_get_channel_layout_nb_channels(layout);
1753  snprintf(layout_str, sizeof(layout_str), "%d", channels);
1754  stream_str = strchr(opt, ':');
1755  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1756  ac_str = av_mallocz(ac_str_size);
1757  if (!ac_str)
1758  return AVERROR(ENOMEM);
1759  av_strlcpy(ac_str, "ac", 3);
1760  if (stream_str)
1761  av_strlcat(ac_str, stream_str, ac_str_size);
1762  ret = parse_option(o, ac_str, layout_str, options);
1763  av_free(ac_str);
1764 
1765  return ret;
1766 }
1767 
1768 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1769 {
1770  OptionsContext *o = optctx;
1771  return parse_option(o, "q:a", arg, options);
1772 }
1773 
1774 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1775 {
1777  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1778  return AVERROR(ENOMEM);
1781  return 0;
1782 }
1783 
1784 void show_help_default(const char *opt, const char *arg)
1785 {
1786  /* per-file options have at least one of those set */
1787  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1788  int show_advanced = 0, show_avoptions = 0;
1789 
1790  if (opt && *opt) {
1791  if (!strcmp(opt, "long"))
1792  show_advanced = 1;
1793  else if (!strcmp(opt, "full"))
1794  show_advanced = show_avoptions = 1;
1795  else
1796  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1797  }
1798 
1799  show_usage();
1800 
1801  printf("Getting help:\n"
1802  " -h -- print basic options\n"
1803  " -h long -- print more options\n"
1804  " -h full -- print all options (including all format and codec specific options, very long)\n"
1805  " See man %s for detailed description of the options.\n"
1806  "\n", program_name);
1807 
1808  show_help_options(options, "Print help / information / capabilities:",
1809  OPT_EXIT, 0, 0);
1810 
1811  show_help_options(options, "Global options (affect whole program "
1812  "instead of just one file:",
1813  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1814  if (show_advanced)
1815  show_help_options(options, "Advanced global options:", OPT_EXPERT,
1816  per_file | OPT_EXIT, 0);
1817 
1818  show_help_options(options, "Per-file main options:", 0,
1820  OPT_EXIT, per_file);
1821  if (show_advanced)
1822  show_help_options(options, "Advanced per-file options:",
1823  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1824 
1825  show_help_options(options, "Video options:",
1827  if (show_advanced)
1828  show_help_options(options, "Advanced Video options:",
1830 
1831  show_help_options(options, "Audio options:",
1833  if (show_advanced)
1834  show_help_options(options, "Advanced Audio options:",
1836  show_help_options(options, "Subtitle options:",
1837  OPT_SUBTITLE, 0, 0);
1838  printf("\n");
1839 
1840  if (show_avoptions) {
1845  }
1846 }
1847 
1848 void show_usage(void)
1849 {
1850  printf("Hyper fast Audio and Video encoder\n");
1851  printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1852  printf("\n");
1853 }
1854 
1855 enum OptGroup {
1858 };
1859 
1860 static const OptionGroupDef groups[] = {
1861  [GROUP_OUTFILE] = { "output file", NULL },
1862  [GROUP_INFILE] = { "input file", "i" },
1863 };
1864 
1865 static int open_files(OptionGroupList *l, const char *inout,
1866  int (*open_file)(OptionsContext*, const char*))
1867 {
1868  int i, ret;
1869 
1870  for (i = 0; i < l->nb_groups; i++) {
1871  OptionGroup *g = &l->groups[i];
1872  OptionsContext o;
1873 
1874  init_options(&o);
1875  o.g = g;
1876 
1877  ret = parse_optgroup(&o, g);
1878  if (ret < 0) {
1879  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1880  "%s.\n", inout, g->arg);
1881  return ret;
1882  }
1883 
1884  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1885  ret = open_file(&o, g->arg);
1886  uninit_options(&o);
1887  if (ret < 0) {
1888  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1889  inout, g->arg);
1890  return ret;
1891  }
1892  av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
1893  }
1894 
1895  return 0;
1896 }
1897 
1898 int avconv_parse_options(int argc, char **argv)
1899 {
1901  uint8_t error[128];
1902  int ret;
1903 
1904  memset(&octx, 0, sizeof(octx));
1905 
1906  /* split the commandline into an internal representation */
1907  ret = split_commandline(&octx, argc, argv, options, groups,
1908  FF_ARRAY_ELEMS(groups));
1909  if (ret < 0) {
1910  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1911  goto fail;
1912  }
1913 
1914  /* apply global options */
1915  ret = parse_optgroup(NULL, &octx.global_opts);
1916  if (ret < 0) {
1917  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1918  goto fail;
1919  }
1920 
1921  /* open input files */
1922  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1923  if (ret < 0) {
1924  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1925  goto fail;
1926  }
1927 
1928  /* open output files */
1929  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1930  if (ret < 0) {
1931  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1932  goto fail;
1933  }
1934 
1935 fail:
1936  uninit_parse_context(&octx);
1937  if (ret < 0) {
1938  av_strerror(ret, error, sizeof(error));
1939  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1940  }
1941  return ret;
1942 }
1943 
1944 #define OFFSET(x) offsetof(OptionsContext, x)
1945 const OptionDef options[] = {
1946  /* main options */
1947 #include "cmdutils_common_opts.h"
1948  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1949  "force format", "fmt" },
1950  { "y", OPT_BOOL, { &file_overwrite },
1951  "overwrite output files" },
1952  { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1953  "codec name", "codec" },
1954  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1955  "codec name", "codec" },
1956  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1957  "preset name", "preset" },
1958  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1959  "set input stream mapping",
1960  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1961  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1962  "set metadata information of outfile from infile",
1963  "outfile[,metadata]:infile[,metadata]" },
1964  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1965  "set chapters mapping", "input_file_index" },
1966  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1967  "record or transcode \"duration\" seconds of audio/video",
1968  "duration" },
1969  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1970  "set the limit file size in bytes", "limit_size" },
1971  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1972  "set the start time offset", "time_off" },
1973  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1974  "set the input ts offset", "time_off" },
1975  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1976  "set the input ts scale", "scale" },
1977  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1978  "add metadata", "string=string" },
1979  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1980  "set the number of data frames to record", "number" },
1981  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1982  "add timings for benchmarking" },
1983  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1984  "set max runtime in seconds", "limit" },
1985  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1986  "dump each input packet" },
1987  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1988  "when dumping packets, also dump the payload" },
1989  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1990  "read input at native frame rate", "" },
1991  { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1992  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1993  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1994  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1995  "video sync method", "" },
1996  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1997  "audio sync method", "" },
1998  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1999  "audio drift threshold", "threshold" },
2000  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2001  "copy timestamps" },
2002  { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2003  "copy input stream time base when stream copying" },
2004  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2005  "finish encoding within shortest input" },
2006  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2007  "timestamp discontinuity delta threshold", "threshold" },
2008  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2009  "exit on error", "error" },
2010  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2011  "copy initial non-keyframes" },
2012  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2013  "set the number of frames to record", "number" },
2014  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2015  "force codec tag/fourcc", "fourcc/tag" },
2016  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2017  "use fixed quality scale (VBR)", "q" },
2018  { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2019  "use fixed quality scale (VBR)", "q" },
2020  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2021  "set stream filterchain", "filter_list" },
2022  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2023  "create a complex filtergraph", "graph_description" },
2024  { "stats", OPT_BOOL, { &print_stats },
2025  "print progress report during encoding", },
2026  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2027  "add an attachment to the output file", "filename" },
2028  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2029  "extract an attachment into a file", "filename" },
2030  { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
2031  "set CPU flags mask", "mask" },
2032 
2033  /* video options */
2034  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2035  "set the number of video frames to record", "number" },
2036  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2037  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2038  { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
2039  "set frame size (WxH or abbreviation)", "size" },
2040  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2041  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2042  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2043  "set pixel format", "format" },
2044  { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2045  "disable video" },
2046  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2047  "discard threshold", "n" },
2048  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2049  "rate control override for specific intervals", "override" },
2050  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2051  "force video codec ('copy' to copy stream)", "codec" },
2052  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2053  "select the pass number (1 or 2)", "n" },
2054  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2055  "select two pass log file name prefix", "prefix" },
2056  { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2057  "this option is deprecated, use the yadif filter instead" },
2058  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2059  "dump video coding statistics to file" },
2060  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2061  "dump video coding statistics to file", "file" },
2062  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2063  "video filters", "filter list" },
2064  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2065  "specify intra matrix coeffs", "matrix" },
2066  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2067  "specify inter matrix coeffs", "matrix" },
2068  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2069  "top=1/bottom=0/auto=-1 field first", "" },
2070  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2071  "intra_dc_precision", "precision" },
2072  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
2073  "force video tag/fourcc", "fourcc/tag" },
2074  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2075  "show QP histogram" },
2076  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2077  "force the selected framerate, disable the best supported framerate selection" },
2078  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2079  "set the value of an outfile streamid", "streamIndex:value" },
2080  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2081  { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2082 
2083  /* audio options */
2084  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2085  "set the number of audio frames to record", "number" },
2086  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2087  "set audio quality (codec-specific)", "quality", },
2088  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2089  "set audio sampling rate (in Hz)", "rate" },
2090  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2091  "set number of audio channels", "channels" },
2092  { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2093  "disable audio" },
2094  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2095  "force audio codec ('copy' to copy stream)", "codec" },
2096  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2097  "force audio tag/fourcc", "fourcc/tag" },
2098  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2099  "change audio volume (256=normal)" , "volume" },
2100  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2101  "set sample format", "format" },
2102  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2103  "set channel layout", "layout" },
2104  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2105  "audio filters", "filter list" },
2106 
2107  /* subtitle options */
2108  { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2109  "disable subtitle" },
2110  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2111  "force subtitle codec ('copy' to copy stream)", "codec" },
2112  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2113  , "force subtitle tag/fourcc", "fourcc/tag" },
2114 
2115  /* grab options */
2116  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2117 
2118  /* muxer options */
2119  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2120  "set the maximum demux-decode delay", "seconds" },
2121  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2122  "set the initial demux-decode delay", "seconds" },
2123 
2124  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2125  "A comma-separated list of bitstream filters", "bitstream_filters" },
2126 
2127  /* data codec support */
2128  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2129  "force data codec ('copy' to copy stream)", "codec" },
2130 
2131  { NULL, },
2132 };