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