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