Libav
avconv_opt.c
Go to the documentation of this file.
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "avconv.h"
24 #include "cmdutils.h"
25 
26 #include "libavformat/avformat.h"
27 
28 #include "libavcodec/avcodec.h"
29 
30 #include "libavfilter/avfilter.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
45 {\
46  int i, ret;\
47  for (i = 0; i < o->nb_ ## name; i++) {\
48  char *spec = o->name[i].specifier;\
49  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50  outvar = o->name[i].u.type;\
51  else if (ret < 0)\
52  exit_program(1);\
53  }\
54 }
55 
56 const HWAccel hwaccels[] = {
57 #if HAVE_VDPAU_X11
59 #endif
60 #if HAVE_DXVA2_LIB
62 #endif
63 #if CONFIG_VDA
64  { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
65 #endif
66  { 0 },
67 };
68 
70 
73 
74 int audio_volume = 256;
77 int do_benchmark = 0;
78 int do_hex_dump = 0;
79 int do_pkt_dump = 0;
80 int copy_ts = 0;
81 int copy_tb = 1;
82 int exit_on_error = 0;
83 int print_stats = 1;
84 int qp_hist = 0;
85 
86 static int file_overwrite = 0;
87 static int file_skip = 0;
88 static int video_discard = 0;
89 static int intra_dc_precision = 8;
90 static int using_stdin = 0;
91 static int input_sync;
92 
94 {
95  const OptionDef *po = options;
96  int i;
97 
98  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
99  while (po->name) {
100  void *dst = (uint8_t*)o + po->u.off;
101 
102  if (po->flags & OPT_SPEC) {
103  SpecifierOpt **so = dst;
104  int i, *count = (int*)(so + 1);
105  for (i = 0; i < *count; i++) {
106  av_freep(&(*so)[i].specifier);
107  if (po->flags & OPT_STRING)
108  av_freep(&(*so)[i].u.str);
109  }
110  av_freep(so);
111  *count = 0;
112  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
113  av_freep(dst);
114  po++;
115  }
116 
117  for (i = 0; i < o->nb_stream_maps; i++)
119  av_freep(&o->stream_maps);
121  av_freep(&o->streamid_map);
122 }
123 
125 {
126  memset(o, 0, sizeof(*o));
127 
128  o->mux_max_delay = 0.7;
130  o->recording_time = INT64_MAX;
131  o->limit_filesize = UINT64_MAX;
132  o->chapters_input_file = INT_MAX;
133  o->accurate_seek = 1;
134 }
135 
136 /* return a copy of the input with the stream specifiers removed from the keys */
138 {
139  AVDictionaryEntry *e = NULL;
140  AVDictionary *ret = NULL;
141 
142  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
143  char *p = strchr(e->key, ':');
144 
145  if (p)
146  *p = 0;
147  av_dict_set(&ret, e->key, e->value, 0);
148  if (p)
149  *p = ':';
150  }
151  return ret;
152 }
153 
154 static double parse_frame_aspect_ratio(const char *arg)
155 {
156  int x = 0, y = 0;
157  double ar = 0;
158  const char *p;
159  char *end;
160 
161  p = strchr(arg, ':');
162  if (p) {
163  x = strtol(arg, &end, 10);
164  if (end == p)
165  y = strtol(end + 1, &end, 10);
166  if (x > 0 && y > 0)
167  ar = (double)x / (double)y;
168  } else
169  ar = strtod(arg, NULL);
170 
171  if (!ar) {
172  av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
173  exit_program(1);
174  }
175  return ar;
176 }
177 
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
179 {
180  OptionsContext *o = optctx;
181  return parse_option(o, "codec:a", arg, options);
182 }
183 
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
185 {
186  OptionsContext *o = optctx;
187  return parse_option(o, "codec:v", arg, options);
188 }
189 
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
191 {
192  OptionsContext *o = optctx;
193  return parse_option(o, "codec:s", arg, options);
194 }
195 
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
197 {
198  OptionsContext *o = optctx;
199  return parse_option(o, "codec:d", arg, options);
200 }
201 
202 static int opt_map(void *optctx, const char *opt, const char *arg)
203 {
204  OptionsContext *o = optctx;
205  StreamMap *m = NULL;
206  int i, negative = 0, file_idx;
207  int sync_file_idx = -1, sync_stream_idx;
208  char *p, *sync;
209  char *map;
210 
211  if (*arg == '-') {
212  negative = 1;
213  arg++;
214  }
215  map = av_strdup(arg);
216 
217  /* parse sync stream first, just pick first matching stream */
218  if (sync = strchr(map, ',')) {
219  *sync = 0;
220  sync_file_idx = strtol(sync + 1, &sync, 0);
221  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
223  exit_program(1);
224  }
225  if (*sync)
226  sync++;
227  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
230  sync_stream_idx = i;
231  break;
232  }
233  if (i == input_files[sync_file_idx]->nb_streams) {
234  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235  "match any streams.\n", arg);
236  exit_program(1);
237  }
238  }
239 
240 
241  if (map[0] == '[') {
242  /* this mapping refers to lavfi output */
243  const char *c = map + 1;
245  m = &o->stream_maps[o->nb_stream_maps - 1];
246  m->linklabel = av_get_token(&c, "]");
247  if (!m->linklabel) {
248  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
249  exit_program(1);
250  }
251  } else {
252  file_idx = strtol(map, &p, 0);
253  if (file_idx >= nb_input_files || file_idx < 0) {
254  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
255  exit_program(1);
256  }
257  if (negative)
258  /* disable some already defined maps */
259  for (i = 0; i < o->nb_stream_maps; i++) {
260  m = &o->stream_maps[i];
261  if (file_idx == m->file_index &&
264  *p == ':' ? p + 1 : p) > 0)
265  m->disabled = 1;
266  }
267  else
268  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
269  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
270  *p == ':' ? p + 1 : p) <= 0)
271  continue;
273  m = &o->stream_maps[o->nb_stream_maps - 1];
274 
275  m->file_index = file_idx;
276  m->stream_index = i;
277 
278  if (sync_file_idx >= 0) {
279  m->sync_file_index = sync_file_idx;
280  m->sync_stream_index = sync_stream_idx;
281  } else {
282  m->sync_file_index = file_idx;
283  m->sync_stream_index = i;
284  }
285  }
286  }
287 
288  if (!m) {
289  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
290  exit_program(1);
291  }
292 
293  av_freep(&map);
294  return 0;
295 }
296 
297 static int opt_attach(void *optctx, const char *opt, const char *arg)
298 {
299  OptionsContext *o = optctx;
301  o->attachments[o->nb_attachments - 1] = arg;
302  return 0;
303 }
304 
312 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
313 {
314  if (*arg) {
315  *type = *arg;
316  switch (*arg) {
317  case 'g':
318  break;
319  case 's':
320  if (*(++arg) && *arg != ':') {
321  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
322  exit_program(1);
323  }
324  *stream_spec = *arg == ':' ? arg + 1 : "";
325  break;
326  case 'c':
327  case 'p':
328  if (*(++arg) == ':')
329  *index = strtol(++arg, NULL, 0);
330  break;
331  default:
332  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
333  exit_program(1);
334  }
335  } else
336  *type = 'g';
337 }
338 
339 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
340 {
341  AVDictionary **meta_in = NULL;
342  AVDictionary **meta_out;
343  int i, ret = 0;
344  char type_in, type_out;
345  const char *istream_spec = NULL, *ostream_spec = NULL;
346  int idx_in = 0, idx_out = 0;
347 
348  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
349  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
350 
351  if (type_in == 'g' || type_out == 'g')
352  o->metadata_global_manual = 1;
353  if (type_in == 's' || type_out == 's')
355  if (type_in == 'c' || type_out == 'c')
357 
358  /* ic is NULL when just disabling automatic mappings */
359  if (!ic)
360  return 0;
361 
362 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
363  if ((index) < 0 || (index) >= (nb_elems)) {\
364  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
365  (desc), (index));\
366  exit_program(1);\
367  }
368 
369 #define SET_DICT(type, meta, context, index)\
370  switch (type) {\
371  case 'g':\
372  meta = &context->metadata;\
373  break;\
374  case 'c':\
375  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
376  meta = &context->chapters[index]->metadata;\
377  break;\
378  case 'p':\
379  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
380  meta = &context->programs[index]->metadata;\
381  break;\
382  case 's':\
383  break; /* handled separately below */ \
384  default: av_assert0(0);\
385  }\
386 
387  SET_DICT(type_in, meta_in, ic, idx_in);
388  SET_DICT(type_out, meta_out, oc, idx_out);
389 
390  /* for input streams choose first matching stream */
391  if (type_in == 's') {
392  for (i = 0; i < ic->nb_streams; i++) {
393  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
394  meta_in = &ic->streams[i]->metadata;
395  break;
396  } else if (ret < 0)
397  exit_program(1);
398  }
399  if (!meta_in) {
400  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
401  exit_program(1);
402  }
403  }
404 
405  if (type_out == 's') {
406  for (i = 0; i < oc->nb_streams; i++) {
407  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
408  meta_out = &oc->streams[i]->metadata;
409  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
410  } else if (ret < 0)
411  exit_program(1);
412  }
413  } else
414  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
415 
416  return 0;
417 }
418 
419 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
420 {
421  const AVCodecDescriptor *desc;
422  const char *codec_string = encoder ? "encoder" : "decoder";
423  AVCodec *codec;
424 
425  codec = encoder ?
428 
429  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
430  codec = encoder ? avcodec_find_encoder(desc->id) :
431  avcodec_find_decoder(desc->id);
432  if (codec)
433  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
434  codec_string, codec->name, desc->name);
435  }
436 
437  if (!codec) {
438  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
439  exit_program(1);
440  }
441  if (codec->type != type) {
442  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
443  exit_program(1);
444  }
445  return codec;
446 }
447 
449 {
450  char *codec_name = NULL;
451 
452  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
453  if (codec_name) {
454  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
455  st->codec->codec_id = codec->id;
456  return codec;
457  } else
458  return avcodec_find_decoder(st->codec->codec_id);
459 }
460 
461 /* Add all the streams from the given input file to the global
462  * list of input streams. */
464 {
465  int i, ret;
466 
467  for (i = 0; i < ic->nb_streams; i++) {
468  AVStream *st = ic->streams[i];
469  AVCodecContext *dec = st->codec;
470  InputStream *ist = av_mallocz(sizeof(*ist));
471  char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
472  char *codec_tag = NULL;
473  char *next;
474 
475  if (!ist)
476  exit_program(1);
477 
479  input_streams[nb_input_streams - 1] = ist;
480 
481  ist->st = st;
482  ist->file_index = nb_input_files;
483  ist->discard = 1;
484  st->discard = AVDISCARD_ALL;
485 
486  ist->ts_scale = 1.0;
487  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
488 
489  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
490  if (codec_tag) {
491  uint32_t tag = strtol(codec_tag, &next, 0);
492  if (*next)
493  tag = AV_RL32(codec_tag);
494  st->codec->codec_tag = tag;
495  }
496 
497  ist->dec = choose_decoder(o, ic, st);
498  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
499 
500  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
501  if (!ist->dec_ctx) {
502  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
503  exit_program(1);
504  }
505 
506  ret = avcodec_copy_context(ist->dec_ctx, dec);
507  if (ret < 0) {
508  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
509  exit_program(1);
510  }
511 
512  switch (dec->codec_type) {
513  case AVMEDIA_TYPE_VIDEO:
514  ist->resample_height = ist->dec_ctx->height;
515  ist->resample_width = ist->dec_ctx->width;
516  ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
517 
518  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
519  if (framerate && av_parse_video_rate(&ist->framerate,
520  framerate) < 0) {
521  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
522  framerate);
523  exit_program(1);
524  }
525 
526  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
527  if (hwaccel) {
528  if (!strcmp(hwaccel, "none"))
529  ist->hwaccel_id = HWACCEL_NONE;
530  else if (!strcmp(hwaccel, "auto"))
531  ist->hwaccel_id = HWACCEL_AUTO;
532  else {
533  int i;
534  for (i = 0; hwaccels[i].name; i++) {
535  if (!strcmp(hwaccels[i].name, hwaccel)) {
536  ist->hwaccel_id = hwaccels[i].id;
537  break;
538  }
539  }
540 
541  if (!ist->hwaccel_id) {
542  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
543  hwaccel);
544  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
545  for (i = 0; hwaccels[i].name; i++)
546  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
547  av_log(NULL, AV_LOG_FATAL, "\n");
548  exit_program(1);
549  }
550  }
551  }
552 
553  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
554  if (hwaccel_device) {
555  ist->hwaccel_device = av_strdup(hwaccel_device);
556  if (!ist->hwaccel_device)
557  exit_program(1);
558  }
560 
561  break;
562  case AVMEDIA_TYPE_AUDIO:
564 
567  ist->resample_channels = ist->dec_ctx->channels;
569 
570  break;
571  case AVMEDIA_TYPE_DATA:
575  break;
576  default:
577  abort();
578  }
579  }
580 }
581 
582 static void assert_file_overwrite(const char *filename)
583 {
584  if (file_overwrite && file_skip) {
585  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
586  exit_program(1);
587  }
588 
589  if (!file_overwrite &&
590  (!strchr(filename, ':') || filename[1] == ':' ||
591  av_strstart(filename, "file:", NULL))) {
592  if (avio_check(filename, 0) == 0) {
593  if (!using_stdin && !file_skip) {
594  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
595  fflush(stderr);
596  if (!read_yesno()) {
597  fprintf(stderr, "Not overwriting - exiting\n");
598  exit_program(1);
599  }
600  }
601  else {
602  fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
603  exit_program(1);
604  }
605  }
606  }
607 }
608 
609 static void dump_attachment(AVStream *st, const char *filename)
610 {
611  int ret;
612  AVIOContext *out = NULL;
614 
615  if (!st->codec->extradata_size) {
616  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
617  nb_input_files - 1, st->index);
618  return;
619  }
620  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
621  filename = e->value;
622  if (!*filename) {
623  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
624  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
625  exit_program(1);
626  }
627 
628  assert_file_overwrite(filename);
629 
630  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
631  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
632  filename);
633  exit_program(1);
634  }
635 
636  avio_write(out, st->codec->extradata, st->codec->extradata_size);
637  avio_flush(out);
638  avio_close(out);
639 }
640 
641 static int open_input_file(OptionsContext *o, const char *filename)
642 {
643  InputFile *f;
644  AVFormatContext *ic;
646  int err, i, ret;
647  int64_t timestamp;
648  uint8_t buf[128];
649  AVDictionary **opts;
650  AVDictionary *unused_opts = NULL;
651  AVDictionaryEntry *e = NULL;
652  int orig_nb_streams; // number of streams before avformat_find_stream_info
653 
654  if (o->format) {
655  if (!(file_iformat = av_find_input_format(o->format))) {
656  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
657  exit_program(1);
658  }
659  }
660 
661  if (!strcmp(filename, "-"))
662  filename = "pipe:";
663 
664  using_stdin |= !strncmp(filename, "pipe:", 5) ||
665  !strcmp(filename, "/dev/stdin");
666 
667  /* get default parameters from command line */
668  ic = avformat_alloc_context();
669  if (!ic) {
670  print_error(filename, AVERROR(ENOMEM));
671  exit_program(1);
672  }
673  if (o->nb_audio_sample_rate) {
674  snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
675  av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
676  }
677  if (o->nb_audio_channels) {
678  /* because we set audio_channels based on both the "ac" and
679  * "channel_layout" options, we need to check that the specified
680  * demuxer actually has the "channels" option before setting it */
681  if (file_iformat && file_iformat->priv_class &&
682  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
684  snprintf(buf, sizeof(buf), "%d",
685  o->audio_channels[o->nb_audio_channels - 1].u.i);
686  av_dict_set(&o->g->format_opts, "channels", buf, 0);
687  }
688  }
689  if (o->nb_frame_rates) {
690  /* set the format-level framerate option;
691  * this is important for video grabbers, e.g. x11 */
692  if (file_iformat && file_iformat->priv_class &&
693  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
695  av_dict_set(&o->g->format_opts, "framerate",
696  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
697  }
698  }
699  if (o->nb_frame_sizes) {
700  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
701  }
702  if (o->nb_frame_pix_fmts)
703  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
704 
705  ic->flags |= AVFMT_FLAG_NONBLOCK;
707 
708  /* open the input file with generic libav function */
709  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
710  if (err < 0) {
711  print_error(filename, err);
712  exit_program(1);
713  }
715 
716  /* apply forced codec ids */
717  for (i = 0; i < ic->nb_streams; i++)
718  choose_decoder(o, ic, ic->streams[i]);
719 
720  /* Set AVCodecContext options for avformat_find_stream_info */
721  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
722  orig_nb_streams = ic->nb_streams;
723 
724  /* If not enough info to get the stream parameters, we decode the
725  first frames to get it. (used in mpeg case for example) */
726  ret = avformat_find_stream_info(ic, opts);
727  if (ret < 0) {
728  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
730  exit_program(1);
731  }
732 
733  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
734  /* add the stream start time */
735  if (ic->start_time != AV_NOPTS_VALUE)
736  timestamp += ic->start_time;
737 
738  /* if seeking requested, we execute it */
739  if (o->start_time != AV_NOPTS_VALUE) {
740  ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
741  if (ret < 0) {
742  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
743  filename, (double)timestamp / AV_TIME_BASE);
744  }
745  }
746 
747  /* update the current parameters so that they match the one of the input stream */
748  add_input_streams(o, ic);
749 
750  /* dump the file content */
751  av_dump_format(ic, nb_input_files, filename, 0);
752 
754  f = av_mallocz(sizeof(*f));
755  if (!f)
756  exit_program(1);
757  input_files[nb_input_files - 1] = f;
758 
759  f->ctx = ic;
761  f->start_time = o->start_time;
763  f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
764  f->nb_streams = ic->nb_streams;
765  f->rate_emu = o->rate_emu;
767 
768  /* check if all codec options have been used */
769  unused_opts = strip_specifiers(o->g->codec_opts);
770  for (i = f->ist_index; i < nb_input_streams; i++) {
771  e = NULL;
772  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
774  av_dict_set(&unused_opts, e->key, NULL, 0);
775  }
776 
777  e = NULL;
778  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
779  const AVClass *class = avcodec_get_class();
780  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
782  if (!option)
783  continue;
784  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
785  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
786  "input file #%d (%s) is not a decoding option.\n", e->key,
787  option->help ? option->help : "", nb_input_files - 1,
788  filename);
789  exit_program(1);
790  }
791 
792  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
793  "input file #%d (%s) has not been used for any stream. The most "
794  "likely reason is either wrong type (e.g. a video option with "
795  "no video streams) or that it is a private option of some decoder "
796  "which was not actually used for any stream.\n", e->key,
797  option->help ? option->help : "", nb_input_files - 1, filename);
798  }
799  av_dict_free(&unused_opts);
800 
801  for (i = 0; i < o->nb_dump_attachment; i++) {
802  int j;
803 
804  for (j = 0; j < ic->nb_streams; j++) {
805  AVStream *st = ic->streams[j];
806 
807  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
809  }
810  }
811 
812  for (i = 0; i < orig_nb_streams; i++)
813  av_dict_free(&opts[i]);
814  av_freep(&opts);
815 
816  return 0;
817 }
818 
820 {
821  AVIOContext *line;
822  uint8_t *buf;
823  char c;
824 
825  if (avio_open_dyn_buf(&line) < 0) {
826  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
827  exit_program(1);
828  }
829 
830  while ((c = avio_r8(s)) && c != '\n')
831  avio_w8(line, c);
832  avio_w8(line, 0);
833  avio_close_dyn_buf(line, &buf);
834 
835  return buf;
836 }
837 
838 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
839 {
840  int i, ret = -1;
841  char filename[1000];
842  const char *base[3] = { getenv("AVCONV_DATADIR"),
843  getenv("HOME"),
845  };
846 
847  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
848  if (!base[i])
849  continue;
850  if (codec_name) {
851  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
852  i != 1 ? "" : "/.avconv", codec_name, preset_name);
853  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
854  }
855  if (ret < 0) {
856  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
857  i != 1 ? "" : "/.avconv", preset_name);
858  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
859  }
860  }
861  return ret;
862 }
863 
865 {
866  char *codec_name = NULL;
867 
868  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
869  if (!codec_name) {
871  NULL, ost->st->codec->codec_type);
872  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
873  } else if (!strcmp(codec_name, "copy"))
874  ost->stream_copy = 1;
875  else {
876  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
877  ost->st->codec->codec_id = ost->enc->id;
878  }
879 }
880 
882 {
883  OutputStream *ost;
884  AVStream *st = avformat_new_stream(oc, NULL);
885  int idx = oc->nb_streams - 1, ret = 0;
886  char *bsf = NULL, *next, *codec_tag = NULL;
887  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
888  double qscale = -1;
889 
890  if (!st) {
891  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
892  exit_program(1);
893  }
894 
895  if (oc->nb_streams - 1 < o->nb_streamid_map)
896  st->id = o->streamid_map[oc->nb_streams - 1];
897 
899  if (!(ost = av_mallocz(sizeof(*ost))))
900  exit_program(1);
902 
903  ost->file_index = nb_output_files - 1;
904  ost->index = idx;
905  ost->st = st;
906  st->codec->codec_type = type;
907  choose_encoder(o, oc, ost);
908 
909  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
910  if (!ost->enc_ctx) {
911  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
912  exit_program(1);
913  }
914  ost->enc_ctx->codec_type = type;
915 
916  if (ost->enc) {
917  AVIOContext *s = NULL;
918  char *buf = NULL, *arg = NULL, *preset = NULL;
919 
920  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
921 
922  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
923  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
924  do {
925  buf = get_line(s);
926  if (!buf[0] || buf[0] == '#') {
927  av_free(buf);
928  continue;
929  }
930  if (!(arg = strchr(buf, '='))) {
931  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
932  exit_program(1);
933  }
934  *arg++ = 0;
936  av_free(buf);
937  } while (!s->eof_reached);
938  avio_close(s);
939  }
940  if (ret) {
942  "Preset %s specified for stream %d:%d, but could not be opened.\n",
943  preset, ost->file_index, ost->index);
944  exit_program(1);
945  }
946  } else {
948  }
949 
950  ost->max_frames = INT64_MAX;
951  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
952 
953  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
954  while (bsf) {
955  if (next = strchr(bsf, ','))
956  *next++ = 0;
957  if (!(bsfc = av_bitstream_filter_init(bsf))) {
958  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
959  exit_program(1);
960  }
961  if (bsfc_prev)
962  bsfc_prev->next = bsfc;
963  else
964  ost->bitstream_filters = bsfc;
965 
966  bsfc_prev = bsfc;
967  bsf = next;
968  }
969 
970  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
971  if (codec_tag) {
972  uint32_t tag = strtol(codec_tag, &next, 0);
973  if (*next)
974  tag = AV_RL32(codec_tag);
975  ost->enc_ctx->codec_tag = tag;
976  }
977 
978  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
979  if (qscale >= 0) {
981  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
982  }
983 
984  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
986 
987  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
988 
989  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
990 
991  ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
993 
994  return ost;
995 }
996 
997 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
998 {
999  int i;
1000  const char *p = str;
1001  for (i = 0;; i++) {
1002  dest[i] = atoi(p);
1003  if (i == 63)
1004  break;
1005  p = strchr(p, ',');
1006  if (!p) {
1007  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1008  exit_program(1);
1009  }
1010  p++;
1011  }
1012 }
1013 
1014 /* read file contents into a string */
1015 static uint8_t *read_file(const char *filename)
1016 {
1017  AVIOContext *pb = NULL;
1018  AVIOContext *dyn_buf = NULL;
1019  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1020  uint8_t buf[1024], *str;
1021 
1022  if (ret < 0) {
1023  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1024  return NULL;
1025  }
1026 
1027  ret = avio_open_dyn_buf(&dyn_buf);
1028  if (ret < 0) {
1029  avio_closep(&pb);
1030  return NULL;
1031  }
1032  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1033  avio_write(dyn_buf, buf, ret);
1034  avio_w8(dyn_buf, 0);
1035  avio_closep(&pb);
1036 
1037  ret = avio_close_dyn_buf(dyn_buf, &str);
1038  if (ret < 0)
1039  return NULL;
1040  return str;
1041 }
1042 
1044  OutputStream *ost)
1045 {
1046  AVStream *st = ost->st;
1047  char *filter = NULL, *filter_script = NULL;
1048 
1049  MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1050  MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1051 
1052  if (filter_script && filter) {
1053  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1054  "output stream #%d:%d.\n", nb_output_files, st->index);
1055  exit_program(1);
1056  }
1057 
1058  if (filter_script)
1059  return read_file(filter_script);
1060  else if (filter)
1061  return av_strdup(filter);
1062 
1063  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1064  "null" : "anull");
1065 }
1066 
1068 {
1069  AVStream *st;
1070  OutputStream *ost;
1071  AVCodecContext *video_enc;
1072  char *frame_aspect_ratio = NULL;
1073 
1074  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1075  st = ost->st;
1076  video_enc = ost->enc_ctx;
1077 
1078  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1079  if (frame_aspect_ratio)
1080  ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1081 
1082  if (!ost->stream_copy) {
1083  const char *p = NULL;
1084  char *frame_rate = NULL, *frame_size = NULL;
1085  char *frame_pix_fmt = NULL;
1086  char *intra_matrix = NULL, *inter_matrix = NULL;
1087  int do_pass = 0;
1088  int i;
1089 
1090  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1091  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1092  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1093  exit_program(1);
1094  }
1095 
1096  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1097  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1098  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1099  exit_program(1);
1100  }
1101 
1102  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1103  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1104  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1105  exit_program(1);
1106  }
1107  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1108 
1109  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1110  if (intra_matrix) {
1111  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1112  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1113  exit_program(1);
1114  }
1115  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1116  }
1117  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1118  if (inter_matrix) {
1119  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1120  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1121  exit_program(1);
1122  }
1123  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1124  }
1125 
1126  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1127  for (i = 0; p; i++) {
1128  int start, end, q;
1129  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1130  if (e != 3) {
1131  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1132  exit_program(1);
1133  }
1134  video_enc->rc_override =
1135  av_realloc(video_enc->rc_override,
1136  sizeof(RcOverride) * (i + 1));
1137  video_enc->rc_override[i].start_frame = start;
1138  video_enc->rc_override[i].end_frame = end;
1139  if (q > 0) {
1140  video_enc->rc_override[i].qscale = q;
1141  video_enc->rc_override[i].quality_factor = 1.0;
1142  }
1143  else {
1144  video_enc->rc_override[i].qscale = 0;
1145  video_enc->rc_override[i].quality_factor = -q/100.0;
1146  }
1147  p = strchr(p, '/');
1148  if (p) p++;
1149  }
1150  video_enc->rc_override_count = i;
1151  video_enc->intra_dc_precision = intra_dc_precision - 8;
1152 
1153  /* two pass mode */
1154  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1155  if (do_pass) {
1156  if (do_pass == 1) {
1157  video_enc->flags |= CODEC_FLAG_PASS1;
1158  } else {
1159  video_enc->flags |= CODEC_FLAG_PASS2;
1160  }
1161  }
1162 
1163  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1164  if (ost->logfile_prefix &&
1165  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1166  exit_program(1);
1167 
1168  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1169  if (ost->forced_keyframes)
1171 
1172  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1173 
1174  ost->top_field_first = -1;
1175  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1176 
1177 
1178  ost->avfilter = get_ost_filters(o, oc, ost);
1179  if (!ost->avfilter)
1180  exit_program(1);
1181  } else {
1182  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1183  }
1184 
1185  return ost;
1186 }
1187 
1189 {
1190  AVStream *st;
1191  OutputStream *ost;
1192  AVCodecContext *audio_enc;
1193 
1194  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1195  st = ost->st;
1196 
1197  audio_enc = ost->enc_ctx;
1198  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1199 
1200  if (!ost->stream_copy) {
1201  char *sample_fmt = NULL;
1202 
1203  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1204 
1205  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1206  if (sample_fmt &&
1207  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1208  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1209  exit_program(1);
1210  }
1211 
1212  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1213 
1214  ost->avfilter = get_ost_filters(o, oc, ost);
1215  if (!ost->avfilter)
1216  exit_program(1);
1217  }
1218 
1219  return ost;
1220 }
1221 
1223 {
1224  OutputStream *ost;
1225 
1226  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1227  if (!ost->stream_copy) {
1228  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1229  exit_program(1);
1230  }
1231 
1232  return ost;
1233 }
1234 
1236 {
1238  ost->stream_copy = 1;
1239  ost->finished = 1;
1240  return ost;
1241 }
1242 
1244 {
1245  OutputStream *ost;
1246  AVCodecContext *subtitle_enc;
1247 
1249  subtitle_enc = ost->enc_ctx;
1250 
1251  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1252 
1253  return ost;
1254 }
1255 
1256 /* arg format is "output-stream-index:streamid-value". */
1257 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1258 {
1259  OptionsContext *o = optctx;
1260  int idx;
1261  char *p;
1262  char idx_str[16];
1263 
1264  av_strlcpy(idx_str, arg, sizeof(idx_str));
1265  p = strchr(idx_str, ':');
1266  if (!p) {
1268  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1269  arg, opt);
1270  exit_program(1);
1271  }
1272  *p++ = '\0';
1273  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1274  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1275  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1276  return 0;
1277 }
1278 
1279 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1280 {
1281  AVFormatContext *is = ifile->ctx;
1282  AVFormatContext *os = ofile->ctx;
1283  AVChapter **tmp;
1284  int i;
1285 
1286  tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1287  if (!tmp)
1288  return AVERROR(ENOMEM);
1289  os->chapters = tmp;
1290 
1291  for (i = 0; i < is->nb_chapters; i++) {
1292  AVChapter *in_ch = is->chapters[i], *out_ch;
1293  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1294  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1295  AV_TIME_BASE_Q, in_ch->time_base);
1296  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1298 
1299 
1300  if (in_ch->end < ts_off)
1301  continue;
1302  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1303  break;
1304 
1305  out_ch = av_mallocz(sizeof(AVChapter));
1306  if (!out_ch)
1307  return AVERROR(ENOMEM);
1308 
1309  out_ch->id = in_ch->id;
1310  out_ch->time_base = in_ch->time_base;
1311  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1312  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1313 
1314  if (copy_metadata)
1315  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1316 
1317  os->chapters[os->nb_chapters++] = out_ch;
1318  }
1319  return 0;
1320 }
1321 
1323  AVFormatContext *oc)
1324 {
1325  OutputStream *ost;
1326 
1328  ofilter->out_tmp->pad_idx)) {
1329  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1330  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1331  default:
1332  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1333  "currently.\n");
1334  exit_program(1);
1335  }
1336 
1337  ost->source_index = -1;
1338  ost->filter = ofilter;
1339 
1340  ofilter->ost = ost;
1341 
1342  if (ost->stream_copy) {
1343  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1344  "which is fed from a complex filtergraph. Filtering and streamcopy "
1345  "cannot be used together.\n", ost->file_index, ost->index);
1346  exit_program(1);
1347  }
1348 
1349  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1350  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1351  exit_program(1);
1352  }
1353  avfilter_inout_free(&ofilter->out_tmp);
1354 }
1355 
1357 {
1358  int i, ret = 0;
1359 
1360  for (i = 0; i < nb_filtergraphs; i++)
1361  if (!filtergraphs[i]->graph &&
1362  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1363  return ret;
1364  return 0;
1365 }
1366 
1367 static int open_output_file(OptionsContext *o, const char *filename)
1368 {
1369  AVFormatContext *oc;
1370  int i, j, err;
1371  AVOutputFormat *file_oformat;
1372  OutputFile *of;
1373  OutputStream *ost;
1374  InputStream *ist;
1375  AVDictionary *unused_opts = NULL;
1376  AVDictionaryEntry *e = NULL;
1377 
1378  if (configure_complex_filters() < 0) {
1379  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1380  exit_program(1);
1381  }
1382 
1384  of = av_mallocz(sizeof(*of));
1385  if (!of)
1386  exit_program(1);
1387  output_files[nb_output_files - 1] = of;
1388 
1390  of->recording_time = o->recording_time;
1391  of->start_time = o->start_time;
1392  of->limit_filesize = o->limit_filesize;
1393  of->shortest = o->shortest;
1394  av_dict_copy(&of->opts, o->g->format_opts, 0);
1395 
1396  if (!strcmp(filename, "-"))
1397  filename = "pipe:";
1398 
1399  oc = avformat_alloc_context();
1400  if (!oc) {
1401  print_error(filename, AVERROR(ENOMEM));
1402  exit_program(1);
1403  }
1404  of->ctx = oc;
1405  if (o->recording_time != INT64_MAX)
1406  oc->duration = o->recording_time;
1407 
1408  if (o->format) {
1409  file_oformat = av_guess_format(o->format, NULL, NULL);
1410  if (!file_oformat) {
1411  av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1412  exit_program(1);
1413  }
1414  } else {
1415  file_oformat = av_guess_format(NULL, filename, NULL);
1416  if (!file_oformat) {
1417  av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1418  filename);
1419  exit_program(1);
1420  }
1421  }
1422 
1423  oc->oformat = file_oformat;
1424  oc->interrupt_callback = int_cb;
1425  av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1426 
1427  /* create streams for all unlabeled output pads */
1428  for (i = 0; i < nb_filtergraphs; i++) {
1429  FilterGraph *fg = filtergraphs[i];
1430  for (j = 0; j < fg->nb_outputs; j++) {
1431  OutputFilter *ofilter = fg->outputs[j];
1432 
1433  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1434  continue;
1435 
1437  ofilter->out_tmp->pad_idx)) {
1438  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1439  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1440  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1441  }
1442  init_output_filter(ofilter, o, oc);
1443  }
1444  }
1445 
1446  if (!o->nb_stream_maps) {
1447  /* pick the "best" stream of each type */
1448 #define NEW_STREAM(type, index)\
1449  if (index >= 0) {\
1450  ost = new_ ## type ## _stream(o, oc);\
1451  ost->source_index = index;\
1452  ost->sync_ist = input_streams[index];\
1453  input_streams[index]->discard = 0;\
1454  input_streams[index]->st->discard = AVDISCARD_NONE;\
1455  }
1456 
1457  /* video: highest resolution */
1458  if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1459  int area = 0, idx = -1;
1460  for (i = 0; i < nb_input_streams; i++) {
1461  ist = input_streams[i];
1462  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1463  ist->st->codec->width * ist->st->codec->height > area) {
1464  area = ist->st->codec->width * ist->st->codec->height;
1465  idx = i;
1466  }
1467  }
1468  NEW_STREAM(video, idx);
1469  }
1470 
1471  /* audio: most channels */
1472  if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1473  int channels = 0, idx = -1;
1474  for (i = 0; i < nb_input_streams; i++) {
1475  ist = input_streams[i];
1476  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1477  ist->st->codec->channels > channels) {
1478  channels = ist->st->codec->channels;
1479  idx = i;
1480  }
1481  }
1482  NEW_STREAM(audio, idx);
1483  }
1484 
1485  /* subtitles: pick first */
1487  for (i = 0; i < nb_input_streams; i++)
1488  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1489  NEW_STREAM(subtitle, i);
1490  break;
1491  }
1492  }
1493  /* do something with data? */
1494  } else {
1495  for (i = 0; i < o->nb_stream_maps; i++) {
1496  StreamMap *map = &o->stream_maps[i];
1497 
1498  if (map->disabled)
1499  continue;
1500 
1501  if (map->linklabel) {
1502  FilterGraph *fg;
1503  OutputFilter *ofilter = NULL;
1504  int j, k;
1505 
1506  for (j = 0; j < nb_filtergraphs; j++) {
1507  fg = filtergraphs[j];
1508  for (k = 0; k < fg->nb_outputs; k++) {
1509  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1510  if (out && !strcmp(out->name, map->linklabel)) {
1511  ofilter = fg->outputs[k];
1512  goto loop_end;
1513  }
1514  }
1515  }
1516 loop_end:
1517  if (!ofilter) {
1518  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1519  "in any defined filter graph.\n", map->linklabel);
1520  exit_program(1);
1521  }
1522  init_output_filter(ofilter, o, oc);
1523  } else {
1525  switch (ist->st->codec->codec_type) {
1526  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1527  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1528  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1529  case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1530  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1531  default:
1532  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1533  map->file_index, map->stream_index);
1534  exit_program(1);
1535  }
1536 
1537  ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1538  ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1539  map->sync_stream_index];
1540  ist->discard = 0;
1541  ist->st->discard = AVDISCARD_NONE;
1542  }
1543  }
1544  }
1545 
1546  /* handle attached files */
1547  for (i = 0; i < o->nb_attachments; i++) {
1548  AVIOContext *pb;
1549  uint8_t *attachment;
1550  const char *p;
1551  int64_t len;
1552 
1553  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1554  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1555  o->attachments[i]);
1556  exit_program(1);
1557  }
1558  if ((len = avio_size(pb)) <= 0) {
1559  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1560  o->attachments[i]);
1561  exit_program(1);
1562  }
1563  if (!(attachment = av_malloc(len))) {
1564  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1565  o->attachments[i]);
1566  exit_program(1);
1567  }
1568  avio_read(pb, attachment, len);
1569 
1570  ost = new_attachment_stream(o, oc);
1571  ost->stream_copy = 0;
1572  ost->source_index = -1;
1573  ost->attachment_filename = o->attachments[i];
1574  ost->st->codec->extradata = attachment;
1575  ost->st->codec->extradata_size = len;
1576 
1577  p = strrchr(o->attachments[i], '/');
1578  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1579  avio_close(pb);
1580  }
1581 
1582  /* check if all codec options have been used */
1583  unused_opts = strip_specifiers(o->g->codec_opts);
1584  for (i = of->ost_index; i < nb_output_streams; i++) {
1585  e = NULL;
1586  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1588  av_dict_set(&unused_opts, e->key, NULL, 0);
1589  }
1590 
1591  e = NULL;
1592  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1593  const AVClass *class = avcodec_get_class();
1594  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1596  if (!option)
1597  continue;
1598  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1599  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1600  "output file #%d (%s) is not an encoding option.\n", e->key,
1601  option->help ? option->help : "", nb_output_files - 1,
1602  filename);
1603  exit_program(1);
1604  }
1605 
1606  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1607  "output file #%d (%s) has not been used for any stream. The most "
1608  "likely reason is either wrong type (e.g. a video option with "
1609  "no video streams) or that it is a private option of some encoder "
1610  "which was not actually used for any stream.\n", e->key,
1611  option->help ? option->help : "", nb_output_files - 1, filename);
1612  }
1613  av_dict_free(&unused_opts);
1614 
1615  /* check filename in case of an image number is expected */
1616  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1617  if (!av_filename_number_test(oc->filename)) {
1618  print_error(oc->filename, AVERROR(EINVAL));
1619  exit_program(1);
1620  }
1621  }
1622 
1623  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1624  /* test if it already exists to avoid losing precious files */
1625  assert_file_overwrite(filename);
1626 
1627  /* open the file */
1628  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1629  &oc->interrupt_callback,
1630  &of->opts)) < 0) {
1631  print_error(filename, err);
1632  exit_program(1);
1633  }
1634  }
1635 
1636  if (o->mux_preload) {
1637  uint8_t buf[64];
1638  snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1639  av_dict_set(&of->opts, "preload", buf, 0);
1640  }
1641  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1642  oc->flags |= AVFMT_FLAG_NONBLOCK;
1643 
1644  /* copy metadata */
1645  for (i = 0; i < o->nb_metadata_map; i++) {
1646  char *p;
1647  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1648 
1649  if (in_file_index >= nb_input_files) {
1650  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1651  exit_program(1);
1652  }
1653  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1654  in_file_index >= 0 ?
1655  input_files[in_file_index]->ctx : NULL, o);
1656  }
1657 
1658  /* copy chapters */
1659  if (o->chapters_input_file >= nb_input_files) {
1660  if (o->chapters_input_file == INT_MAX) {
1661  /* copy chapters from the first input file that has them*/
1662  o->chapters_input_file = -1;
1663  for (i = 0; i < nb_input_files; i++)
1664  if (input_files[i]->ctx->nb_chapters) {
1665  o->chapters_input_file = i;
1666  break;
1667  }
1668  } else {
1669  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1670  o->chapters_input_file);
1671  exit_program(1);
1672  }
1673  }
1674  if (o->chapters_input_file >= 0)
1677 
1678  /* copy global metadata by default */
1682  if (!o->metadata_streams_manual)
1683  for (i = of->ost_index; i < nb_output_streams; i++) {
1684  InputStream *ist;
1685  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1686  continue;
1688  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1689  }
1690 
1691  /* process manually set metadata */
1692  for (i = 0; i < o->nb_metadata; i++) {
1693  AVDictionary **m;
1694  char type, *val;
1695  const char *stream_spec;
1696  int index = 0, j, ret;
1697 
1698  val = strchr(o->metadata[i].u.str, '=');
1699  if (!val) {
1700  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1701  o->metadata[i].u.str);
1702  exit_program(1);
1703  }
1704  *val++ = 0;
1705 
1706  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1707  if (type == 's') {
1708  for (j = 0; j < oc->nb_streams; j++) {
1709  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1710  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1711  } else if (ret < 0)
1712  exit_program(1);
1713  }
1714  }
1715  else {
1716  switch (type) {
1717  case 'g':
1718  m = &oc->metadata;
1719  break;
1720  case 'c':
1721  if (index < 0 || index >= oc->nb_chapters) {
1722  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1723  exit_program(1);
1724  }
1725  m = &oc->chapters[index]->metadata;
1726  break;
1727  default:
1728  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1729  exit_program(1);
1730  }
1731  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1732  }
1733  }
1734 
1735  return 0;
1736 }
1737 
1738 static int opt_target(void *optctx, const char *opt, const char *arg)
1739 {
1740  OptionsContext *o = optctx;
1741  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1742  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1743 
1744  if (!strncmp(arg, "pal-", 4)) {
1745  norm = PAL;
1746  arg += 4;
1747  } else if (!strncmp(arg, "ntsc-", 5)) {
1748  norm = NTSC;
1749  arg += 5;
1750  } else if (!strncmp(arg, "film-", 5)) {
1751  norm = FILM;
1752  arg += 5;
1753  } else {
1754  /* Try to determine PAL/NTSC by peeking in the input files */
1755  if (nb_input_files) {
1756  int i, j, fr;
1757  for (j = 0; j < nb_input_files; j++) {
1758  for (i = 0; i < input_files[j]->nb_streams; i++) {
1759  AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1760  if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1761  !c->time_base.num)
1762  continue;
1763  fr = c->time_base.den * 1000 / c->time_base.num;
1764  if (fr == 25000) {
1765  norm = PAL;
1766  break;
1767  } else if ((fr == 29970) || (fr == 23976)) {
1768  norm = NTSC;
1769  break;
1770  }
1771  }
1772  if (norm != UNKNOWN)
1773  break;
1774  }
1775  }
1776  if (norm != UNKNOWN)
1777  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1778  }
1779 
1780  if (norm == UNKNOWN) {
1781  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1782  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1783  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1784  exit_program(1);
1785  }
1786 
1787  if (!strcmp(arg, "vcd")) {
1788  opt_video_codec(o, "c:v", "mpeg1video");
1789  opt_audio_codec(o, "c:a", "mp2");
1790  parse_option(o, "f", "vcd", options);
1791 
1792  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1793  parse_option(o, "r", frame_rates[norm], options);
1794  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1795 
1796  opt_default(NULL, "b", "1150000");
1797  opt_default(NULL, "maxrate", "1150000");
1798  opt_default(NULL, "minrate", "1150000");
1799  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1800 
1801  opt_default(NULL, "b:a", "224000");
1802  parse_option(o, "ar", "44100", options);
1803  parse_option(o, "ac", "2", options);
1804 
1805  opt_default(NULL, "packetsize", "2324");
1806  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1807 
1808  /* We have to offset the PTS, so that it is consistent with the SCR.
1809  SCR starts at 36000, but the first two packs contain only padding
1810  and the first pack from the other stream, respectively, may also have
1811  been written before.
1812  So the real data starts at SCR 36000+3*1200. */
1813  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1814  } else if (!strcmp(arg, "svcd")) {
1815 
1816  opt_video_codec(o, "c:v", "mpeg2video");
1817  opt_audio_codec(o, "c:a", "mp2");
1818  parse_option(o, "f", "svcd", options);
1819 
1820  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1821  parse_option(o, "r", frame_rates[norm], options);
1822  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1823 
1824  opt_default(NULL, "b", "2040000");
1825  opt_default(NULL, "maxrate", "2516000");
1826  opt_default(NULL, "minrate", "0"); // 1145000;
1827  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1828  opt_default(NULL, "flags", "+scan_offset");
1829 
1830 
1831  opt_default(NULL, "b:a", "224000");
1832  parse_option(o, "ar", "44100", options);
1833 
1834  opt_default(NULL, "packetsize", "2324");
1835 
1836  } else if (!strcmp(arg, "dvd")) {
1837 
1838  opt_video_codec(o, "c:v", "mpeg2video");
1839  opt_audio_codec(o, "c:a", "ac3");
1840  parse_option(o, "f", "dvd", options);
1841 
1842  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1843  parse_option(o, "r", frame_rates[norm], options);
1844  opt_default(NULL, "g", norm == PAL ? "15" : "18");
1845 
1846  opt_default(NULL, "b", "6000000");
1847  opt_default(NULL, "maxrate", "9000000");
1848  opt_default(NULL, "minrate", "0"); // 1500000;
1849  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1850 
1851  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1852  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1853 
1854  opt_default(NULL, "b:a", "448000");
1855  parse_option(o, "ar", "48000", options);
1856 
1857  } else if (!strncmp(arg, "dv", 2)) {
1858 
1859  parse_option(o, "f", "dv", options);
1860 
1861  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1862  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1863  norm == PAL ? "yuv420p" : "yuv411p", options);
1864  parse_option(o, "r", frame_rates[norm], options);
1865 
1866  parse_option(o, "ar", "48000", options);
1867  parse_option(o, "ac", "2", options);
1868 
1869  } else {
1870  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1871  return AVERROR(EINVAL);
1872  }
1873  return 0;
1874 }
1875 
1876 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1877 {
1879  vstats_filename = av_strdup (arg);
1880  return 0;
1881 }
1882 
1883 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1884 {
1885  char filename[40];
1886  time_t today2 = time(NULL);
1887  struct tm *today = localtime(&today2);
1888 
1889  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1890  today->tm_sec);
1891  return opt_vstats_file(NULL, opt, filename);
1892 }
1893 
1894 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1895 {
1896  OptionsContext *o = optctx;
1897  return parse_option(o, "frames:v", arg, options);
1898 }
1899 
1900 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1901 {
1902  OptionsContext *o = optctx;
1903  return parse_option(o, "frames:a", arg, options);
1904 }
1905 
1906 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1907 {
1908  OptionsContext *o = optctx;
1909  return parse_option(o, "frames:d", arg, options);
1910 }
1911 
1912 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1913 {
1914  OptionsContext *o = optctx;
1915  return parse_option(o, "tag:v", arg, options);
1916 }
1917 
1918 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1919 {
1920  OptionsContext *o = optctx;
1921  return parse_option(o, "tag:a", arg, options);
1922 }
1923 
1924 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1925 {
1926  OptionsContext *o = optctx;
1927  return parse_option(o, "tag:s", arg, options);
1928 }
1929 
1930 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1931 {
1932  OptionsContext *o = optctx;
1933  return parse_option(o, "filter:v", arg, options);
1934 }
1935 
1936 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1937 {
1938  OptionsContext *o = optctx;
1939  return parse_option(o, "filter:a", arg, options);
1940 }
1941 
1942 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1943 {
1944  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1945  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1946  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1947 
1950  return 0;
1951 }
1952 
1953 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1954 {
1955  OptionsContext *o = optctx;
1956  char layout_str[32];
1957  char *stream_str;
1958  char *ac_str;
1959  int ret, channels, ac_str_size;
1960  uint64_t layout;
1961 
1962  layout = av_get_channel_layout(arg);
1963  if (!layout) {
1964  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1965  return AVERROR(EINVAL);
1966  }
1967  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1968  ret = opt_default(NULL, opt, layout_str);
1969  if (ret < 0)
1970  return ret;
1971 
1972  /* set 'ac' option based on channel layout */
1973  channels = av_get_channel_layout_nb_channels(layout);
1974  snprintf(layout_str, sizeof(layout_str), "%d", channels);
1975  stream_str = strchr(opt, ':');
1976  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1977  ac_str = av_mallocz(ac_str_size);
1978  if (!ac_str)
1979  return AVERROR(ENOMEM);
1980  av_strlcpy(ac_str, "ac", 3);
1981  if (stream_str)
1982  av_strlcat(ac_str, stream_str, ac_str_size);
1983  ret = parse_option(o, ac_str, layout_str, options);
1984  av_free(ac_str);
1985 
1986  return ret;
1987 }
1988 
1989 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1990 {
1991  OptionsContext *o = optctx;
1992  return parse_option(o, "q:a", arg, options);
1993 }
1994 
1995 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1996 {
1998  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1999  return AVERROR(ENOMEM);
2002  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2003  return AVERROR(ENOMEM);
2004  return 0;
2005 }
2006 
2007 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2008 {
2009  uint8_t *graph_desc = read_file(arg);
2010  if (!graph_desc)
2011  return AVERROR(EINVAL);
2012 
2014  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2015  return AVERROR(ENOMEM);
2017  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2018  return 0;
2019 }
2020 
2021 void show_help_default(const char *opt, const char *arg)
2022 {
2023  /* per-file options have at least one of those set */
2024  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2025  int show_advanced = 0, show_avoptions = 0;
2026 
2027  if (opt && *opt) {
2028  if (!strcmp(opt, "long"))
2029  show_advanced = 1;
2030  else if (!strcmp(opt, "full"))
2031  show_advanced = show_avoptions = 1;
2032  else
2033  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2034  }
2035 
2036  show_usage();
2037 
2038  printf("Getting help:\n"
2039  " -h -- print basic options\n"
2040  " -h long -- print more options\n"
2041  " -h full -- print all options (including all format and codec specific options, very long)\n"
2042  " See man %s for detailed description of the options.\n"
2043  "\n", program_name);
2044 
2045  show_help_options(options, "Print help / information / capabilities:",
2046  OPT_EXIT, 0, 0);
2047 
2048  show_help_options(options, "Global options (affect whole program "
2049  "instead of just one file:",
2050  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2051  if (show_advanced)
2052  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2053  per_file | OPT_EXIT, 0);
2054 
2055  show_help_options(options, "Per-file main options:", 0,
2057  OPT_EXIT, per_file);
2058  if (show_advanced)
2059  show_help_options(options, "Advanced per-file options:",
2060  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2061 
2062  show_help_options(options, "Video options:",
2064  if (show_advanced)
2065  show_help_options(options, "Advanced Video options:",
2067 
2068  show_help_options(options, "Audio options:",
2070  if (show_advanced)
2071  show_help_options(options, "Advanced Audio options:",
2073  show_help_options(options, "Subtitle options:",
2074  OPT_SUBTITLE, 0, 0);
2075  printf("\n");
2076 
2077  if (show_avoptions) {
2083  }
2084 }
2085 
2086 void show_usage(void)
2087 {
2088  printf("Hyper fast Audio and Video encoder\n");
2089  printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2090  printf("\n");
2091 }
2092 
2093 enum OptGroup {
2096 };
2097 
2098 static const OptionGroupDef groups[] = {
2099  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2100  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2101 };
2102 
2103 static int open_files(OptionGroupList *l, const char *inout,
2104  int (*open_file)(OptionsContext*, const char*))
2105 {
2106  int i, ret;
2107 
2108  for (i = 0; i < l->nb_groups; i++) {
2109  OptionGroup *g = &l->groups[i];
2110  OptionsContext o;
2111 
2112  init_options(&o);
2113  o.g = g;
2114 
2115  ret = parse_optgroup(&o, g);
2116  if (ret < 0) {
2117  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2118  "%s.\n", inout, g->arg);
2119  return ret;
2120  }
2121 
2122  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2123  ret = open_file(&o, g->arg);
2124  uninit_options(&o);
2125  if (ret < 0) {
2126  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2127  inout, g->arg);
2128  return ret;
2129  }
2130  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2131  }
2132 
2133  return 0;
2134 }
2135 
2136 int avconv_parse_options(int argc, char **argv)
2137 {
2139  uint8_t error[128];
2140  int ret;
2141 
2142  memset(&octx, 0, sizeof(octx));
2143 
2144  /* split the commandline into an internal representation */
2145  ret = split_commandline(&octx, argc, argv, options, groups,
2146  FF_ARRAY_ELEMS(groups));
2147  if (ret < 0) {
2148  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2149  goto fail;
2150  }
2151 
2152  /* apply global options */
2153  ret = parse_optgroup(NULL, &octx.global_opts);
2154  if (ret < 0) {
2155  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2156  goto fail;
2157  }
2158 
2159  /* open input files */
2160  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2161  if (ret < 0) {
2162  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2163  goto fail;
2164  }
2165 
2166  /* open output files */
2167  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2168  if (ret < 0) {
2169  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2170  goto fail;
2171  }
2172 
2173 fail:
2174  uninit_parse_context(&octx);
2175  if (ret < 0) {
2176  av_strerror(ret, error, sizeof(error));
2177  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2178  }
2179  return ret;
2180 }
2181 
2182 #define OFFSET(x) offsetof(OptionsContext, x)
2183 const OptionDef options[] = {
2184  /* main options */
2185 #include "cmdutils_common_opts.h"
2186  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2187  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2188  "force format", "fmt" },
2189  { "y", OPT_BOOL, { &file_overwrite },
2190  "overwrite output files" },
2191  { "n", OPT_BOOL, { &file_skip },
2192  "never overwrite output files" },
2193  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2194  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2195  "codec name", "codec" },
2196  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2197  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2198  "codec name", "codec" },
2199  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2200  OPT_OUTPUT, { .off = OFFSET(presets) },
2201  "preset name", "preset" },
2202  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2203  OPT_OUTPUT, { .func_arg = opt_map },
2204  "set input stream mapping",
2205  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2206  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2207  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2208  "set metadata information of outfile from infile",
2209  "outfile[,metadata]:infile[,metadata]" },
2210  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2211  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2212  "set chapters mapping", "input_file_index" },
2213  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2214  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2215  "record or transcode \"duration\" seconds of audio/video",
2216  "duration" },
2217  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2218  "set the limit file size in bytes", "limit_size" },
2219  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2220  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2221  "set the start time offset", "time_off" },
2222  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2223  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2224  "enable/disable accurate seeking with -ss" },
2225  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2226  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2227  "set the input ts offset", "time_off" },
2228  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2229  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2230  "set the input ts scale", "scale" },
2231  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2232  "add metadata", "string=string" },
2233  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2234  OPT_OUTPUT, { .func_arg = opt_data_frames },
2235  "set the number of data frames to record", "number" },
2236  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2237  "add timings for benchmarking" },
2238  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2239  "set max runtime in seconds", "limit" },
2240  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2241  "dump each input packet" },
2242  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2243  "when dumping packets, also dump the payload" },
2244  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2245  OPT_INPUT, { .off = OFFSET(rate_emu) },
2246  "read input at native frame rate", "" },
2247  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2248  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2249  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2250  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2251  "video sync method", "" },
2252  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2253  "audio sync method", "" },
2254  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2255  "audio drift threshold", "threshold" },
2256  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2257  "copy timestamps" },
2258  { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2259  "copy input stream time base when stream copying" },
2260  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2261  OPT_OUTPUT, { .off = OFFSET(shortest) },
2262  "finish encoding within shortest input" },
2263  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2264  "timestamp discontinuity delta threshold", "threshold" },
2265  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2266  "exit on error", "error" },
2267  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2268  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2269  "copy initial non-keyframes" },
2270  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2271  "set the number of frames to record", "number" },
2272  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2273  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2274  "force codec tag/fourcc", "fourcc/tag" },
2275  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2276  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2277  "use fixed quality scale (VBR)", "q" },
2278  { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2279  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2280  "use fixed quality scale (VBR)", "q" },
2281  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2282  "set stream filterchain", "filter_list" },
2283  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2284  "read stream filtergraph description from a file", "filename" },
2285  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2286  "create a complex filtergraph", "graph_description" },
2287  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2288  "read complex filtergraph description from a file", "filename" },
2289  { "stats", OPT_BOOL, { &print_stats },
2290  "print progress report during encoding", },
2291  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2292  OPT_OUTPUT, { .func_arg = opt_attach },
2293  "add an attachment to the output file", "filename" },
2294  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2295  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2296  "extract an attachment into a file", "filename" },
2297 
2298  /* video options */
2299  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2300  "set the number of video frames to record", "number" },
2301  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2302  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2303  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2304  { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2305  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2306  "set frame size (WxH or abbreviation)", "size" },
2307  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2308  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2309  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2310  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2311  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2312  "set pixel format", "format" },
2313  { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2314  "disable video" },
2315  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2316  "discard threshold", "n" },
2317  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2318  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2319  "rate control override for specific intervals", "override" },
2320  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2321  OPT_OUTPUT, { .func_arg = opt_video_codec },
2322  "force video codec ('copy' to copy stream)", "codec" },
2323  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2324  "select the pass number (1 or 2)", "n" },
2325  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2326  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2327  "select two pass log file name prefix", "prefix" },
2328  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2329  "dump video coding statistics to file" },
2330  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2331  "dump video coding statistics to file", "file" },
2332  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2333  "video filters", "filter list" },
2334  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2335  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2336  "specify intra matrix coeffs", "matrix" },
2337  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2338  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2339  "specify inter matrix coeffs", "matrix" },
2340  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2341  OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2342  "top=1/bottom=0/auto=-1 field first", "" },
2343  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2344  "intra_dc_precision", "precision" },
2345  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2346  OPT_OUTPUT, { .func_arg = opt_video_tag },
2347  "force video tag/fourcc", "fourcc/tag" },
2348  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2349  "show QP histogram" },
2350  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2351  OPT_OUTPUT, { .off = OFFSET(force_fps) },
2352  "force the selected framerate, disable the best supported framerate selection" },
2353  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2354  OPT_OUTPUT, { .func_arg = opt_streamid },
2355  "set the value of an outfile streamid", "streamIndex:value" },
2356  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2357  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2358  "force key frames at specified timestamps", "timestamps" },
2359  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2360  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2361  "use HW accelerated decoding", "hwaccel name" },
2362  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2363  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2364  "select a device for HW acceleration" "devicename" },
2365 
2366  /* audio options */
2367  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2368  "set the number of audio frames to record", "number" },
2369  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2370  "set audio quality (codec-specific)", "quality", },
2371  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2372  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2373  "set audio sampling rate (in Hz)", "rate" },
2374  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2375  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2376  "set number of audio channels", "channels" },
2377  { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2378  "disable audio" },
2379  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2380  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2381  "force audio codec ('copy' to copy stream)", "codec" },
2382  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2383  OPT_OUTPUT, { .func_arg = opt_audio_tag },
2384  "force audio tag/fourcc", "fourcc/tag" },
2385  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2386  "change audio volume (256=normal)" , "volume" },
2387  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2389  "set sample format", "format" },
2390  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2391  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2392  "set channel layout", "layout" },
2393  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2394  "audio filters", "filter list" },
2395 
2396  /* subtitle options */
2397  { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2398  "disable subtitle" },
2399  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2400  "force subtitle codec ('copy' to copy stream)", "codec" },
2401  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2402  , "force subtitle tag/fourcc", "fourcc/tag" },
2403 
2404  /* grab options */
2405  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2406 
2407  /* muxer options */
2408  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2409  "set the maximum demux-decode delay", "seconds" },
2410  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2411  "set the initial demux-decode delay", "seconds" },
2412 
2413  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2414  "A comma-separated list of bitstream filters", "bitstream_filters" },
2415 
2416  /* data codec support */
2417  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2418  "force data codec ('copy' to copy stream)", "codec" },
2419 
2420  { NULL, },
2421 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1119
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:778
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:364
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: avconv_opt.c:44
int nb_input_files
Definition: avconv.c:101
int nb_dump_attachment
Definition: avconv.h:111
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:1609
int nb_metadata
Definition: avconv.h:147
int nb_streamid_map
Definition: avconv.h:144
int copy_tb
Definition: avconv_opt.c:81
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:62
AVDictionary * resample_opts
Definition: cmdutils.h:260
Bytestream IO Context.
Definition: avio.h:68
float mux_preload
Definition: avconv.h:133
#define OPT_EXPERT
Definition: cmdutils.h:144
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
Definition: avconv_opt.c:881
int64_t recording_time
Definition: avconv.h:367
static AVCodec * choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
Definition: avconv_opt.c:448
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:241
int nb_input_streams
Definition: avconv.c:99
static int file_overwrite
Definition: avconv_opt.c:86
#define VSYNC_AUTO
Definition: avconv.h:46
int nb_outputs
Definition: avconv.h:214
int resample_channels
Definition: avconv.h:245
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:345
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1752
static OutputStream * new_audio_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1188
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1163
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:966
AVOption.
Definition: opt.h:234
AVRational frame_rate
Definition: avconv.h:323
int audio_channels
Definition: rtp.c:39
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:146
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:636
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1322
float mux_max_delay
Definition: avconv.h:134
int accurate_seek
Definition: avconv.h:287
int * streamid_map
Definition: avconv.h:143
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1918
Main libavfilter public API header.
int nb_stream_maps
Definition: avconv.h:119
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:247
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:69
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:635
static PrintContext octx
Definition: avprobe.c:110
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:598
AVRational framerate
Definition: avconv.h:237
static int video_discard
Definition: avconv_opt.c:88
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:179
enum AVCodecID video_codec
default video codec
Definition: avformat.h:457
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1488
#define OPT_AUDIO
Definition: cmdutils.h:147
AVFilterInOut * out_tmp
Definition: avconv.h:202
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:718
int qscale
Definition: avcodec.h:590
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:769
int num
numerator
Definition: rational.h:44
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:269
int video_sync_method
Definition: avconv_opt.c:76
int index
stream index in AVFormatContext
Definition: avformat.h:700
int nb_frame_pix_fmts
Definition: avconv.h:101
#define AVIO_FLAG_READ
read-only
Definition: avio.h:292
static int sync(AVFormatContext *s, uint8_t *header)
Read input until we find the next ident.
Definition: lxfdec.c:86
static int configure_complex_filters(void)
Definition: avconv_opt.c:1356
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:293
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:1423
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1953
int audio_sync_method
Definition: avconv_opt.c:75
AVBitStreamFilterContext * bitstream_filters
Definition: avconv.h:316
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1248
external API header
const char * arg
Definition: cmdutils.h:253
static int using_stdin
Definition: avconv_opt.c:90
float audio_drift_threshold
Definition: avconv_opt.c:71
int do_pkt_dump
Definition: avconv_opt.c:79
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1876
#define OPT_DATA
Definition: cmdutils.h:153
FilterGraph ** filtergraphs
Definition: avconv.c:108
enum AVMediaType type
Definition: avcodec.h:2803
#define FF_ARRAY_ELEMS(a)
discard all
Definition: avcodec.h:568
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1930
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:71
const char * name
Definition: avconv.h:60
AVDictionary * metadata
Definition: avformat.h:909
#define OPT_DOUBLE
Definition: cmdutils.h:161
#define OPT_FLOAT
Definition: cmdutils.h:149
AVCodec.
Definition: avcodec.h:2790
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:954
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
Definition: options.c:154
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:1571
int64_t start_time
Definition: avconv.h:368
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1243
int index
Definition: avconv.h:206
static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: avconv_opt.c:864
SpecifierOpt * frame_pix_fmts
Definition: avconv.h:100
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1169
static AVInputFormat * file_iformat
Definition: avplay.c:227
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:198
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:572
Format I/O context.
Definition: avformat.h:922
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:217
int do_hex_dump
Definition: avconv_opt.c:78
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:318
enum HWAccelID id
Definition: avconv.h:62
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
char * logfile_prefix
Definition: avconv.h:335
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1036
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:577
int copy_initial_nonkeyframes
Definition: avconv.h:347
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1793
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:465
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:189
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:433
#define OPT_OUTPUT
Definition: cmdutils.h:163
AVOptions.
#define HAS_ARG
Definition: cmdutils.h:142
InputFile ** input_files
Definition: avconv.c:100
AVDictionary * opts
Definition: avconv.h:365
#define CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:657
#define VSYNC_PASSTHROUGH
Definition: avconv.h:47
int id
unique ID to identify the chapter
Definition: avformat.h:906
int id
Format-specific stream ID.
Definition: avformat.h:706
int copy_ts
Definition: avconv_opt.c:80
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
Definition: avconv_opt.c:463
#define OPT_OFFSET
Definition: cmdutils.h:156
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1158
const char * name
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2497
int shortest
Definition: avconv.h:371
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:990
double strtod(const char *, char **)
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:98
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:550
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:38
int nb_streams
Definition: avconv.h:284
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1033
static int audio_disable
Definition: avplay.c:234
int sync_file_index
Definition: avconv.h:71
static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1924
AVDictionary * resample_opts
Definition: avconv.h:343
static int flags
Definition: log.c:44
uint32_t tag
Definition: movenc.c:844
#define OPT_SPEC
Definition: cmdutils.h:157
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:139
int resample_sample_rate
Definition: avconv.h:244
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:114
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:135
AVCodec * dec
Definition: avconv.h:223
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:165
int file_index
Definition: avconv.h:218
void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:184
struct AVBitStreamFilterContext * next
Definition: avcodec.h:4286
int resample_pix_fmt
Definition: avconv.h:241
int resample_height
Definition: avconv.h:239
static int opt_video_tag(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1912
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:264
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:452
float quality_factor
Definition: avcodec.h:591
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:941
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1627
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: utils.c:1757
OptGroup
Definition: avconv_opt.c:2093
int configure_filtergraph(FilterGraph *fg)
#define OPT_SUBTITLE
Definition: cmdutils.h:150
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:129
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)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:345
static char * get_ost_filters(OptionsContext *o, AVFormatContext *oc, OutputStream *ost)
Definition: avconv_opt.c:1043
enum AVCodecID id
Definition: avcodec.h:2804
void show_help_default(const char *opt, const char *arg)
Per-avtool specific help handler.
Definition: avconv_opt.c:2021
static int64_t start_time
Definition: avplay.c:245
int rate_emu
Definition: avconv.h:286
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1130
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
enum AVPixelFormat hwaccel_pix_fmt
Definition: avconv.h:263
int64_t start_time
Definition: avconv.h:87
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: avconv.h:315
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1995
sample_fmts
Definition: avconv_filter.c:68
int qp_hist
Definition: avconv_opt.c:84
int64_t sws_flags
Definition: avconv.h:341
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:800
g
Definition: yuv2rgb.c:535
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:170
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:1138
const char * name
Definition: cmdutils.h:140
static void dump_attachment(AVStream *st, const char *filename)
Definition: avconv_opt.c:609
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:300
AVChapter ** chapters
Definition: avformat.h:1120
Definition: graph2dot.c:49
int finished
Definition: avconv.h:344
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:611
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:168
const char * name
Name of the codec implementation.
Definition: avcodec.h:2797
int video_disable
Definition: avconv.h:137
HW acceleration through VDA, data[3] contains a CVPixelBufferRef.
Definition: pixfmt.h:204
#define VSYNC_VFR
Definition: avconv.h:49
int flags
Definition: cmdutils.h:141
int force_fps
Definition: avconv.h:324
static int file_skip
Definition: avconv_opt.c:87
float dts_delta_threshold
Definition: avconv_opt.c:72
#define FFMAX(a, b)
Definition: common.h:55
StreamMap * stream_maps
Definition: avconv.h:118
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:81
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:121
uint64_t limit_filesize
Definition: avconv.h:132
const char * format
Definition: avconv.h:88
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:312
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1846
int nb_output_streams
Definition: avconv.c:104
#define pass
Definition: fft_template.c:335
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:443
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:718
OutputFilter * filter
Definition: avconv.h:338
int intra_dc_precision
precision of the intra DC coefficient - 8
Definition: avcodec.h:1630
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:698
int file_index
Definition: avconv.h:69
MetadataMap(* meta_data_maps)[2]
Definition: avconv.h:121
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:307
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:978
int nb_attachments
Definition: avconv.h:127
int nb_filtergraphs
Definition: avconv.c:109
static AVDictionary * strip_specifiers(AVDictionary *dict)
Definition: avconv_opt.c:137
OptionGroup * groups
Definition: cmdutils.h:271
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:162
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2106
size_t off
Definition: cmdutils.h:167
char * linklabel
Definition: avconv.h:73
int void avio_flush(AVIOContext *s)
Definition: aviobuf.c:180
audio channel layout utility functions
const AVIOInterruptCB int_cb
Definition: avconv.c:141
char filename[1024]
input or output filename
Definition: avformat.h:998
const HWAccel hwaccels[]
Definition: avconv_opt.c:56
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:234
#define FFMIN(a, b)
Definition: common.h:57
SpecifierOpt * audio_channels
Definition: avconv.h:92
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
Definition: avconv_opt.c:838
int av_strcasecmp(const char *a, const char *b)
Definition: avstring.c:156
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: avconv_opt.c:339
int nb_audio_sample_rate
Definition: avconv.h:95
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:124
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:383
int metadata_chapters_manual
Definition: avconv.h:125
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: format.c:139
struct OutputStream * ost
Definition: avconv.h:197
int accurate_seek
Definition: avconv.h:106
int width
picture width / height.
Definition: avcodec.h:1218
AVBitStreamFilterContext * av_bitstream_filter_init(const char *name)
static int intra_dc_precision
Definition: avconv_opt.c:89
SpecifierOpt * audio_sample_rate
Definition: avconv.h:94
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:415
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:196
static int open_output_file(OptionsContext *o, const char *filename)
Definition: avconv_opt.c:1367
SpecifierOpt * dump_attachment
Definition: avconv.h:110
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:268
#define OPT_EXIT
Definition: cmdutils.h:152
int start_frame
Definition: avcodec.h:588
SpecifierOpt * metadata_map
Definition: avconv.h:172
union SpecifierOpt::@1 u
#define OPT_INT64
Definition: cmdutils.h:151
int64_t max_frames
Definition: avconv.h:319
#define AV_RL32
Definition: intreadwrite.h:146
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:129
int do_benchmark
Definition: avconv_opt.c:77
AVDictionary * metadata
Definition: avformat.h:771
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: format.c:104
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1883
static const OptionGroupDef groups[]
Definition: avconv_opt.c:2098
const OptionDef options[]
Definition: avconv_opt.c:2183
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:186
Opaque data information usually sparse.
Definition: avutil.h:191
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:745
SpecifierOpt * frame_sizes
Definition: avconv.h:98
option
Definition: ffv1enc.c:1079
#define VSYNC_CFR
Definition: avconv.h:48
int vdpau_init(AVCodecContext *s)
Definition: avconv_vdpau.c:294
static OutputStream * new_video_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1067
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:2372
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
Definition: avconv_opt.c:997
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:1096
RcOverride * rc_override
Definition: avcodec.h:2107
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:94
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1936
if(ac->has_optimized_func)
uint8_t * str
Definition: cmdutils.h:131
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:178
Stream structure.
Definition: avformat.h:699
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:793
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1091
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:908
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:391
int64_t recording_time
Definition: avconv.h:283
Definition: avconv.h:59
NULL
Definition: eval.c:55
SpecifierOpt * frame_rates
Definition: avconv.h:96
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
sample_fmt
Definition: avconv_filter.c:68
int ost_index
Definition: avconv.h:366
struct InputStream * sync_ist
Definition: avconv.h:309
OutputFile ** output_files
Definition: avconv.c:105
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1052
double ts_scale
Definition: avconv.h:234
int64_t recording_time
Definition: avconv.h:131
int chapters_input_file
Definition: avconv.h:129
enum AVCodecID codec_id
Definition: avcodec.h:1061
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:240
static AVCodec * find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
Definition: avconv_opt.c:419
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:213
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
int sample_rate
samples per second
Definition: avcodec.h:1785
AVIOContext * pb
I/O context.
Definition: avformat.h:964
OutputStream ** output_streams
Definition: avconv.c:103
int ist_index
Definition: avconv.h:280
static double parse_frame_aspect_ratio(const char *arg)
Definition: avconv_opt.c:154
const char * graph_desc
Definition: avconv.h:207
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1906
int64_t start_time
Definition: avconv.h:282
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:144
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:270
main external API structure.
Definition: avcodec.h:1044
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1771
int rate_emu
Definition: avconv.h:105
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:134
int metadata_streams_manual
Definition: avconv.h:124
const char * attachment_filename
Definition: avconv.h:346
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1076
a very simple circular buffer FIFO implementation
AVCodecContext * enc_ctx
Definition: avconv.h:317
int audio_disable
Definition: avconv.h:138
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1942
int64_t input_ts_offset
Definition: avconv.h:104
#define AVCONV_DATADIR
Definition: config.h:6
int extradata_size
Definition: avcodec.h:1159
static void uninit_options(OptionsContext *o)
Definition: avconv_opt.c:93
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:68
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:1585
AVCodecContext * dec_ctx
Definition: avconv.h:222
AVStream * st
Definition: avconv.h:219
static int open_input_file(OptionsContext *o, const char *filename)
Definition: avconv_opt.c:641
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1894
Describe the class of an AVClass context structure.
Definition: log.h:33
#define NTSC
Definition: bktr.c:68
int index
Definition: gxfenc.c:72
char * vstats_filename
Definition: avconv_opt.c:69
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:1099
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:458
const char program_name[]
program name, defined by the program for show_version().
Definition: avconv.c:82
int file_index
Definition: avconv.h:300
int metadata_global_manual
Definition: avconv.h:123
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:190
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:190
int avconv_parse_options(int argc, char **argv)
Definition: avconv_opt.c:2136
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:265
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:1647
#define OPT_STRING
Definition: cmdutils.h:145
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: avconv_opt.c:1279
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
AVMediaType
Definition: avutil.h:185
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:783
AVDictionary * decoder_opts
Definition: avconv.h:236
int shortest
Definition: avconv.h:135
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:486
int64_t ts_offset
Definition: avconv.h:281
misc parsing utilities
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:138
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:91
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:1592
int end_frame
Definition: avcodec.h:589
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:478
int print_stats
Definition: avconv_opt.c:83
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:102
char * name
unique name for this input/output in the list
Definition: avfilter.h:1093
int nb_audio_channels
Definition: avconv.h:93
#define OPT_TIME
Definition: cmdutils.h:160
int source_index
Definition: avconv.h:302
SpecifierOpt * metadata
Definition: avconv.h:146
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1124
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: utils.c:1776
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1007
void show_usage(void)
Definition: avconv_opt.c:2086
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:1510
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:243
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:202
int64_t start
Definition: avformat.h:908
char * forced_keyframes
Definition: avconv.h:333
int nb_frame_rates
Definition: avconv.h:97
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
#define OPT_BOOL
Definition: cmdutils.h:143
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:240
int guess_input_channel_layout(InputStream *ist)
Definition: avconv.c:1134
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:2007
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:758
struct FilterGraph * graph
Definition: avconv.h:198
uint64_t limit_filesize
Definition: avconv.h:369
#define OPT_INT
Definition: cmdutils.h:148
AVDictionary * format_opts
Definition: cmdutils.h:259
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:409
int nb_frame_sizes
Definition: avconv.h:99
OptionGroupList * groups
Definition: cmdutils.h:278
OptionGroup * g
Definition: avconv.h:84
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:117
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:297
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:2031
InputStream ** input_streams
Definition: avconv.c:98
static uint8_t * read_file(const char *filename)
Definition: avconv_opt.c:1015
AVStream * st
Definition: avconv.h:303
OptionGroup global_opts
Definition: cmdutils.h:276
int audio_volume
Definition: avconv_opt.c:74
int vda_init(AVCodecContext *s)
Definition: avconv_vda.c:103
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1257
const char ** attachments
Definition: avconv.h:126
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required po...
Definition: opt.h:392
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:907
char * key
Definition: dict.h:75
int den
denominator
Definition: rational.h:45
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1989
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:2475
AVFormatContext * ctx
Definition: avconv.h:277
union OptionDef::@2 u
int stream_index
Definition: avconv.h:70
AVCodec * enc
Definition: avconv.h:318
int nb_metadata_map
Definition: avconv.h:173
static uint8_t * get_line(AVIOContext *s)
Definition: avconv_opt.c:819
enum AVCodecID id
Definition: avcodec.h:479
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:537
pixel format definitions
char * avfilter
Definition: avconv.h:339
char * value
Definition: dict.h:76
int eof_reached
true if eof reached
Definition: avio.h:96
#define OFFSET(x)
Definition: avconv_opt.c:2182
int len
int channels
number of audio channels
Definition: avcodec.h:1786
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:456
int top_field_first
Definition: avconv.h:325
OutputFilter ** outputs
Definition: avconv.h:213
static int input_sync
Definition: avconv_opt.c:91
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:68
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:207
#define PAL
Definition: bktr.c:66
AVFormatContext * ctx
Definition: avconv.h:364
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:164
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1900
uint64_t layout
int nb_output_files
Definition: avconv.c:106
char * hwaccel_device
Definition: avconv.h:255
AVDictionary * encoder_opts
Definition: avconv.h:342
AVDictionary * codec_opts
Definition: cmdutils.h:258
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1017
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0...
Definition: cmdutils.c:1379
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:184
float frame_aspect_ratio
Definition: avconv.h:327
int sync_stream_index
Definition: avconv.h:72
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:117
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: avconv_opt.c:2103
int exit_on_error
Definition: avconv_opt.c:82
#define SET_DICT(type, meta, context, index)
int dxva2_init(AVCodecContext *s)
Definition: avconv_dxva2.c:589
static OutputStream * new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1235
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:1552
int discard
Definition: avconv.h:220
#define OPT_PERFILE
Definition: cmdutils.h:154
enum AVPixelFormat pix_fmts[2]
Definition: avconv.h:349
#define OPT_INPUT
Definition: cmdutils.h:162
enum HWAccelID hwaccel_id
Definition: avconv.h:254
static OutputStream * new_data_stream(OptionsContext *o, AVFormatContext *oc)
Definition: avconv_opt.c:1222
static int video_disable
Definition: avplay.c:235
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:762
int index
Definition: avconv.h:301
void assert_avoptions(AVDictionary *m)
Definition: avconv.c:236
struct SwsContext * sws_opts
Definition: cmdutils.h:261
uint64_t resample_channel_layout
Definition: avconv.h:246
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:814
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:205
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: avconv_opt.c:1738
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:228
static void assert_file_overwrite(const char *filename)
Definition: avconv_opt.c:582
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:410
discard nothing
Definition: avcodec.h:563
int subtitle_disable
Definition: avconv.h:139
#define NEW_STREAM(type, index)
static void init_options(OptionsContext *o)
Definition: avconv_opt.c:124