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 };
unsigned int nb_chapters
Definition: avformat.h:969
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:343
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: avconv_opt.c:45
int nb_input_files
Definition: avconv.c:105
int nb_dump_attachment
Definition: avconv.h:96
int nb_metadata
Definition: avconv.h:128
int nb_streamid_map
Definition: avconv.h:125
int copy_tb
Definition: avconv_opt.c:70
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
Bytestream IO Context.
Definition: avio.h:68
float mux_preload
Definition: avconv.h:114
#define OPT_EXPERT
Definition: cmdutils.h:129
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
Definition: avconv_opt.c:746
int64_t recording_time
Definition: avconv.h:310
static AVCodec * choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
Definition: avconv_opt.c:416
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:241
int nb_input_streams
Definition: avconv.c:103
static int file_overwrite
Definition: avconv_opt.c:75
#define VSYNC_AUTO
Definition: avconv.h:47
int nb_outputs
Definition: avconv.h:193
int resample_channels
Definition: avconv.h:223
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:122
int stream_copy
Definition: avconv.h:299
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1494
static OutputStream * new_audio_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:989
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1005
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:945
AVRational frame_rate
Definition: avconv.h:278
int audio_channels
Definition: rtp.c:42
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:95
#define OPT_VIDEO
Definition: cmdutils.h:131
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1123
float mux_max_delay
Definition: avconv.h:115
int * streamid_map
Definition: avconv.h:124
static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1680
int nb_stream_maps
Definition: avconv.h:100
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:476
AVStream * st
Definition: avconv.h:259
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:556
AVRational framerate
Definition: avconv.h:215
static int video_discard
Definition: avconv_opt.c:76
enum AVCodecID video_codec
default video codec
Definition: avformat.h:387
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1388
#define OPT_AUDIO
Definition: cmdutils.h:132
AVFilterInOut * out_tmp
Definition: avconv.h:181
int qscale
Definition: avcodec.h:613
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:697
int num
numerator
Definition: rational.h:44
int video_sync_method
Definition: avconv_opt.c:64
int index
stream index in AVFormatContext
Definition: avformat.h:623
int nb_frame_pix_fmts
Definition: avconv.h:87
static int sync(AVFormatContext *s, uint8_t *header)
Read input until we find the next ident.
Definition: lxfdec.c:84
static int configure_complex_filters(void)
Definition: avconv_opt.c:1157
void av_set_cpu_flags_mask(int mask)
Set a mask on flags returned by av_get_cpu_flags().
Definition: cpu.c:42
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1724
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1733
#define pass
Definition: fft.c:334
int audio_sync_method
Definition: avconv_opt.c:63
AVBitStreamFilterContext * bitstream_filters
Definition: avconv.h:272
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
external API header
const char * arg
Definition: cmdutils.h:231
static int using_stdin
Definition: avconv_opt.c:78
float audio_drift_threshold
Definition: avconv_opt.c:59
int do_pkt_dump
Definition: avconv_opt.c:68
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1638
#define OPT_DATA
Definition: cmdutils.h:138
FilterGraph ** filtergraphs
Definition: avconv.c:112
enum AVMediaType type
Definition: avcodec.h:2973
discard all
Definition: avcodec.h:536
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1692
AVDictionary * metadata
Definition: avformat.h:817
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
#define OPT_DOUBLE
Definition: cmdutils.h:146
#define OPT_FLOAT
Definition: cmdutils.h:134
AVCodec.
Definition: avcodec.h:2960
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:71
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:933
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:1442
int64_t start_time
Definition: avconv.h:311
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1043
int index
Definition: avconv.h:185
static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: avconv_opt.c:729
SpecifierOpt * frame_pix_fmts
Definition: avconv.h:86
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1465
static AVInputFormat * file_iformat
Definition: avplay.c:230
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:531
Format I/O context.
Definition: avformat.h:828
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:197
int do_hex_dump
Definition: avconv_opt.c:67
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:306
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
char * logfile_prefix
Definition: avconv.h:290
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:432
int copy_initial_nonkeyframes
Definition: avconv.h:301
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT
Definition: avformat.h:395
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:181
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:402
AVOptions.
#define HAS_ARG
Definition: cmdutils.h:127
InputFile ** input_files
Definition: avconv.c:104
AVDictionary * opts
Definition: avconv.h:308
#define VSYNC_PASSTHROUGH
Definition: avconv.h:48
int id
unique ID to identify the chapter
Definition: avformat.h:814
int id
Format-specific stream ID.
Definition: avformat.h:629
AVDictionary * opts
Definition: avconv.h:297
int copy_ts
Definition: avconv_opt.c:69
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
Definition: avconv_opt.c:431
#define OPT_OFFSET
Definition: cmdutils.h:141
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
const char * name
int shortest
Definition: avconv.h:314
AVStream ** streams
Definition: avformat.h:876
int av_parse_cpu_flags(const char *s)
Parse CPU flags from a string.
Definition: cpu.c:48
double strtod(const char *, char **)
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:97
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:480
int nb_streams
Definition: avconv.h:241
static int audio_disable
Definition: avplay.c:237
int sync_file_index
Definition: avconv.h:57
static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1686
static int flags
Definition: log.c:42
uint32_t tag
Definition: movenc.c:802
#define OPT_SPEC
Definition: cmdutils.h:142
int resample_sample_rate
Definition: avconv.h:222
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:106
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:117
AVCodec * dec
Definition: avconv.h:201
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:165
int file_index
Definition: avconv.h:197
struct AVBitStreamFilterContext * next
Definition: avcodec.h:4485
int resample_pix_fmt
Definition: avconv.h:219
int resample_height
Definition: avconv.h:217
static int opt_video_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1674
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:446
float quality_factor
Definition: avcodec.h:614
struct AVOutputFormat * oformat
Definition: avformat.h:842
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1500
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: utils.c:1499
OptGroup
Definition: avconv_opt.c:1856
#define AVCONV_DATADIR
Definition: config.h:6
int configure_filtergraph(FilterGraph *fg)
#define OPT_SUBTITLE
Definition: cmdutils.h:135
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:122
static const uint8_t frame_size[4]
Definition: g723_1_data.h:47
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Definition: utils.c:2952
void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:127
enum AVCodecID id
Definition: avcodec.h:2974
static int64_t start_time
Definition: avplay.c:248
void show_help_default(const char *opt, const char *arg)
Per-avtool specific help handler.
Definition: avconv_opt.c:1785
int rate_emu
Definition: avconv.h:243
AVDictionary * metadata
Definition: avformat.h:972
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
int64_t start_time
Definition: avconv.h:73
int64_t last_mux_dts
Definition: avconv.h:271
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1775
sample_fmts
Definition: avconv_filter.c:63
int qp_hist
Definition: avconv_opt.c:73
int64_t sws_flags
Definition: avconv.h:296
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:782
g
Definition: yuv2rgb.c:540
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:113
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
const char * name
Definition: cmdutils.h:125
static void dump_attachment(AVStream *st, const char *filename)
Definition: avconv_opt.c:515
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:279
AVChapter ** chapters
Definition: avformat.h:970
Definition: graph2dot.c:48
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2736
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
int video_disable
Definition: avconv.h:118
#define VSYNC_VFR
Definition: avconv.h:50
int flags
Definition: cmdutils.h:126
int force_fps
Definition: avconv.h:279
float dts_delta_threshold
Definition: avconv_opt.c:60
StreamMap * stream_maps
Definition: avconv.h:99
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:67
int do_deinterlace
Definition: avconv_opt.c:65
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:106
uint64_t limit_filesize
Definition: avconv.h:113
const char * format
Definition: avconv.h:74
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
Definition: avconv_opt.c:280
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
int nb_output_streams
Definition: avconv.c:108
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:437
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:641
OutputFilter * filter
Definition: avconv.h:293
int intra_dc_precision
precision of the intra DC coefficient - 8
Definition: avcodec.h:1951
AVDictionary * opts
Definition: avconv.h:214
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:636
int file_index
Definition: avconv.h:55
MetadataMap(* meta_data_maps)[2]
Definition: avconv.h:102
unsigned int nb_streams
A list of all streams in the file.
Definition: avformat.h:875
int nb_attachments
Definition: avconv.h:108
static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1715
int nb_filtergraphs
Definition: avconv.c:113
OptionGroup * groups
Definition: cmdutils.h:248
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: utils.c:207
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2324
size_t off
Definition: cmdutils.h:150
char * linklabel
Definition: avconv.h:59
int void avio_flush(AVIOContext *s)
Definition: aviobuf.c:180
audio channel layout utility functions
const AVIOInterruptCB int_cb
Definition: avconv.c:145
char filename[1024]
input or output filename
Definition: avformat.h:878
SpecifierOpt * audio_channels
Definition: avconv.h:78
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
Definition: avconv_opt.c:703
int av_strcasecmp(const char *a, const char *b)
Definition: avstring.c:140
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: avconv_opt.c:307
int nb_audio_sample_rate
Definition: avconv.h:81
int metadata_chapters_manual
Definition: avconv.h:106
enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
Guess the codec ID based upon muxer and filename.
Definition: utils.c:186
struct OutputStream * ost
Definition: avconv.h:176
int width
picture width / height.
Definition: avcodec.h:1508
AVBitStreamFilterContext * av_bitstream_filter_init(const char *name)
static int intra_dc_precision
Definition: avconv_opt.c:77
SpecifierOpt * audio_sample_rate
Definition: avconv.h:80
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:164
static int open_output_file(OptionsContext *o, const char *filename)
Definition: avconv_opt.c:1168
SpecifierOpt * dump_attachment
Definition: avconv.h:95
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:245
#define OPT_EXIT
Definition: cmdutils.h:137
int start_frame
Definition: avcodec.h:611
SpecifierOpt * metadata_map
Definition: avconv.h:153
union SpecifierOpt::@1 u
#define OPT_INT64
Definition: cmdutils.h:136
int64_t max_frames
Definition: avconv.h:274
#define AV_RL32
Definition: intreadwrite.h:146
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:114
int do_benchmark
Definition: avconv_opt.c:66
AVDictionary * metadata
Definition: avformat.h:699
AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: utils.c:151
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1645
static const OptionGroupDef groups[]
Definition: avconv_opt.c:1861
const OptionDef options[]
Definition: avconv_opt.c:1946
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:178
Opaque data information usually sparse.
Definition: avutil.h:183
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:692
SpecifierOpt * frame_sizes
Definition: avconv.h:84
#define VSYNC_CFR
Definition: avconv.h:49
static OutputStream * new_video_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:870
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:2206
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
Definition: avconv_opt.c:853
AVFilterContext * filter_ctx
filter context associated to this input/output
RcOverride * rc_override
Definition: avcodec.h:2325
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1698
uint8_t * str
Definition: cmdutils.h:116
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:146
Stream structure.
Definition: avformat.h:622
A linked-list of the inputs/outputs of the filter chain.
Definition: avfiltergraph.h:98
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:816
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:371
NULL
Definition: eval.c:52
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:181
SpecifierOpt * frame_rates
Definition: avconv.h:82
sample_fmt
Definition: avconv_filter.c:63
int ost_index
Definition: avconv.h:309
struct InputStream * sync_ist
Definition: avconv.h:265
OutputFile ** output_files
Definition: avconv.c:109
external API header
enum AVMediaType codec_type
Definition: avcodec.h:1347
double ts_scale
Definition: avconv.h:211
int64_t recording_time
Definition: avconv.h:112
int chapters_input_file
Definition: avconv.h:110
enum AVCodecID codec_id
Definition: avcodec.h:1350
static AVCodec * find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
Definition: avconv_opt.c:387
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:166
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
AVIOContext * pb
I/O context.
Definition: avformat.h:861
OutputStream ** output_streams
Definition: avconv.c:107
int ist_index
Definition: avconv.h:239
static double parse_frame_aspect_ratio(const char *arg)
Definition: avconv_opt.c:122
const char * graph_desc
Definition: avconv.h:186
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1668
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:144
main external API structure.
Definition: avcodec.h:1339
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1513
int rate_emu
Definition: avconv.h:91
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:252
int metadata_streams_manual
Definition: avconv.h:105
const char * attachment_filename
Definition: avconv.h:300
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1365
a very simple circular buffer FIFO implementation
int audio_disable
Definition: avconv.h:119
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1704
int64_t input_ts_offset
Definition: avconv.h:90
int extradata_size
Definition: avcodec.h:1455
static void uninit_options(OptionsContext *o)
Definition: avconv_opt.c:81
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:63
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:1892
AVStream * st
Definition: avconv.h:198
static int open_input_file(OptionsContext *o, const char *filename)
Definition: avconv_opt.c:547
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1656
#define NTSC
Definition: bktr.c:66
int index
Definition: gxfenc.c:72
char * vstats_filename
Definition: avconv_opt.c:57
int pad_idx
index of the filt_ctx pad to use for linking
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:388
const char program_name[]
program name, defined by the program for show_version().
Definition: avconv.c:82
int file_index
Definition: avconv.h:256
int metadata_global_manual
Definition: avconv.h:104
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:158
int avconv_parse_options(int argc, char **argv)
Definition: avconv_opt.c:1899
static OutputContext octx
Definition: avprobe.c:109
void * grow_array(void *array, int elem_size, int *size, int new_size)
Realloc array to hold new_size elements of elem_size.
Definition: cmdutils.c:1520
#define OPT_STRING
Definition: cmdutils.h:130
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: avconv_opt.c:1081
AVMediaType
Definition: avutil.h:177
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:765
int shortest
Definition: avconv.h:116
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:458
int64_t ts_offset
Definition: avconv.h:240
misc parsing utilities
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:77
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:1899
int end_frame
Definition: avcodec.h:612
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:450
int print_stats
Definition: avconv_opt.c:72
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:84
char * name
unique name for this input/output in the list
int nb_audio_channels
Definition: avconv.h:79
#define OPT_TIME
Definition: cmdutils.h:145
int source_index
Definition: avconv.h:258
SpecifierOpt * metadata
Definition: avconv.h:127
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1420
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: utils.c:1518
int64_t start_time
Decoding: position of the first frame of the component, in AV_TIME_BASE fractional seconds...
Definition: avformat.h:885
void show_usage(void)
Definition: avconv_opt.c:1849
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:1730
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:23
int resample_sample_fmt
Definition: avconv.h:221
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:170
int64_t start
Definition: avformat.h:816
char * forced_keyframes
Definition: avconv.h:288
int nb_frame_rates
Definition: avconv.h:83
enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:449
#define OPT_BOOL
Definition: cmdutils.h:128
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:32
int resample_width
Definition: avconv.h:218
int guess_input_channel_layout(InputStream *ist)
Definition: avconv.c:1086
Main libavformat public API header.
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:705
struct FilterGraph * graph
Definition: avconv.h:177
uint64_t limit_filesize
Definition: avconv.h:312
#define OPT_INT
Definition: cmdutils.h:133
AVDictionary * format_opts
Definition: cmdutils.h:237
int nb_frame_sizes
Definition: avconv.h:85
OptionGroupList * groups
Definition: cmdutils.h:255
OptionGroup * g
Definition: avconv.h:70
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:116
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:265
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:2236
InputStream ** input_streams
Definition: avconv.c:102
OptionGroup global_opts
Definition: cmdutils.h:253
int audio_volume
Definition: avconv_opt.c:62
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1059
const char ** attachments
Definition: avconv.h:107
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:815
int den
denominator
Definition: rational.h:45
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
Set the fields of the given AVCodecContext to default values corresponding to the given codec (defaul...
Definition: options.c:80
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1769
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:2713
AVFormatContext * ctx
Definition: avconv.h:236
union OptionDef::@2 u
int stream_index
Definition: avconv.h:56
AVCodec * enc
Definition: avconv.h:273
int nb_metadata_map
Definition: avconv.h:154
static uint8_t * get_line(AVIOContext *s)
Definition: avconv_opt.c:684
enum AVCodecID id
Definition: avcodec.h:451
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:509
pixel format definitions
char * avfilter
Definition: avconv.h:294
char * value
Definition: dict.h:76
int eof_reached
true if eof reached
Definition: avio.h:96
#define OFFSET(x)
Definition: avconv_opt.c:1945
int len
int channels
number of audio channels
Definition: avcodec.h:2105
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:386
int top_field_first
Definition: avconv.h:280
OutputFilter ** outputs
Definition: avconv.h:192
static int input_sync
Definition: avconv_opt.c:79
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
int disabled
Definition: avconv.h:54
#define PAL
Definition: bktr.c:64
AVFormatContext * ctx
Definition: avconv.h:307
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:146
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1662
uint64_t layout
int nb_output_files
Definition: avconv.c:110
AVDictionary * codec_opts
Definition: cmdutils.h:236
int64_t duration
Decoding: duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:893
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0...
Definition: cmdutils.c:1279
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:152
float frame_aspect_ratio
Definition: avconv.h:282
int sync_stream_index
Definition: avconv.h:58
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: avconv_opt.c:1866
int exit_on_error
Definition: avconv_opt.c:71
#define SET_DICT(type, meta, context, index)
static OutputStream * new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1036
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:1389
int discard
Definition: avconv.h:199
#define OPT_PERFILE
Definition: cmdutils.h:139
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1722
enum AVPixelFormat pix_fmts[2]
Definition: avconv.h:303
static OutputStream * new_data_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1023
static int video_disable
Definition: avplay.c:238
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:690
int index
Definition: avconv.h:257
void assert_avoptions(AVDictionary *m)
Definition: avconv.c:224
struct SwsContext * sws_opts
Definition: cmdutils.h:238
uint64_t resample_channel_layout
Definition: avconv.h:224
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:158
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1501
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:54
static void assert_file_overwrite(const char *filename)
Definition: avconv_opt.c:493
discard nothing
Definition: avcodec.h:531
int subtitle_disable
Definition: avconv.h:120
#define NEW_STREAM(type, index)
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
static void init_options(OptionsContext *o)
Definition: avconv_opt.c:112