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