FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "ffmpeg.h"
24 #include "cmdutils.h"
25 
26 #include "libavformat/avformat.h"
27 
28 #include "libavcodec/avcodec.h"
29 
30 #include "libavfilter/avfilter.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
45 
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 {\
48  int i, ret;\
49  for (i = 0; i < o->nb_ ## name; i++) {\
50  char *spec = o->name[i].specifier;\
51  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52  outvar = o->name[i].u.type;\
53  else if (ret < 0)\
54  exit_program(1);\
55  }\
56 }
57 
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 {\
60  int i;\
61  for (i = 0; i < o->nb_ ## name; i++) {\
62  char *spec = o->name[i].specifier;\
63  if (!strcmp(spec, mediatype))\
64  outvar = o->name[i].u.type;\
65  }\
66 }
67 
68 const HWAccel hwaccels[] = {
69 #if HAVE_VDPAU_X11
72 #endif
73 #if CONFIG_D3D11VA
76 #endif
77 #if CONFIG_DXVA2
80 #endif
81 #if CONFIG_VDA
84 #endif
85 #if CONFIG_VIDEOTOOLBOX
88 #endif
89 #if CONFIG_LIBMFX
92 #endif
93 #if CONFIG_VAAPI
96 #endif
97 #if CONFIG_CUVID
100 #endif
101  { 0 },
102 };
106 
109 
112 float dts_error_threshold = 3600*30;
113 
114 int audio_volume = 256;
119 int do_benchmark = 0;
121 int do_hex_dump = 0;
122 int do_pkt_dump = 0;
123 int copy_ts = 0;
125 int copy_tb = -1;
126 int debug_ts = 0;
129 int print_stats = -1;
130 int qp_hist = 0;
133 float max_error_rate = 2.0/3;
137 
138 
139 static int intra_only = 0;
140 static int file_overwrite = 0;
141 static int no_file_overwrite = 0;
142 static int do_psnr = 0;
143 static int input_sync;
144 static int override_ffserver = 0;
146 static int ignore_unknown_streams = 0;
147 static int copy_unknown_streams = 0;
148 static int find_stream_info = 1;
149 
151 {
152  const OptionDef *po = options;
153  int i;
154 
155  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
156  while (po->name) {
157  void *dst = (uint8_t*)o + po->u.off;
158 
159  if (po->flags & OPT_SPEC) {
160  SpecifierOpt **so = dst;
161  int i, *count = (int*)(so + 1);
162  for (i = 0; i < *count; i++) {
163  av_freep(&(*so)[i].specifier);
164  if (po->flags & OPT_STRING)
165  av_freep(&(*so)[i].u.str);
166  }
167  av_freep(so);
168  *count = 0;
169  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
170  av_freep(dst);
171  po++;
172  }
173 
174  for (i = 0; i < o->nb_stream_maps; i++)
176  av_freep(&o->stream_maps);
178  av_freep(&o->streamid_map);
179  av_freep(&o->attachments);
180 }
181 
183 {
184  memset(o, 0, sizeof(*o));
185 
186  o->stop_time = INT64_MAX;
187  o->mux_max_delay = 0.7;
190  o->recording_time = INT64_MAX;
191  o->limit_filesize = UINT64_MAX;
192  o->chapters_input_file = INT_MAX;
193  o->accurate_seek = 1;
194 }
195 
196 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
197 {
198  int i;
199 
200  printf("Hardware acceleration methods:\n");
201  for (i = 0; hwaccels[i].name; i++) {
202  printf("%s\n", hwaccels[i].name);
203  }
204  printf("\n");
205  return 0;
206 }
207 
208 /* return a copy of the input with the stream specifiers removed from the keys */
210 {
211  AVDictionaryEntry *e = NULL;
212  AVDictionary *ret = NULL;
213 
214  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
215  char *p = strchr(e->key, ':');
216 
217  if (p)
218  *p = 0;
219  av_dict_set(&ret, e->key, e->value, 0);
220  if (p)
221  *p = ':';
222  }
223  return ret;
224 }
225 
226 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
227 {
228  static const AVOption opts[] = {
229  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
230  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
231  { NULL },
232  };
233  static const AVClass class = {
234  .class_name = "",
235  .item_name = av_default_item_name,
236  .option = opts,
237  .version = LIBAVUTIL_VERSION_INT,
238  };
239  const AVClass *pclass = &class;
240 
241  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
242 }
243 
244 static int opt_sameq(void *optctx, const char *opt, const char *arg)
245 {
246  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
247  "If you are looking for an option to preserve the quality (which is not "
248  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
249  opt, opt);
250  return AVERROR(EINVAL);
251 }
252 
253 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
254 {
255  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
256  return opt_default(optctx, "channel", arg);
257 }
258 
259 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
260 {
261  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
262  return opt_default(optctx, "standard", arg);
263 }
264 
265 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
266 {
267  OptionsContext *o = optctx;
268  return parse_option(o, "codec:a", arg, options);
269 }
270 
271 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
272 {
273  OptionsContext *o = optctx;
274  return parse_option(o, "codec:v", arg, options);
275 }
276 
277 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
278 {
279  OptionsContext *o = optctx;
280  return parse_option(o, "codec:s", arg, options);
281 }
282 
283 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
284 {
285  OptionsContext *o = optctx;
286  return parse_option(o, "codec:d", arg, options);
287 }
288 
289 static int opt_map(void *optctx, const char *opt, const char *arg)
290 {
291  OptionsContext *o = optctx;
292  StreamMap *m = NULL;
293  int i, negative = 0, file_idx;
294  int sync_file_idx = -1, sync_stream_idx = 0;
295  char *p, *sync;
296  char *map;
297  char *allow_unused;
298 
299  if (*arg == '-') {
300  negative = 1;
301  arg++;
302  }
303  map = av_strdup(arg);
304  if (!map)
305  return AVERROR(ENOMEM);
306 
307  /* parse sync stream first, just pick first matching stream */
308  if (sync = strchr(map, ',')) {
309  *sync = 0;
310  sync_file_idx = strtol(sync + 1, &sync, 0);
311  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
312  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
313  exit_program(1);
314  }
315  if (*sync)
316  sync++;
317  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
318  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
319  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
320  sync_stream_idx = i;
321  break;
322  }
323  if (i == input_files[sync_file_idx]->nb_streams) {
324  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
325  "match any streams.\n", arg);
326  exit_program(1);
327  }
328  }
329 
330 
331  if (map[0] == '[') {
332  /* this mapping refers to lavfi output */
333  const char *c = map + 1;
335  m = &o->stream_maps[o->nb_stream_maps - 1];
336  m->linklabel = av_get_token(&c, "]");
337  if (!m->linklabel) {
338  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
339  exit_program(1);
340  }
341  } else {
342  if (allow_unused = strchr(map, '?'))
343  *allow_unused = 0;
344  file_idx = strtol(map, &p, 0);
345  if (file_idx >= nb_input_files || file_idx < 0) {
346  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
347  exit_program(1);
348  }
349  if (negative)
350  /* disable some already defined maps */
351  for (i = 0; i < o->nb_stream_maps; i++) {
352  m = &o->stream_maps[i];
353  if (file_idx == m->file_index &&
356  *p == ':' ? p + 1 : p) > 0)
357  m->disabled = 1;
358  }
359  else
360  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
361  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
362  *p == ':' ? p + 1 : p) <= 0)
363  continue;
365  m = &o->stream_maps[o->nb_stream_maps - 1];
366 
367  m->file_index = file_idx;
368  m->stream_index = i;
369 
370  if (sync_file_idx >= 0) {
371  m->sync_file_index = sync_file_idx;
372  m->sync_stream_index = sync_stream_idx;
373  } else {
374  m->sync_file_index = file_idx;
375  m->sync_stream_index = i;
376  }
377  }
378  }
379 
380  if (!m) {
381  if (allow_unused) {
382  av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
383  } else {
384  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
385  "To ignore this, add a trailing '?' to the map.\n", arg);
386  exit_program(1);
387  }
388  }
389 
390  av_freep(&map);
391  return 0;
392 }
393 
394 static int opt_attach(void *optctx, const char *opt, const char *arg)
395 {
396  OptionsContext *o = optctx;
398  o->attachments[o->nb_attachments - 1] = arg;
399  return 0;
400 }
401 
402 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
403 {
404  OptionsContext *o = optctx;
405  int n;
406  AVStream *st;
407  AudioChannelMap *m;
408  char *allow_unused;
409  char *mapchan;
410  mapchan = av_strdup(arg);
411  if (!mapchan)
412  return AVERROR(ENOMEM);
413 
416 
417  /* muted channel syntax */
418  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
419  if ((n == 1 || n == 3) && m->channel_idx == -1) {
420  m->file_idx = m->stream_idx = -1;
421  if (n == 1)
422  m->ofile_idx = m->ostream_idx = -1;
423  av_free(mapchan);
424  return 0;
425  }
426 
427  /* normal syntax */
428  n = sscanf(arg, "%d.%d.%d:%d.%d",
429  &m->file_idx, &m->stream_idx, &m->channel_idx,
430  &m->ofile_idx, &m->ostream_idx);
431 
432  if (n != 3 && n != 5) {
433  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
434  "[file.stream.channel|-1][:syncfile:syncstream]\n");
435  exit_program(1);
436  }
437 
438  if (n != 5) // only file.stream.channel specified
439  m->ofile_idx = m->ostream_idx = -1;
440 
441  /* check input */
442  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
443  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
444  m->file_idx);
445  exit_program(1);
446  }
447  if (m->stream_idx < 0 ||
449  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
450  m->file_idx, m->stream_idx);
451  exit_program(1);
452  }
453  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
454  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
455  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
456  m->file_idx, m->stream_idx);
457  exit_program(1);
458  }
459  /* allow trailing ? to map_channel */
460  if (allow_unused = strchr(mapchan, '?'))
461  *allow_unused = 0;
462  if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
463  if (allow_unused) {
464  av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
465  m->file_idx, m->stream_idx, m->channel_idx);
466  } else {
467  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
468  "To ignore this, add a trailing '?' to the map_channel.\n",
469  m->file_idx, m->stream_idx, m->channel_idx);
470  exit_program(1);
471  }
472 
473  }
474  av_free(mapchan);
475  return 0;
476 }
477 
478 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
479 {
481  sdp_filename = av_strdup(arg);
482  return 0;
483 }
484 
485 #if CONFIG_VAAPI
486 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
487 {
488  HWDevice *dev;
489  const char *prefix = "vaapi:";
490  char *tmp;
491  int err;
492  tmp = av_asprintf("%s%s", prefix, arg);
493  if (!tmp)
494  return AVERROR(ENOMEM);
495  err = hw_device_init_from_string(tmp, &dev);
496  av_free(tmp);
497  if (err < 0)
498  return err;
499  hw_device_ctx = av_buffer_ref(dev->device_ref);
500  if (!hw_device_ctx)
501  return AVERROR(ENOMEM);
502  return 0;
503 }
504 #endif
505 
506 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
507 {
508  if (!strcmp(arg, "list")) {
510  printf("Supported hardware device types:\n");
511  while ((type = av_hwdevice_iterate_types(type)) !=
513  printf("%s\n", av_hwdevice_get_type_name(type));
514  printf("\n");
515  exit_program(0);
516  } else {
517  return hw_device_init_from_string(arg, NULL);
518  }
519 }
520 
521 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
522 {
523  if (filter_hw_device) {
524  av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
525  return AVERROR(EINVAL);
526  }
527  filter_hw_device = hw_device_get_by_name(arg);
528  if (!filter_hw_device) {
529  av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
530  return AVERROR(EINVAL);
531  }
532  return 0;
533 }
534 
535 /**
536  * Parse a metadata specifier passed as 'arg' parameter.
537  * @param arg metadata string to parse
538  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
539  * @param index for type c/p, chapter/program index is written here
540  * @param stream_spec for type s, the stream specifier is written here
541  */
542 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
543 {
544  if (*arg) {
545  *type = *arg;
546  switch (*arg) {
547  case 'g':
548  break;
549  case 's':
550  if (*(++arg) && *arg != ':') {
551  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
552  exit_program(1);
553  }
554  *stream_spec = *arg == ':' ? arg + 1 : "";
555  break;
556  case 'c':
557  case 'p':
558  if (*(++arg) == ':')
559  *index = strtol(++arg, NULL, 0);
560  break;
561  default:
562  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
563  exit_program(1);
564  }
565  } else
566  *type = 'g';
567 }
568 
569 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
570 {
571  AVDictionary **meta_in = NULL;
572  AVDictionary **meta_out = NULL;
573  int i, ret = 0;
574  char type_in, type_out;
575  const char *istream_spec = NULL, *ostream_spec = NULL;
576  int idx_in = 0, idx_out = 0;
577 
578  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
579  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
580 
581  if (!ic) {
582  if (type_out == 'g' || !*outspec)
583  o->metadata_global_manual = 1;
584  if (type_out == 's' || !*outspec)
586  if (type_out == 'c' || !*outspec)
588  return 0;
589  }
590 
591  if (type_in == 'g' || type_out == 'g')
592  o->metadata_global_manual = 1;
593  if (type_in == 's' || type_out == 's')
595  if (type_in == 'c' || type_out == 'c')
597 
598  /* ic is NULL when just disabling automatic mappings */
599  if (!ic)
600  return 0;
601 
602 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
603  if ((index) < 0 || (index) >= (nb_elems)) {\
604  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
605  (desc), (index));\
606  exit_program(1);\
607  }
608 
609 #define SET_DICT(type, meta, context, index)\
610  switch (type) {\
611  case 'g':\
612  meta = &context->metadata;\
613  break;\
614  case 'c':\
615  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
616  meta = &context->chapters[index]->metadata;\
617  break;\
618  case 'p':\
619  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
620  meta = &context->programs[index]->metadata;\
621  break;\
622  case 's':\
623  break; /* handled separately below */ \
624  default: av_assert0(0);\
625  }\
626 
627  SET_DICT(type_in, meta_in, ic, idx_in);
628  SET_DICT(type_out, meta_out, oc, idx_out);
629 
630  /* for input streams choose first matching stream */
631  if (type_in == 's') {
632  for (i = 0; i < ic->nb_streams; i++) {
633  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
634  meta_in = &ic->streams[i]->metadata;
635  break;
636  } else if (ret < 0)
637  exit_program(1);
638  }
639  if (!meta_in) {
640  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
641  exit_program(1);
642  }
643  }
644 
645  if (type_out == 's') {
646  for (i = 0; i < oc->nb_streams; i++) {
647  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
648  meta_out = &oc->streams[i]->metadata;
649  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
650  } else if (ret < 0)
651  exit_program(1);
652  }
653  } else
654  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
655 
656  return 0;
657 }
658 
659 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
660 {
661  OptionsContext *o = optctx;
662  char buf[128];
663  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
664  struct tm time = *gmtime((time_t*)&recording_timestamp);
665  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
666  return -1;
667  parse_option(o, "metadata", buf, options);
668 
669  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
670  "tag instead.\n", opt);
671  return 0;
672 }
673 
674 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
675 {
676  const AVCodecDescriptor *desc;
677  const char *codec_string = encoder ? "encoder" : "decoder";
678  AVCodec *codec;
679 
680  codec = encoder ?
683 
684  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
685  codec = encoder ? avcodec_find_encoder(desc->id) :
686  avcodec_find_decoder(desc->id);
687  if (codec)
688  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
689  codec_string, codec->name, desc->name);
690  }
691 
692  if (!codec) {
693  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
694  exit_program(1);
695  }
696  if (codec->type != type) {
697  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
698  exit_program(1);
699  }
700  return codec;
701 }
702 
704 {
705  char *codec_name = NULL;
706 
707  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
708  if (codec_name) {
709  AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
710  st->codecpar->codec_id = codec->id;
711  return codec;
712  } else
714 }
715 
716 /* Add all the streams from the given input file to the global
717  * list of input streams. */
719 {
720  int i, ret;
721 
722  for (i = 0; i < ic->nb_streams; i++) {
723  AVStream *st = ic->streams[i];
724  AVCodecParameters *par = st->codecpar;
725  InputStream *ist = av_mallocz(sizeof(*ist));
726  char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
727  char *hwaccel_output_format = NULL;
728  char *codec_tag = NULL;
729  char *next;
730  char *discard_str = NULL;
731  const AVClass *cc = avcodec_get_class();
732  const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
733 
734  if (!ist)
735  exit_program(1);
736 
738  input_streams[nb_input_streams - 1] = ist;
739 
740  ist->st = st;
741  ist->file_index = nb_input_files;
742  ist->discard = 1;
743  st->discard = AVDISCARD_ALL;
744  ist->nb_samples = 0;
745  ist->min_pts = INT64_MAX;
746  ist->max_pts = INT64_MIN;
747 
748  ist->ts_scale = 1.0;
749  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
750 
751  ist->autorotate = 1;
752  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
753 
754  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
755  if (codec_tag) {
756  uint32_t tag = strtol(codec_tag, &next, 0);
757  if (*next)
758  tag = AV_RL32(codec_tag);
759  st->codecpar->codec_tag = tag;
760  }
761 
762  ist->dec = choose_decoder(o, ic, st);
763  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
764 
765  ist->reinit_filters = -1;
766  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
767 
768  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
770  if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
771  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
772  discard_str);
773  exit_program(1);
774  }
775 
777 
778  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
779  if (!ist->dec_ctx) {
780  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
781  exit_program(1);
782  }
783 
784  ret = avcodec_parameters_to_context(ist->dec_ctx, par);
785  if (ret < 0) {
786  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
787  exit_program(1);
788  }
789 
790  switch (par->codec_type) {
791  case AVMEDIA_TYPE_VIDEO:
792  if(!ist->dec)
793  ist->dec = avcodec_find_decoder(par->codec_id);
794 #if FF_API_LOWRES
795  if (av_codec_get_lowres(st->codec)) {
797  ist->dec_ctx->width = st->codec->width;
798  ist->dec_ctx->height = st->codec->height;
799  ist->dec_ctx->coded_width = st->codec->coded_width;
800  ist->dec_ctx->coded_height = st->codec->coded_height;
801 #if FF_API_EMU_EDGE
803 #endif
804  }
805 #endif
806 
807  // avformat_find_stream_info() doesn't set this for us anymore.
808  ist->dec_ctx->framerate = st->avg_frame_rate;
809 
810  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
811  if (framerate && av_parse_video_rate(&ist->framerate,
812  framerate) < 0) {
813  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
814  framerate);
815  exit_program(1);
816  }
817 
818  ist->top_field_first = -1;
819  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
820 
821  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
822  if (hwaccel) {
823  if (!strcmp(hwaccel, "none"))
824  ist->hwaccel_id = HWACCEL_NONE;
825  else if (!strcmp(hwaccel, "auto"))
826  ist->hwaccel_id = HWACCEL_AUTO;
827  else {
828  int i;
829  for (i = 0; hwaccels[i].name; i++) {
830  if (!strcmp(hwaccels[i].name, hwaccel)) {
831  ist->hwaccel_id = hwaccels[i].id;
832  break;
833  }
834  }
835 
836  if (!ist->hwaccel_id) {
837  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
838  hwaccel);
839  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
840  for (i = 0; hwaccels[i].name; i++)
841  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
842  av_log(NULL, AV_LOG_FATAL, "\n");
843  exit_program(1);
844  }
845  }
846  }
847 
848  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
849  if (hwaccel_device) {
850  ist->hwaccel_device = av_strdup(hwaccel_device);
851  if (!ist->hwaccel_device)
852  exit_program(1);
853  }
854 
855  MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
856  hwaccel_output_format, ic, st);
857  if (hwaccel_output_format) {
858  ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
860  av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
861  "format: %s", hwaccel_output_format);
862  }
863  } else {
865  }
866 
868 
869  break;
870  case AVMEDIA_TYPE_AUDIO:
871  ist->guess_layout_max = INT_MAX;
872  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
874  break;
875  case AVMEDIA_TYPE_DATA:
876  case AVMEDIA_TYPE_SUBTITLE: {
877  char *canvas_size = NULL;
878  if(!ist->dec)
879  ist->dec = avcodec_find_decoder(par->codec_id);
880  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
881  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
882  if (canvas_size &&
883  av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
884  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
885  exit_program(1);
886  }
887  break;
888  }
891  break;
892  default:
893  abort();
894  }
895 
896  ret = avcodec_parameters_from_context(par, ist->dec_ctx);
897  if (ret < 0) {
898  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
899  exit_program(1);
900  }
901  }
902 }
903 
904 static void assert_file_overwrite(const char *filename)
905 {
907  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
908  exit_program(1);
909  }
910 
911  if (!file_overwrite) {
912  const char *proto_name = avio_find_protocol_name(filename);
913  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
915  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
916  fflush(stderr);
917  term_exit();
918  signal(SIGINT, SIG_DFL);
919  if (!read_yesno()) {
920  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
921  exit_program(1);
922  }
923  term_init();
924  }
925  else {
926  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
927  exit_program(1);
928  }
929  }
930  }
931 }
932 
933 static void dump_attachment(AVStream *st, const char *filename)
934 {
935  int ret;
936  AVIOContext *out = NULL;
938 
939  if (!st->codecpar->extradata_size) {
940  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
941  nb_input_files - 1, st->index);
942  return;
943  }
944  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
945  filename = e->value;
946  if (!*filename) {
947  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
948  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
949  exit_program(1);
950  }
951 
952  assert_file_overwrite(filename);
953 
954  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
955  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
956  filename);
957  exit_program(1);
958  }
959 
961  avio_flush(out);
962  avio_close(out);
963 }
964 
965 static int open_input_file(OptionsContext *o, const char *filename)
966 {
967  InputFile *f;
968  AVFormatContext *ic;
970  int err, i, ret;
971  int64_t timestamp;
972  AVDictionary *unused_opts = NULL;
973  AVDictionaryEntry *e = NULL;
974  char * video_codec_name = NULL;
975  char * audio_codec_name = NULL;
976  char *subtitle_codec_name = NULL;
977  char * data_codec_name = NULL;
978  int scan_all_pmts_set = 0;
979 
980  if (o->format) {
981  if (!(file_iformat = av_find_input_format(o->format))) {
982  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
983  exit_program(1);
984  }
985  }
986 
987  if (!strcmp(filename, "-"))
988  filename = "pipe:";
989 
990  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
991  strcmp(filename, "/dev/stdin");
992 
993  /* get default parameters from command line */
994  ic = avformat_alloc_context();
995  if (!ic) {
996  print_error(filename, AVERROR(ENOMEM));
997  exit_program(1);
998  }
999  ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1000  if (o->nb_audio_sample_rate) {
1001  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1002  }
1003  if (o->nb_audio_channels) {
1004  /* because we set audio_channels based on both the "ac" and
1005  * "channel_layout" options, we need to check that the specified
1006  * demuxer actually has the "channels" option before setting it */
1007  if (file_iformat && file_iformat->priv_class &&
1008  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1010  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1011  }
1012  }
1013  if (o->nb_frame_rates) {
1014  /* set the format-level framerate option;
1015  * this is important for video grabbers, e.g. x11 */
1016  if (file_iformat && file_iformat->priv_class &&
1017  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1019  av_dict_set(&o->g->format_opts, "framerate",
1020  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1021  }
1022  }
1023  if (o->nb_frame_sizes) {
1024  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1025  }
1026  if (o->nb_frame_pix_fmts)
1027  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1028 
1029  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1030  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1031  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1032  MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1033 
1034  ic->video_codec_id = video_codec_name ?
1035  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
1036  ic->audio_codec_id = audio_codec_name ?
1037  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
1038  ic->subtitle_codec_id= subtitle_codec_name ?
1039  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
1040  ic->data_codec_id = data_codec_name ?
1041  find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
1042 
1043  if (video_codec_name)
1044  av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
1045  if (audio_codec_name)
1046  av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
1047  if (subtitle_codec_name)
1049  if (data_codec_name)
1051 
1052  ic->flags |= AVFMT_FLAG_NONBLOCK;
1053  ic->interrupt_callback = int_cb;
1054 
1055  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1056  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1057  scan_all_pmts_set = 1;
1058  }
1059  /* open the input file with generic avformat function */
1060  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1061  if (err < 0) {
1062  print_error(filename, err);
1063  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1064  av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1065  exit_program(1);
1066  }
1067  if (scan_all_pmts_set)
1068  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1071 
1072  /* apply forced codec ids */
1073  for (i = 0; i < ic->nb_streams; i++)
1074  choose_decoder(o, ic, ic->streams[i]);
1075 
1076  if (find_stream_info) {
1078  int orig_nb_streams = ic->nb_streams;
1079 
1080  /* If not enough info to get the stream parameters, we decode the
1081  first frames to get it. (used in mpeg case for example) */
1082  ret = avformat_find_stream_info(ic, opts);
1083 
1084  for (i = 0; i < orig_nb_streams; i++)
1085  av_dict_free(&opts[i]);
1086  av_freep(&opts);
1087 
1088  if (ret < 0) {
1089  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1090  if (ic->nb_streams == 0) {
1091  avformat_close_input(&ic);
1092  exit_program(1);
1093  }
1094  }
1095  }
1096 
1097  if (o->start_time_eof != AV_NOPTS_VALUE) {
1098  if (ic->duration>0) {
1099  o->start_time = o->start_time_eof + ic->duration;
1100  } else
1101  av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1102  }
1103  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1104  /* add the stream start time */
1105  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1106  timestamp += ic->start_time;
1107 
1108  /* if seeking requested, we execute it */
1109  if (o->start_time != AV_NOPTS_VALUE) {
1110  int64_t seek_timestamp = timestamp;
1111 
1112  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1113  int dts_heuristic = 0;
1114  for (i=0; i<ic->nb_streams; i++) {
1115  const AVCodecParameters *par = ic->streams[i]->codecpar;
1116  if (par->video_delay)
1117  dts_heuristic = 1;
1118  }
1119  if (dts_heuristic) {
1120  seek_timestamp -= 3*AV_TIME_BASE / 23;
1121  }
1122  }
1123  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1124  if (ret < 0) {
1125  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1126  filename, (double)timestamp / AV_TIME_BASE);
1127  }
1128  }
1129 
1130  /* update the current parameters so that they match the one of the input stream */
1131  add_input_streams(o, ic);
1132 
1133  /* dump the file content */
1134  av_dump_format(ic, nb_input_files, filename, 0);
1135 
1137  f = av_mallocz(sizeof(*f));
1138  if (!f)
1139  exit_program(1);
1140  input_files[nb_input_files - 1] = f;
1141 
1142  f->ctx = ic;
1144  f->start_time = o->start_time;
1147  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1148  f->nb_streams = ic->nb_streams;
1149  f->rate_emu = o->rate_emu;
1150  f->accurate_seek = o->accurate_seek;
1151  f->loop = o->loop;
1152  f->duration = 0;
1153  f->time_base = (AVRational){ 1, 1 };
1154 #if HAVE_PTHREADS
1155  f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1156 #endif
1157 
1158  /* check if all codec options have been used */
1159  unused_opts = strip_specifiers(o->g->codec_opts);
1160  for (i = f->ist_index; i < nb_input_streams; i++) {
1161  e = NULL;
1162  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1164  av_dict_set(&unused_opts, e->key, NULL, 0);
1165  }
1166 
1167  e = NULL;
1168  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1169  const AVClass *class = avcodec_get_class();
1170  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1172  const AVClass *fclass = avformat_get_class();
1173  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1175  if (!option || foption)
1176  continue;
1177 
1178 
1179  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1180  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1181  "input file #%d (%s) is not a decoding option.\n", e->key,
1182  option->help ? option->help : "", nb_input_files - 1,
1183  filename);
1184  exit_program(1);
1185  }
1186 
1187  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1188  "input file #%d (%s) has not been used for any stream. The most "
1189  "likely reason is either wrong type (e.g. a video option with "
1190  "no video streams) or that it is a private option of some decoder "
1191  "which was not actually used for any stream.\n", e->key,
1192  option->help ? option->help : "", nb_input_files - 1, filename);
1193  }
1194  av_dict_free(&unused_opts);
1195 
1196  for (i = 0; i < o->nb_dump_attachment; i++) {
1197  int j;
1198 
1199  for (j = 0; j < ic->nb_streams; j++) {
1200  AVStream *st = ic->streams[j];
1201 
1202  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1203  dump_attachment(st, o->dump_attachment[i].u.str);
1204  }
1205  }
1206 
1208 
1209  return 0;
1210 }
1211 
1213 {
1214  AVIOContext *line;
1215  uint8_t *buf;
1216  char c;
1217 
1218  if (avio_open_dyn_buf(&line) < 0) {
1219  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1220  exit_program(1);
1221  }
1222 
1223  while ((c = avio_r8(s)) && c != '\n')
1224  avio_w8(line, c);
1225  avio_w8(line, 0);
1226  avio_close_dyn_buf(line, &buf);
1227 
1228  return buf;
1229 }
1230 
1231 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1232 {
1233  int i, ret = -1;
1234  char filename[1000];
1235  const char *base[3] = { getenv("AVCONV_DATADIR"),
1236  getenv("HOME"),
1237  AVCONV_DATADIR,
1238  };
1239 
1240  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1241  if (!base[i])
1242  continue;
1243  if (codec_name) {
1244  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1245  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1246  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1247  }
1248  if (ret < 0) {
1249  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1250  i != 1 ? "" : "/.avconv", preset_name);
1251  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1252  }
1253  }
1254  return ret;
1255 }
1256 
1258 {
1259  enum AVMediaType type = ost->st->codecpar->codec_type;
1260  char *codec_name = NULL;
1261 
1262  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1263  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1264  if (!codec_name) {
1266  NULL, ost->st->codecpar->codec_type);
1267  ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1268  if (!ost->enc) {
1269  av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1270  "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1271  "probably disabled. Please choose an encoder manually.\n",
1272  ost->file_index, ost->index, s->oformat->name,
1275  }
1276  } else if (!strcmp(codec_name, "copy"))
1277  ost->stream_copy = 1;
1278  else {
1279  ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1280  ost->st->codecpar->codec_id = ost->enc->id;
1281  }
1282  ost->encoding_needed = !ost->stream_copy;
1283  } else {
1284  /* no encoding supported for other media types */
1285  ost->stream_copy = 1;
1286  ost->encoding_needed = 0;
1287  }
1288 
1289  return 0;
1290 }
1291 
1293 {
1294  OutputStream *ost;
1295  AVStream *st = avformat_new_stream(oc, NULL);
1296  int idx = oc->nb_streams - 1, ret = 0;
1297  const char *bsfs = NULL, *time_base = NULL;
1298  char *next, *codec_tag = NULL;
1299  double qscale = -1;
1300  int i;
1301 
1302  if (!st) {
1303  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1304  exit_program(1);
1305  }
1306 
1307  if (oc->nb_streams - 1 < o->nb_streamid_map)
1308  st->id = o->streamid_map[oc->nb_streams - 1];
1309 
1311  if (!(ost = av_mallocz(sizeof(*ost))))
1312  exit_program(1);
1313  output_streams[nb_output_streams - 1] = ost;
1314 
1315  ost->file_index = nb_output_files - 1;
1316  ost->index = idx;
1317  ost->st = st;
1318  st->codecpar->codec_type = type;
1319 
1320  ret = choose_encoder(o, oc, ost);
1321  if (ret < 0) {
1322  av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1323  "%d:%d\n", ost->file_index, ost->index);
1324  exit_program(1);
1325  }
1326 
1327  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1328  if (!ost->enc_ctx) {
1329  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1330  exit_program(1);
1331  }
1332  ost->enc_ctx->codec_type = type;
1333 
1335  if (!ost->ref_par) {
1336  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1337  exit_program(1);
1338  }
1339 
1340  if (ost->enc) {
1341  AVIOContext *s = NULL;
1342  char *buf = NULL, *arg = NULL, *preset = NULL;
1343 
1344  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1345 
1346  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1347  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1348  do {
1349  buf = get_line(s);
1350  if (!buf[0] || buf[0] == '#') {
1351  av_free(buf);
1352  continue;
1353  }
1354  if (!(arg = strchr(buf, '='))) {
1355  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1356  exit_program(1);
1357  }
1358  *arg++ = 0;
1360  av_free(buf);
1361  } while (!s->eof_reached);
1362  avio_closep(&s);
1363  }
1364  if (ret) {
1366  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1367  preset, ost->file_index, ost->index);
1368  exit_program(1);
1369  }
1370  } else {
1372  }
1373 
1374  MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1375  if (time_base) {
1376  AVRational q;
1377  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1378  q.num <= 0 || q.den <= 0) {
1379  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1380  exit_program(1);
1381  }
1382  st->time_base = q;
1383  }
1384 
1385  MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1386  if (time_base) {
1387  AVRational q;
1388  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1389  q.den <= 0) {
1390  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1391  exit_program(1);
1392  }
1393  ost->enc_timebase = q;
1394  }
1395 
1396  ost->max_frames = INT64_MAX;
1397  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1398  for (i = 0; i<o->nb_max_frames; i++) {
1399  char *p = o->max_frames[i].specifier;
1400  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1401  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1402  break;
1403  }
1404  }
1405 
1406  ost->copy_prior_start = -1;
1407  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1408 
1409  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1410  while (bsfs && *bsfs) {
1411  const AVBitStreamFilter *filter;
1412  char *bsf, *bsf_options_str, *bsf_name;
1413 
1414  bsf = av_get_token(&bsfs, ",");
1415  if (!bsf)
1416  exit_program(1);
1417  bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1418  if (!bsf_name)
1419  exit_program(1);
1420 
1421  filter = av_bsf_get_by_name(bsf_name);
1422  if (!filter) {
1423  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1424  exit_program(1);
1425  }
1426 
1427  ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1428  ost->nb_bitstream_filters + 1,
1429  sizeof(*ost->bsf_ctx));
1430  if (!ost->bsf_ctx)
1431  exit_program(1);
1432 
1433  ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1434  if (ret < 0) {
1435  av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1436  exit_program(1);
1437  }
1438 
1439  ost->nb_bitstream_filters++;
1440 
1441  if (bsf_options_str && filter->priv_class) {
1442  const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1443  const char * shorthand[2] = {NULL};
1444 
1445  if (opt)
1446  shorthand[0] = opt->name;
1447 
1448  ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1449  if (ret < 0) {
1450  av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1451  exit_program(1);
1452  }
1453  }
1454  av_freep(&bsf);
1455 
1456  if (*bsfs)
1457  bsfs++;
1458  }
1459 
1460  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1461  if (codec_tag) {
1462  uint32_t tag = strtol(codec_tag, &next, 0);
1463  if (*next)
1464  tag = AV_RL32(codec_tag);
1465  ost->st->codecpar->codec_tag =
1466  ost->enc_ctx->codec_tag = tag;
1467  }
1468 
1469  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1470  if (qscale >= 0) {
1472  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1473  }
1474 
1475  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1476  ost->disposition = av_strdup(ost->disposition);
1477 
1478  ost->max_muxing_queue_size = 128;
1479  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1480  ost->max_muxing_queue_size *= sizeof(AVPacket);
1481 
1482  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1484 
1485  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1486 
1487  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1488  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1489  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1490 
1491  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1492 
1493  ost->source_index = source_index;
1494  if (source_index >= 0) {
1495  ost->sync_ist = input_streams[source_index];
1496  input_streams[source_index]->discard = 0;
1497  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1498  }
1500 
1501  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1502  if (!ost->muxing_queue)
1503  exit_program(1);
1504 
1505  return ost;
1506 }
1507 
1508 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1509 {
1510  int i;
1511  const char *p = str;
1512  for (i = 0;; i++) {
1513  dest[i] = atoi(p);
1514  if (i == 63)
1515  break;
1516  p = strchr(p, ',');
1517  if (!p) {
1518  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1519  exit_program(1);
1520  }
1521  p++;
1522  }
1523 }
1524 
1525 /* read file contents into a string */
1526 static uint8_t *read_file(const char *filename)
1527 {
1528  AVIOContext *pb = NULL;
1529  AVIOContext *dyn_buf = NULL;
1530  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1531  uint8_t buf[1024], *str;
1532 
1533  if (ret < 0) {
1534  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1535  return NULL;
1536  }
1537 
1538  ret = avio_open_dyn_buf(&dyn_buf);
1539  if (ret < 0) {
1540  avio_closep(&pb);
1541  return NULL;
1542  }
1543  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1544  avio_write(dyn_buf, buf, ret);
1545  avio_w8(dyn_buf, 0);
1546  avio_closep(&pb);
1547 
1548  ret = avio_close_dyn_buf(dyn_buf, &str);
1549  if (ret < 0)
1550  return NULL;
1551  return str;
1552 }
1553 
1555  OutputStream *ost)
1556 {
1557  AVStream *st = ost->st;
1558 
1559  if (ost->filters_script && ost->filters) {
1560  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1561  "output stream #%d:%d.\n", nb_output_files, st->index);
1562  exit_program(1);
1563  }
1564 
1565  if (ost->filters_script)
1566  return read_file(ost->filters_script);
1567  else if (ost->filters)
1568  return av_strdup(ost->filters);
1569 
1571  "null" : "anull");
1572 }
1573 
1575  const OutputStream *ost, enum AVMediaType type)
1576 {
1577  if (ost->filters_script || ost->filters) {
1579  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1580  "Filtering and streamcopy cannot be used together.\n",
1581  ost->filters ? "Filtergraph" : "Filtergraph script",
1582  ost->filters ? ost->filters : ost->filters_script,
1583  av_get_media_type_string(type), ost->file_index, ost->index);
1584  exit_program(1);
1585  }
1586 }
1587 
1589 {
1590  AVStream *st;
1591  OutputStream *ost;
1592  AVCodecContext *video_enc;
1593  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1594 
1595  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1596  st = ost->st;
1597  video_enc = ost->enc_ctx;
1598 
1599  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1600  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1601  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1602  exit_program(1);
1603  }
1604  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1605  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1606 
1607  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1608  if (frame_aspect_ratio) {
1609  AVRational q;
1610  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1611  q.num <= 0 || q.den <= 0) {
1612  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1613  exit_program(1);
1614  }
1615  ost->frame_aspect_ratio = q;
1616  }
1617 
1618  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1619  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1620 
1621  if (!ost->stream_copy) {
1622  const char *p = NULL;
1623  char *frame_size = NULL;
1624  char *frame_pix_fmt = NULL;
1625  char *intra_matrix = NULL, *inter_matrix = NULL;
1626  char *chroma_intra_matrix = NULL;
1627  int do_pass = 0;
1628  int i;
1629 
1630  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1631  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1632  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1633  exit_program(1);
1634  }
1635 
1637  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1638  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1639  ost->keep_pix_fmt = 1;
1640  if (!*++frame_pix_fmt)
1641  frame_pix_fmt = NULL;
1642  }
1643  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1644  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1645  exit_program(1);
1646  }
1647  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1648 
1649  if (intra_only)
1650  video_enc->gop_size = 0;
1651  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1652  if (intra_matrix) {
1653  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1654  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1655  exit_program(1);
1656  }
1657  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1658  }
1659  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1660  if (chroma_intra_matrix) {
1661  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1662  if (!p) {
1663  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1664  exit_program(1);
1665  }
1666  av_codec_set_chroma_intra_matrix(video_enc, p);
1667  parse_matrix_coeffs(p, chroma_intra_matrix);
1668  }
1669  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1670  if (inter_matrix) {
1671  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1672  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1673  exit_program(1);
1674  }
1675  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1676  }
1677 
1678  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1679  for (i = 0; p; i++) {
1680  int start, end, q;
1681  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1682  if (e != 3) {
1683  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1684  exit_program(1);
1685  }
1686  video_enc->rc_override =
1687  av_realloc_array(video_enc->rc_override,
1688  i + 1, sizeof(RcOverride));
1689  if (!video_enc->rc_override) {
1690  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1691  exit_program(1);
1692  }
1693  video_enc->rc_override[i].start_frame = start;
1694  video_enc->rc_override[i].end_frame = end;
1695  if (q > 0) {
1696  video_enc->rc_override[i].qscale = q;
1697  video_enc->rc_override[i].quality_factor = 1.0;
1698  }
1699  else {
1700  video_enc->rc_override[i].qscale = 0;
1701  video_enc->rc_override[i].quality_factor = -q/100.0;
1702  }
1703  p = strchr(p, '/');
1704  if (p) p++;
1705  }
1706  video_enc->rc_override_count = i;
1707 
1708  if (do_psnr)
1709  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1710 
1711  /* two pass mode */
1712  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1713  if (do_pass) {
1714  if (do_pass & 1) {
1715  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1716  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1717  }
1718  if (do_pass & 2) {
1719  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1720  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1721  }
1722  }
1723 
1724  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1725  if (ost->logfile_prefix &&
1726  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1727  exit_program(1);
1728 
1729  if (do_pass) {
1730  char logfilename[1024];
1731  FILE *f;
1732 
1733  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1734  ost->logfile_prefix ? ost->logfile_prefix :
1736  i);
1737  if (!strcmp(ost->enc->name, "libx264")) {
1738  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1739  } else {
1740  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1741  char *logbuffer = read_file(logfilename);
1742 
1743  if (!logbuffer) {
1744  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1745  logfilename);
1746  exit_program(1);
1747  }
1748  video_enc->stats_in = logbuffer;
1749  }
1750  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1751  f = av_fopen_utf8(logfilename, "wb");
1752  if (!f) {
1754  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1755  logfilename, strerror(errno));
1756  exit_program(1);
1757  }
1758  ost->logfile = f;
1759  }
1760  }
1761  }
1762 
1763  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1764  if (ost->forced_keyframes)
1766 
1767  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1768 
1769  ost->top_field_first = -1;
1770  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1771 
1772 
1773  ost->avfilter = get_ost_filters(o, oc, ost);
1774  if (!ost->avfilter)
1775  exit_program(1);
1776  } else {
1777  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1778  }
1779 
1780  if (ost->stream_copy)
1782 
1783  return ost;
1784 }
1785 
1787 {
1788  int n;
1789  AVStream *st;
1790  OutputStream *ost;
1791  AVCodecContext *audio_enc;
1792 
1793  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1794  st = ost->st;
1795 
1796  audio_enc = ost->enc_ctx;
1797  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1798 
1799  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1800  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1801 
1802  if (!ost->stream_copy) {
1803  char *sample_fmt = NULL;
1804 
1805  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1806 
1807  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1808  if (sample_fmt &&
1809  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1810  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1811  exit_program(1);
1812  }
1813 
1814  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1815 
1816  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1817  ost->apad = av_strdup(ost->apad);
1818 
1819  ost->avfilter = get_ost_filters(o, oc, ost);
1820  if (!ost->avfilter)
1821  exit_program(1);
1822 
1823  /* check for channel mapping for this audio stream */
1824  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1826  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1827  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1828  InputStream *ist;
1829 
1830  if (map->channel_idx == -1) {
1831  ist = NULL;
1832  } else if (ost->source_index < 0) {
1833  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1834  ost->file_index, ost->st->index);
1835  continue;
1836  } else {
1837  ist = input_streams[ost->source_index];
1838  }
1839 
1840  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1842  ost->audio_channels_mapped + 1,
1843  sizeof(*ost->audio_channels_map)
1844  ) < 0 )
1845  exit_program(1);
1846 
1848  }
1849  }
1850  }
1851  }
1852 
1853  if (ost->stream_copy)
1855 
1856  return ost;
1857 }
1858 
1860 {
1861  OutputStream *ost;
1862 
1863  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1864  if (!ost->stream_copy) {
1865  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1866  exit_program(1);
1867  }
1868 
1869  return ost;
1870 }
1871 
1873 {
1874  OutputStream *ost;
1875 
1876  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1877  if (!ost->stream_copy) {
1878  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1879  exit_program(1);
1880  }
1881 
1882  return ost;
1883 }
1884 
1886 {
1887  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1888  ost->stream_copy = 1;
1889  ost->finished = 1;
1890  return ost;
1891 }
1892 
1894 {
1895  AVStream *st;
1896  OutputStream *ost;
1897  AVCodecContext *subtitle_enc;
1898 
1899  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1900  st = ost->st;
1901  subtitle_enc = ost->enc_ctx;
1902 
1903  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1904 
1905  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1906 
1907  if (!ost->stream_copy) {
1908  char *frame_size = NULL;
1909 
1910  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1911  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1912  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1913  exit_program(1);
1914  }
1915  }
1916 
1917  return ost;
1918 }
1919 
1920 /* arg format is "output-stream-index:streamid-value". */
1921 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1922 {
1923  OptionsContext *o = optctx;
1924  int idx;
1925  char *p;
1926  char idx_str[16];
1927 
1928  av_strlcpy(idx_str, arg, sizeof(idx_str));
1929  p = strchr(idx_str, ':');
1930  if (!p) {
1932  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1933  arg, opt);
1934  exit_program(1);
1935  }
1936  *p++ = '\0';
1937  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1938  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1939  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1940  return 0;
1941 }
1942 
1944 {
1945  AVFormatContext *is = ifile->ctx;
1946  AVFormatContext *os = ofile->ctx;
1947  AVChapter **tmp;
1948  int i;
1949 
1950  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1951  if (!tmp)
1952  return AVERROR(ENOMEM);
1953  os->chapters = tmp;
1954 
1955  for (i = 0; i < is->nb_chapters; i++) {
1956  AVChapter *in_ch = is->chapters[i], *out_ch;
1957  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1958  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1959  AV_TIME_BASE_Q, in_ch->time_base);
1960  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1962 
1963 
1964  if (in_ch->end < ts_off)
1965  continue;
1966  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1967  break;
1968 
1969  out_ch = av_mallocz(sizeof(AVChapter));
1970  if (!out_ch)
1971  return AVERROR(ENOMEM);
1972 
1973  out_ch->id = in_ch->id;
1974  out_ch->time_base = in_ch->time_base;
1975  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1976  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1977 
1978  if (copy_metadata)
1979  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1980 
1981  os->chapters[os->nb_chapters++] = out_ch;
1982  }
1983  return 0;
1984 }
1985 
1986 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1987 {
1988  int i, err;
1990 
1991  ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1992  ic->interrupt_callback = int_cb;
1993  err = avformat_open_input(&ic, filename, NULL, NULL);
1994  if (err < 0)
1995  return err;
1996  /* copy stream format */
1997  for(i=0;i<ic->nb_streams;i++) {
1998  AVStream *st;
1999  OutputStream *ost;
2000  AVCodec *codec;
2001  const char *enc_config;
2002 
2003  codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2004  if (!codec) {
2005  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2006  return AVERROR(EINVAL);
2007  }
2008  if (codec->type == AVMEDIA_TYPE_AUDIO)
2009  opt_audio_codec(o, "c:a", codec->name);
2010  else if (codec->type == AVMEDIA_TYPE_VIDEO)
2011  opt_video_codec(o, "c:v", codec->name);
2012  ost = new_output_stream(o, s, codec->type, -1);
2013  st = ost->st;
2014 
2015  avcodec_get_context_defaults3(st->codec, codec);
2017  if (enc_config) {
2018  AVDictionary *opts = NULL;
2019  av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2020  av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2021  av_dict_free(&opts);
2022  }
2023 
2024  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2025  choose_sample_fmt(st, codec);
2026  else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2027  choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2028  avcodec_copy_context(ost->enc_ctx, st->codec);
2029  if (enc_config)
2030  av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2031  }
2032 
2033  avformat_close_input(&ic);
2034  return err;
2035 }
2036 
2038  AVFormatContext *oc)
2039 {
2040  OutputStream *ost;
2041 
2042  switch (ofilter->type) {
2043  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2044  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2045  default:
2046  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2047  "currently.\n");
2048  exit_program(1);
2049  }
2050 
2051  ost->source_index = -1;
2052  ost->filter = ofilter;
2053 
2054  ofilter->ost = ost;
2055  ofilter->format = -1;
2056 
2057  if (ost->stream_copy) {
2058  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2059  "which is fed from a complex filtergraph. Filtering and streamcopy "
2060  "cannot be used together.\n", ost->file_index, ost->index);
2061  exit_program(1);
2062  }
2063 
2064  if (ost->avfilter && (ost->filters || ost->filters_script)) {
2065  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2067  "%s '%s' was specified through the %s option "
2068  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2069  "%s and -filter_complex cannot be used together for the same stream.\n",
2070  ost->filters ? "Filtergraph" : "Filtergraph script",
2071  ost->filters ? ost->filters : ost->filters_script,
2072  opt, ost->file_index, ost->index, opt);
2073  exit_program(1);
2074  }
2075 
2076  avfilter_inout_free(&ofilter->out_tmp);
2077 }
2078 
2079 static int init_complex_filters(void)
2080 {
2081  int i, ret = 0;
2082 
2083  for (i = 0; i < nb_filtergraphs; i++) {
2085  if (ret < 0)
2086  return ret;
2087  }
2088  return 0;
2089 }
2090 
2091 static int open_output_file(OptionsContext *o, const char *filename)
2092 {
2093  AVFormatContext *oc;
2094  int i, j, err;
2095  AVOutputFormat *file_oformat;
2096  OutputFile *of;
2097  OutputStream *ost;
2098  InputStream *ist;
2099  AVDictionary *unused_opts = NULL;
2100  AVDictionaryEntry *e = NULL;
2101  int format_flags = 0;
2102 
2103  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2104  o->stop_time = INT64_MAX;
2105  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2106  }
2107 
2108  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2109  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2110  if (o->stop_time <= start_time) {
2111  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2112  exit_program(1);
2113  } else {
2115  }
2116  }
2117 
2119  of = av_mallocz(sizeof(*of));
2120  if (!of)
2121  exit_program(1);
2122  output_files[nb_output_files - 1] = of;
2123 
2125  of->recording_time = o->recording_time;
2126  of->start_time = o->start_time;
2127  of->limit_filesize = o->limit_filesize;
2128  of->shortest = o->shortest;
2129  av_dict_copy(&of->opts, o->g->format_opts, 0);
2130 
2131  if (!strcmp(filename, "-"))
2132  filename = "pipe:";
2133 
2134  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2135  if (!oc) {
2136  print_error(filename, err);
2137  exit_program(1);
2138  }
2139 
2140  of->ctx = oc;
2141  if (o->recording_time != INT64_MAX)
2142  oc->duration = o->recording_time;
2143 
2144  file_oformat= oc->oformat;
2145  oc->interrupt_callback = int_cb;
2146 
2147  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2148  if (e) {
2149  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2150  av_opt_eval_flags(oc, o, e->value, &format_flags);
2151  }
2152 
2153  /* create streams for all unlabeled output pads */
2154  for (i = 0; i < nb_filtergraphs; i++) {
2155  FilterGraph *fg = filtergraphs[i];
2156  for (j = 0; j < fg->nb_outputs; j++) {
2157  OutputFilter *ofilter = fg->outputs[j];
2158 
2159  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2160  continue;
2161 
2162  switch (ofilter->type) {
2163  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2164  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2165  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2166  }
2167  init_output_filter(ofilter, o, oc);
2168  }
2169  }
2170 
2171  /* ffserver seeking with date=... needs a date reference */
2172  if (!strcmp(file_oformat->name, "ffm") &&
2173  !(format_flags & AVFMT_FLAG_BITEXACT) &&
2174  av_strstart(filename, "http:", NULL)) {
2175  int err = parse_option(o, "metadata", "creation_time=now", options);
2176  if (err < 0) {
2177  print_error(filename, err);
2178  exit_program(1);
2179  }
2180  }
2181 
2182  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2183  av_strstart(filename, "http:", NULL)) {
2184  int j;
2185  /* special case for files sent to ffserver: we get the stream
2186  parameters from ffserver */
2187  int err = read_ffserver_streams(o, oc, filename);
2188  if (err < 0) {
2189  print_error(filename, err);
2190  exit_program(1);
2191  }
2192  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2193  ost = output_streams[j];
2194  for (i = 0; i < nb_input_streams; i++) {
2195  ist = input_streams[i];
2196  if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2197  ost->sync_ist= ist;
2198  ost->source_index= i;
2199  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2200  if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2201  ist->discard = 0;
2202  ist->st->discard = ist->user_set_discard;
2203  break;
2204  }
2205  }
2206  if(!ost->sync_ist){
2207  av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2208  exit_program(1);
2209  }
2210  }
2211  } else if (!o->nb_stream_maps) {
2212  char *subtitle_codec_name = NULL;
2213  /* pick the "best" stream of each type */
2214 
2215  /* video: highest resolution */
2217  int area = 0, idx = -1;
2218  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2219  for (i = 0; i < nb_input_streams; i++) {
2220  int new_area;
2221  ist = input_streams[i];
2222  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2223  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2224  new_area = 1;
2225  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2226  new_area > area) {
2227  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2228  continue;
2229  area = new_area;
2230  idx = i;
2231  }
2232  }
2233  if (idx >= 0)
2234  new_video_stream(o, oc, idx);
2235  }
2236 
2237  /* audio: most channels */
2239  int best_score = 0, idx = -1;
2240  for (i = 0; i < nb_input_streams; i++) {
2241  int score;
2242  ist = input_streams[i];
2243  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2244  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2245  score > best_score) {
2246  best_score = score;
2247  idx = i;
2248  }
2249  }
2250  if (idx >= 0)
2251  new_audio_stream(o, oc, idx);
2252  }
2253 
2254  /* subtitles: pick first */
2255  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2256  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2257  for (i = 0; i < nb_input_streams; i++)
2258  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2259  AVCodecDescriptor const *input_descriptor =
2260  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2261  AVCodecDescriptor const *output_descriptor = NULL;
2262  AVCodec const *output_codec =
2264  int input_props = 0, output_props = 0;
2265  if (output_codec)
2266  output_descriptor = avcodec_descriptor_get(output_codec->id);
2267  if (input_descriptor)
2268  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2269  if (output_descriptor)
2270  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2271  if (subtitle_codec_name ||
2272  input_props & output_props ||
2273  // Map dvb teletext which has neither property to any output subtitle encoder
2274  input_descriptor && output_descriptor &&
2275  (!input_descriptor->props ||
2276  !output_descriptor->props)) {
2277  new_subtitle_stream(o, oc, i);
2278  break;
2279  }
2280  }
2281  }
2282  /* Data only if codec id match */
2283  if (!o->data_disable ) {
2285  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2286  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2287  && input_streams[i]->st->codecpar->codec_id == codec_id )
2288  new_data_stream(o, oc, i);
2289  }
2290  }
2291  } else {
2292  for (i = 0; i < o->nb_stream_maps; i++) {
2293  StreamMap *map = &o->stream_maps[i];
2294 
2295  if (map->disabled)
2296  continue;
2297 
2298  if (map->linklabel) {
2299  FilterGraph *fg;
2300  OutputFilter *ofilter = NULL;
2301  int j, k;
2302 
2303  for (j = 0; j < nb_filtergraphs; j++) {
2304  fg = filtergraphs[j];
2305  for (k = 0; k < fg->nb_outputs; k++) {
2306  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2307  if (out && !strcmp(out->name, map->linklabel)) {
2308  ofilter = fg->outputs[k];
2309  goto loop_end;
2310  }
2311  }
2312  }
2313 loop_end:
2314  if (!ofilter) {
2315  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2316  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2317  exit_program(1);
2318  }
2319  init_output_filter(ofilter, o, oc);
2320  } else {
2321  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2322 
2325  continue;
2327  continue;
2329  continue;
2330  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2331  continue;
2332 
2333  ost = NULL;
2334  switch (ist->st->codecpar->codec_type) {
2335  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2336  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2337  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2338  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2339  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2340  case AVMEDIA_TYPE_UNKNOWN:
2341  if (copy_unknown_streams) {
2342  ost = new_unknown_stream (o, oc, src_idx);
2343  break;
2344  }
2345  default:
2347  "Cannot map stream #%d:%d - unsupported type.\n",
2348  map->file_index, map->stream_index);
2349  if (!ignore_unknown_streams) {
2350  av_log(NULL, AV_LOG_FATAL,
2351  "If you want unsupported types ignored instead "
2352  "of failing, please use the -ignore_unknown option\n"
2353  "If you want them copied, please use -copy_unknown\n");
2354  exit_program(1);
2355  }
2356  }
2357  if (ost)
2358  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2359  + map->sync_stream_index];
2360  }
2361  }
2362  }
2363 
2364  /* handle attached files */
2365  for (i = 0; i < o->nb_attachments; i++) {
2366  AVIOContext *pb;
2367  uint8_t *attachment;
2368  const char *p;
2369  int64_t len;
2370 
2371  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2372  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2373  o->attachments[i]);
2374  exit_program(1);
2375  }
2376  if ((len = avio_size(pb)) <= 0) {
2377  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2378  o->attachments[i]);
2379  exit_program(1);
2380  }
2381  if (!(attachment = av_malloc(len))) {
2382  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2383  o->attachments[i]);
2384  exit_program(1);
2385  }
2386  avio_read(pb, attachment, len);
2387 
2388  ost = new_attachment_stream(o, oc, -1);
2389  ost->stream_copy = 0;
2390  ost->attachment_filename = o->attachments[i];
2391  ost->st->codecpar->extradata = attachment;
2392  ost->st->codecpar->extradata_size = len;
2393 
2394  p = strrchr(o->attachments[i], '/');
2395  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2396  avio_closep(&pb);
2397  }
2398 
2399 #if FF_API_LAVF_AVCTX
2400  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2401  AVDictionaryEntry *e;
2402  ost = output_streams[i];
2403 
2404  if ((ost->stream_copy || ost->attachment_filename)
2405  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2406  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2407  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2408  exit_program(1);
2409  }
2410 #endif
2411 
2412  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2413  av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2414  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2415  exit_program(1);
2416  }
2417 
2418  /* check if all codec options have been used */
2419  unused_opts = strip_specifiers(o->g->codec_opts);
2420  for (i = of->ost_index; i < nb_output_streams; i++) {
2421  e = NULL;
2422  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2424  av_dict_set(&unused_opts, e->key, NULL, 0);
2425  }
2426 
2427  e = NULL;
2428  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2429  const AVClass *class = avcodec_get_class();
2430  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2432  const AVClass *fclass = avformat_get_class();
2433  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2435  if (!option || foption)
2436  continue;
2437 
2438 
2439  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2440  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2441  "output file #%d (%s) is not an encoding option.\n", e->key,
2442  option->help ? option->help : "", nb_output_files - 1,
2443  filename);
2444  exit_program(1);
2445  }
2446 
2447  // gop_timecode is injected by generic code but not always used
2448  if (!strcmp(e->key, "gop_timecode"))
2449  continue;
2450 
2451  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2452  "output file #%d (%s) has not been used for any stream. The most "
2453  "likely reason is either wrong type (e.g. a video option with "
2454  "no video streams) or that it is a private option of some encoder "
2455  "which was not actually used for any stream.\n", e->key,
2456  option->help ? option->help : "", nb_output_files - 1, filename);
2457  }
2458  av_dict_free(&unused_opts);
2459 
2460  /* set the decoding_needed flags and create simple filtergraphs */
2461  for (i = of->ost_index; i < nb_output_streams; i++) {
2462  OutputStream *ost = output_streams[i];
2463 
2464  if (ost->encoding_needed && ost->source_index >= 0) {
2465  InputStream *ist = input_streams[ost->source_index];
2467 
2468  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2470  err = init_simple_filtergraph(ist, ost);
2471  if (err < 0) {
2473  "Error initializing a simple filtergraph between streams "
2474  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2475  nb_output_files - 1, ost->st->index);
2476  exit_program(1);
2477  }
2478  }
2479  }
2480 
2481  /* set the filter output constraints */
2482  if (ost->filter) {
2483  OutputFilter *f = ost->filter;
2484  int count;
2485  switch (ost->enc_ctx->codec_type) {
2486  case AVMEDIA_TYPE_VIDEO:
2487  f->frame_rate = ost->frame_rate;
2488  f->width = ost->enc_ctx->width;
2489  f->height = ost->enc_ctx->height;
2490  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2491  f->format = ost->enc_ctx->pix_fmt;
2492  } else if (ost->enc->pix_fmts) {
2493  count = 0;
2494  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2495  count++;
2496  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2497  if (!f->formats)
2498  exit_program(1);
2499  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2500  }
2501  break;
2502  case AVMEDIA_TYPE_AUDIO:
2503  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2504  f->format = ost->enc_ctx->sample_fmt;
2505  } else if (ost->enc->sample_fmts) {
2506  count = 0;
2507  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2508  count++;
2509  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2510  if (!f->formats)
2511  exit_program(1);
2512  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2513  }
2514  if (ost->enc_ctx->sample_rate) {
2515  f->sample_rate = ost->enc_ctx->sample_rate;
2516  } else if (ost->enc->supported_samplerates) {
2517  count = 0;
2518  while (ost->enc->supported_samplerates[count])
2519  count++;
2520  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2521  if (!f->sample_rates)
2522  exit_program(1);
2523  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2524  (count + 1) * sizeof(*f->sample_rates));
2525  }
2526  if (ost->enc_ctx->channels) {
2528  } else if (ost->enc->channel_layouts) {
2529  count = 0;
2530  while (ost->enc->channel_layouts[count])
2531  count++;
2532  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2533  if (!f->channel_layouts)
2534  exit_program(1);
2535  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2536  (count + 1) * sizeof(*f->channel_layouts));
2537  }
2538  break;
2539  }
2540  }
2541  }
2542 
2543  /* check filename in case of an image number is expected */
2544  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2545  if (!av_filename_number_test(oc->filename)) {
2546  print_error(oc->filename, AVERROR(EINVAL));
2547  exit_program(1);
2548  }
2549  }
2550 
2553  "No input streams but output needs an input stream\n");
2554  exit_program(1);
2555  }
2556 
2557  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2558  /* test if it already exists to avoid losing precious files */
2559  assert_file_overwrite(filename);
2560 
2561  /* open the file */
2562  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2563  &oc->interrupt_callback,
2564  &of->opts)) < 0) {
2565  print_error(filename, err);
2566  exit_program(1);
2567  }
2568  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2569  assert_file_overwrite(filename);
2570 
2571  if (o->mux_preload) {
2572  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2573  }
2574  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2575 
2576  /* copy metadata */
2577  for (i = 0; i < o->nb_metadata_map; i++) {
2578  char *p;
2579  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2580 
2581  if (in_file_index >= nb_input_files) {
2582  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2583  exit_program(1);
2584  }
2585  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2586  in_file_index >= 0 ?
2587  input_files[in_file_index]->ctx : NULL, o);
2588  }
2589 
2590  /* copy chapters */
2591  if (o->chapters_input_file >= nb_input_files) {
2592  if (o->chapters_input_file == INT_MAX) {
2593  /* copy chapters from the first input file that has them*/
2594  o->chapters_input_file = -1;
2595  for (i = 0; i < nb_input_files; i++)
2596  if (input_files[i]->ctx->nb_chapters) {
2597  o->chapters_input_file = i;
2598  break;
2599  }
2600  } else {
2601  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2602  o->chapters_input_file);
2603  exit_program(1);
2604  }
2605  }
2606  if (o->chapters_input_file >= 0)
2609 
2610  /* copy global metadata by default */
2614  if(o->recording_time != INT64_MAX)
2615  av_dict_set(&oc->metadata, "duration", NULL, 0);
2616  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2617  }
2618  if (!o->metadata_streams_manual)
2619  for (i = of->ost_index; i < nb_output_streams; i++) {
2620  InputStream *ist;
2621  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2622  continue;
2624  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2625  if (!output_streams[i]->stream_copy) {
2626  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2627  }
2628  }
2629 
2630  /* process manually set programs */
2631  for (i = 0; i < o->nb_program; i++) {
2632  const char *p = o->program[i].u.str;
2633  int progid = i+1;
2634  AVProgram *program;
2635 
2636  while(*p) {
2637  const char *p2 = av_get_token(&p, ":");
2638  const char *to_dealloc = p2;
2639  char *key;
2640  if (!p2)
2641  break;
2642 
2643  if(*p) p++;
2644 
2645  key = av_get_token(&p2, "=");
2646  if (!key || !*p2) {
2647  av_freep(&to_dealloc);
2648  av_freep(&key);
2649  break;
2650  }
2651  p2++;
2652 
2653  if (!strcmp(key, "program_num"))
2654  progid = strtol(p2, NULL, 0);
2655  av_freep(&to_dealloc);
2656  av_freep(&key);
2657  }
2658 
2659  program = av_new_program(oc, progid);
2660 
2661  p = o->program[i].u.str;
2662  while(*p) {
2663  const char *p2 = av_get_token(&p, ":");
2664  const char *to_dealloc = p2;
2665  char *key;
2666  if (!p2)
2667  break;
2668  if(*p) p++;
2669 
2670  key = av_get_token(&p2, "=");
2671  if (!key) {
2673  "No '=' character in program string %s.\n",
2674  p2);
2675  exit_program(1);
2676  }
2677  if (!*p2)
2678  exit_program(1);
2679  p2++;
2680 
2681  if (!strcmp(key, "title")) {
2682  av_dict_set(&program->metadata, "title", p2, 0);
2683  } else if (!strcmp(key, "program_num")) {
2684  } else if (!strcmp(key, "st")) {
2685  int st_num = strtol(p2, NULL, 0);
2686  av_program_add_stream_index(oc, progid, st_num);
2687  } else {
2688  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2689  exit_program(1);
2690  }
2691  av_freep(&to_dealloc);
2692  av_freep(&key);
2693  }
2694  }
2695 
2696  /* process manually set metadata */
2697  for (i = 0; i < o->nb_metadata; i++) {
2698  AVDictionary **m;
2699  char type, *val;
2700  const char *stream_spec;
2701  int index = 0, j, ret = 0;
2702 
2703  val = strchr(o->metadata[i].u.str, '=');
2704  if (!val) {
2705  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2706  o->metadata[i].u.str);
2707  exit_program(1);
2708  }
2709  *val++ = 0;
2710 
2711  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2712  if (type == 's') {
2713  for (j = 0; j < oc->nb_streams; j++) {
2714  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2715  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2716  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2717  char *tail;
2718  double theta = av_strtod(val, &tail);
2719  if (!*tail) {
2720  ost->rotate_overridden = 1;
2721  ost->rotate_override_value = theta;
2722  }
2723  } else {
2724  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2725  }
2726  } else if (ret < 0)
2727  exit_program(1);
2728  }
2729  }
2730  else {
2731  switch (type) {
2732  case 'g':
2733  m = &oc->metadata;
2734  break;
2735  case 'c':
2736  if (index < 0 || index >= oc->nb_chapters) {
2737  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2738  exit_program(1);
2739  }
2740  m = &oc->chapters[index]->metadata;
2741  break;
2742  case 'p':
2743  if (index < 0 || index >= oc->nb_programs) {
2744  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2745  exit_program(1);
2746  }
2747  m = &oc->programs[index]->metadata;
2748  break;
2749  default:
2750  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2751  exit_program(1);
2752  }
2753  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2754  }
2755  }
2756 
2757  return 0;
2758 }
2759 
2760 static int opt_target(void *optctx, const char *opt, const char *arg)
2761 {
2762  OptionsContext *o = optctx;
2763  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2764  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2765 
2766  if (!strncmp(arg, "pal-", 4)) {
2767  norm = PAL;
2768  arg += 4;
2769  } else if (!strncmp(arg, "ntsc-", 5)) {
2770  norm = NTSC;
2771  arg += 5;
2772  } else if (!strncmp(arg, "film-", 5)) {
2773  norm = FILM;
2774  arg += 5;
2775  } else {
2776  /* Try to determine PAL/NTSC by peeking in the input files */
2777  if (nb_input_files) {
2778  int i, j, fr;
2779  for (j = 0; j < nb_input_files; j++) {
2780  for (i = 0; i < input_files[j]->nb_streams; i++) {
2781  AVStream *st = input_files[j]->ctx->streams[i];
2783  continue;
2784  fr = st->time_base.den * 1000 / st->time_base.num;
2785  if (fr == 25000) {
2786  norm = PAL;
2787  break;
2788  } else if ((fr == 29970) || (fr == 23976)) {
2789  norm = NTSC;
2790  break;
2791  }
2792  }
2793  if (norm != UNKNOWN)
2794  break;
2795  }
2796  }
2797  if (norm != UNKNOWN)
2798  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2799  }
2800 
2801  if (norm == UNKNOWN) {
2802  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2803  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2804  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2805  exit_program(1);
2806  }
2807 
2808  if (!strcmp(arg, "vcd")) {
2809  opt_video_codec(o, "c:v", "mpeg1video");
2810  opt_audio_codec(o, "c:a", "mp2");
2811  parse_option(o, "f", "vcd", options);
2812 
2813  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2814  parse_option(o, "r", frame_rates[norm], options);
2815  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2816 
2817  opt_default(NULL, "b:v", "1150000");
2818  opt_default(NULL, "maxrate:v", "1150000");
2819  opt_default(NULL, "minrate:v", "1150000");
2820  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2821 
2822  opt_default(NULL, "b:a", "224000");
2823  parse_option(o, "ar", "44100", options);
2824  parse_option(o, "ac", "2", options);
2825 
2826  opt_default(NULL, "packetsize", "2324");
2827  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2828 
2829  /* We have to offset the PTS, so that it is consistent with the SCR.
2830  SCR starts at 36000, but the first two packs contain only padding
2831  and the first pack from the other stream, respectively, may also have
2832  been written before.
2833  So the real data starts at SCR 36000+3*1200. */
2834  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2835  } else if (!strcmp(arg, "svcd")) {
2836 
2837  opt_video_codec(o, "c:v", "mpeg2video");
2838  opt_audio_codec(o, "c:a", "mp2");
2839  parse_option(o, "f", "svcd", options);
2840 
2841  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2842  parse_option(o, "r", frame_rates[norm], options);
2843  parse_option(o, "pix_fmt", "yuv420p", options);
2844  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2845 
2846  opt_default(NULL, "b:v", "2040000");
2847  opt_default(NULL, "maxrate:v", "2516000");
2848  opt_default(NULL, "minrate:v", "0"); // 1145000;
2849  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2850  opt_default(NULL, "scan_offset", "1");
2851 
2852  opt_default(NULL, "b:a", "224000");
2853  parse_option(o, "ar", "44100", options);
2854 
2855  opt_default(NULL, "packetsize", "2324");
2856 
2857  } else if (!strcmp(arg, "dvd")) {
2858 
2859  opt_video_codec(o, "c:v", "mpeg2video");
2860  opt_audio_codec(o, "c:a", "ac3");
2861  parse_option(o, "f", "dvd", options);
2862 
2863  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2864  parse_option(o, "r", frame_rates[norm], options);
2865  parse_option(o, "pix_fmt", "yuv420p", options);
2866  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2867 
2868  opt_default(NULL, "b:v", "6000000");
2869  opt_default(NULL, "maxrate:v", "9000000");
2870  opt_default(NULL, "minrate:v", "0"); // 1500000;
2871  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2872 
2873  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2874  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2875 
2876  opt_default(NULL, "b:a", "448000");
2877  parse_option(o, "ar", "48000", options);
2878 
2879  } else if (!strncmp(arg, "dv", 2)) {
2880 
2881  parse_option(o, "f", "dv", options);
2882 
2883  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2884  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2885  norm == PAL ? "yuv420p" : "yuv411p", options);
2886  parse_option(o, "r", frame_rates[norm], options);
2887 
2888  parse_option(o, "ar", "48000", options);
2889  parse_option(o, "ac", "2", options);
2890 
2891  } else {
2892  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2893  return AVERROR(EINVAL);
2894  }
2895 
2898 
2899  return 0;
2900 }
2901 
2902 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2903 {
2905  vstats_filename = av_strdup (arg);
2906  return 0;
2907 }
2908 
2909 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2910 {
2911  char filename[40];
2912  time_t today2 = time(NULL);
2913  struct tm *today = localtime(&today2);
2914 
2915  if (!today) { // maybe tomorrow
2916  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2917  exit_program(1);
2918  }
2919 
2920  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2921  today->tm_sec);
2922  return opt_vstats_file(NULL, opt, filename);
2923 }
2924 
2925 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2926 {
2927  OptionsContext *o = optctx;
2928  return parse_option(o, "frames:v", arg, options);
2929 }
2930 
2931 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2932 {
2933  OptionsContext *o = optctx;
2934  return parse_option(o, "frames:a", arg, options);
2935 }
2936 
2937 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2938 {
2939  OptionsContext *o = optctx;
2940  return parse_option(o, "frames:d", arg, options);
2941 }
2942 
2943 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2944 {
2945  int ret;
2946  AVDictionary *cbak = codec_opts;
2947  AVDictionary *fbak = format_opts;
2948  codec_opts = NULL;
2949  format_opts = NULL;
2950 
2951  ret = opt_default(NULL, opt, arg);
2952 
2953  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2957  codec_opts = cbak;
2958  format_opts = fbak;
2959 
2960  return ret;
2961 }
2962 
2963 static int opt_preset(void *optctx, const char *opt, const char *arg)
2964 {
2965  OptionsContext *o = optctx;
2966  FILE *f=NULL;
2967  char filename[1000], line[1000], tmp_line[1000];
2968  const char *codec_name = NULL;
2969 
2970  tmp_line[0] = *opt;
2971  tmp_line[1] = 0;
2972  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2973 
2974  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2975  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2976  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2977  }else
2978  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2979  exit_program(1);
2980  }
2981 
2982  while (fgets(line, sizeof(line), f)) {
2983  char *key = tmp_line, *value, *endptr;
2984 
2985  if (strcspn(line, "#\n\r") == 0)
2986  continue;
2987  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2988  if (!av_strtok(key, "=", &value) ||
2989  !av_strtok(value, "\r\n", &endptr)) {
2990  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2991  exit_program(1);
2992  }
2993  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2994 
2995  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2996  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2997  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2998  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2999  else if (opt_default_new(o, key, value) < 0) {
3000  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3001  filename, line, key, value);
3002  exit_program(1);
3003  }
3004  }
3005 
3006  fclose(f);
3007 
3008  return 0;
3009 }
3010 
3011 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3012 {
3013  OptionsContext *o = optctx;
3014  char *s = av_asprintf("%s:%c", opt + 1, *opt);
3015  int ret = parse_option(o, s, arg, options);
3016  av_free(s);
3017  return ret;
3018 }
3019 
3020 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3021 {
3022  OptionsContext *o = optctx;
3023 
3024  if(!strcmp(opt, "ab")){
3025  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3026  return 0;
3027  } else if(!strcmp(opt, "b")){
3028  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3029  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3030  return 0;
3031  }
3032  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3033  return 0;
3034 }
3035 
3036 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3037 {
3038  OptionsContext *o = optctx;
3039  char *s;
3040  int ret;
3041  if(!strcmp(opt, "qscale")){
3042  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3043  return parse_option(o, "q:v", arg, options);
3044  }
3045  s = av_asprintf("q%s", opt + 6);
3046  ret = parse_option(o, s, arg, options);
3047  av_free(s);
3048  return ret;
3049 }
3050 
3051 static int opt_profile(void *optctx, const char *opt, const char *arg)
3052 {
3053  OptionsContext *o = optctx;
3054  if(!strcmp(opt, "profile")){
3055  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3056  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3057  return 0;
3058  }
3059  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3060  return 0;
3061 }
3062 
3063 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3064 {
3065  OptionsContext *o = optctx;
3066  return parse_option(o, "filter:v", arg, options);
3067 }
3068 
3069 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3070 {
3071  OptionsContext *o = optctx;
3072  return parse_option(o, "filter:a", arg, options);
3073 }
3074 
3075 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3076 {
3077  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3078  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3079  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3080  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3081 
3084  return 0;
3085 }
3086 
3087 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3088 {
3089  OptionsContext *o = optctx;
3090  char *tcr = av_asprintf("timecode=%s", arg);
3091  int ret = parse_option(o, "metadata:g", tcr, options);
3092  if (ret >= 0)
3093  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3094  av_free(tcr);
3095  return ret;
3096 }
3097 
3098 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3099 {
3100  OptionsContext *o = optctx;
3101  char layout_str[32];
3102  char *stream_str;
3103  char *ac_str;
3104  int ret, channels, ac_str_size;
3105  uint64_t layout;
3106 
3107  layout = av_get_channel_layout(arg);
3108  if (!layout) {
3109  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3110  return AVERROR(EINVAL);
3111  }
3112  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3113  ret = opt_default_new(o, opt, layout_str);
3114  if (ret < 0)
3115  return ret;
3116 
3117  /* set 'ac' option based on channel layout */
3118  channels = av_get_channel_layout_nb_channels(layout);
3119  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3120  stream_str = strchr(opt, ':');
3121  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3122  ac_str = av_mallocz(ac_str_size);
3123  if (!ac_str)
3124  return AVERROR(ENOMEM);
3125  av_strlcpy(ac_str, "ac", 3);
3126  if (stream_str)
3127  av_strlcat(ac_str, stream_str, ac_str_size);
3128  ret = parse_option(o, ac_str, layout_str, options);
3129  av_free(ac_str);
3130 
3131  return ret;
3132 }
3133 
3134 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3135 {
3136  OptionsContext *o = optctx;
3137  return parse_option(o, "q:a", arg, options);
3138 }
3139 
3140 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3141 {
3143  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3144  return AVERROR(ENOMEM);
3147  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3148  return AVERROR(ENOMEM);
3149 
3151 
3152  return 0;
3153 }
3154 
3155 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3156 {
3157  uint8_t *graph_desc = read_file(arg);
3158  if (!graph_desc)
3159  return AVERROR(EINVAL);
3160 
3162  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3163  return AVERROR(ENOMEM);
3165  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3166 
3168 
3169  return 0;
3170 }
3171 
3172 void show_help_default(const char *opt, const char *arg)
3173 {
3174  /* per-file options have at least one of those set */
3175  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3176  int show_advanced = 0, show_avoptions = 0;
3177 
3178  if (opt && *opt) {
3179  if (!strcmp(opt, "long"))
3180  show_advanced = 1;
3181  else if (!strcmp(opt, "full"))
3182  show_advanced = show_avoptions = 1;
3183  else
3184  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3185  }
3186 
3187  show_usage();
3188 
3189  printf("Getting help:\n"
3190  " -h -- print basic options\n"
3191  " -h long -- print more options\n"
3192  " -h full -- print all options (including all format and codec specific options, very long)\n"
3193  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3194  " See man %s for detailed description of the options.\n"
3195  "\n", program_name);
3196 
3197  show_help_options(options, "Print help / information / capabilities:",
3198  OPT_EXIT, 0, 0);
3199 
3200  show_help_options(options, "Global options (affect whole program "
3201  "instead of just one file:",
3202  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3203  if (show_advanced)
3204  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3205  per_file | OPT_EXIT, 0);
3206 
3207  show_help_options(options, "Per-file main options:", 0,
3209  OPT_EXIT, per_file);
3210  if (show_advanced)
3211  show_help_options(options, "Advanced per-file options:",
3212  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3213 
3214  show_help_options(options, "Video options:",
3216  if (show_advanced)
3217  show_help_options(options, "Advanced Video options:",
3219 
3220  show_help_options(options, "Audio options:",
3222  if (show_advanced)
3223  show_help_options(options, "Advanced Audio options:",
3225  show_help_options(options, "Subtitle options:",
3226  OPT_SUBTITLE, 0, 0);
3227  printf("\n");
3228 
3229  if (show_avoptions) {
3233 #if CONFIG_SWSCALE
3235 #endif
3238  }
3239 }
3240 
3241 void show_usage(void)
3242 {
3243  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3244  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3245  av_log(NULL, AV_LOG_INFO, "\n");
3246 }
3247 
3248 enum OptGroup {
3251 };
3252 
3253 static const OptionGroupDef groups[] = {
3254  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3255  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3256 };
3257 
3258 static int open_files(OptionGroupList *l, const char *inout,
3259  int (*open_file)(OptionsContext*, const char*))
3260 {
3261  int i, ret;
3262 
3263  for (i = 0; i < l->nb_groups; i++) {
3264  OptionGroup *g = &l->groups[i];
3265  OptionsContext o;
3266 
3267  init_options(&o);
3268  o.g = g;
3269 
3270  ret = parse_optgroup(&o, g);
3271  if (ret < 0) {
3272  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3273  "%s.\n", inout, g->arg);
3274  return ret;
3275  }
3276 
3277  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3278  ret = open_file(&o, g->arg);
3279  uninit_options(&o);
3280  if (ret < 0) {
3281  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3282  inout, g->arg);
3283  return ret;
3284  }
3285  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3286  }
3287 
3288  return 0;
3289 }
3290 
3291 int ffmpeg_parse_options(int argc, char **argv)
3292 {
3293  OptionParseContext octx;
3294  uint8_t error[128];
3295  int ret;
3296 
3297  memset(&octx, 0, sizeof(octx));
3298 
3299  /* split the commandline into an internal representation */
3300  ret = split_commandline(&octx, argc, argv, options, groups,
3301  FF_ARRAY_ELEMS(groups));
3302  if (ret < 0) {
3303  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3304  goto fail;
3305  }
3306 
3307  /* apply global options */
3308  ret = parse_optgroup(NULL, &octx.global_opts);
3309  if (ret < 0) {
3310  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3311  goto fail;
3312  }
3313 
3314  /* configure terminal and setup signal handlers */
3315  term_init();
3316 
3317  /* open input files */
3318  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3319  if (ret < 0) {
3320  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3321  goto fail;
3322  }
3323 
3324  /* create the complex filtergraphs */
3325  ret = init_complex_filters();
3326  if (ret < 0) {
3327  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3328  goto fail;
3329  }
3330 
3331  /* open output files */
3332  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3333  if (ret < 0) {
3334  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3335  goto fail;
3336  }
3337 
3339 
3340 fail:
3341  uninit_parse_context(&octx);
3342  if (ret < 0) {
3343  av_strerror(ret, error, sizeof(error));
3344  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3345  }
3346  return ret;
3347 }
3348 
3349 static int opt_progress(void *optctx, const char *opt, const char *arg)
3350 {
3351  AVIOContext *avio = NULL;
3352  int ret;
3353 
3354  if (!strcmp(arg, "-"))
3355  arg = "pipe:";
3356  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3357  if (ret < 0) {
3358  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3359  arg, av_err2str(ret));
3360  return ret;
3361  }
3362  progress_avio = avio;
3363  return 0;
3364 }
3365 
3366 #define OFFSET(x) offsetof(OptionsContext, x)
3367 const OptionDef options[] = {
3368  /* main options */
3370  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3371  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3372  "force format", "fmt" },
3373  { "y", OPT_BOOL, { &file_overwrite },
3374  "overwrite output files" },
3375  { "n", OPT_BOOL, { &no_file_overwrite },
3376  "never overwrite output files" },
3377  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3378  "Ignore unknown stream types" },
3379  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3380  "Copy unknown stream types" },
3381  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3382  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3383  "codec name", "codec" },
3384  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3385  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3386  "codec name", "codec" },
3387  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3388  OPT_OUTPUT, { .off = OFFSET(presets) },
3389  "preset name", "preset" },
3390  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3391  OPT_OUTPUT, { .func_arg = opt_map },
3392  "set input stream mapping",
3393  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3394  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3395  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3396  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3397  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3398  "set metadata information of outfile from infile",
3399  "outfile[,metadata]:infile[,metadata]" },
3400  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3401  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3402  "set chapters mapping", "input_file_index" },
3403  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3404  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3405  "record or transcode \"duration\" seconds of audio/video",
3406  "duration" },
3407  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3408  "record or transcode stop time", "time_stop" },
3409  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3410  "set the limit file size in bytes", "limit_size" },
3411  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3412  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3413  "set the start time offset", "time_off" },
3414  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3415  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3416  "set the start time offset relative to EOF", "time_off" },
3417  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3418  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3419  "enable/disable seeking by timestamp with -ss" },
3420  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3421  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3422  "enable/disable accurate seeking with -ss" },
3423  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3424  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3425  "set the input ts offset", "time_off" },
3426  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3427  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3428  "set the input ts scale", "scale" },
3429  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3430  "set the recording timestamp ('now' to set the current time)", "time" },
3431  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3432  "add metadata", "string=string" },
3433  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3434  "add program with specified streams", "title=string:st=number..." },
3435  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3436  OPT_OUTPUT, { .func_arg = opt_data_frames },
3437  "set the number of data frames to output", "number" },
3438  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3439  "add timings for benchmarking" },
3440  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3441  "add timings for each task" },
3442  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3443  "write program-readable progress information", "url" },
3444  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3445  "enable or disable interaction on standard input" },
3446  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3447  "set max runtime in seconds", "limit" },
3448  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3449  "dump each input packet" },
3450  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3451  "when dumping packets, also dump the payload" },
3452  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3453  OPT_INPUT, { .off = OFFSET(rate_emu) },
3454  "read input at native frame rate", "" },
3455  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3456  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3457  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3458  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3459  "video sync method", "" },
3460  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3461  "frame drop threshold", "" },
3462  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3463  "audio sync method", "" },
3464  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3465  "audio drift threshold", "threshold" },
3466  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3467  "copy timestamps" },
3468  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3469  "shift input timestamps to start at 0 when using copyts" },
3470  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3471  "copy input stream time base when stream copying", "mode" },
3472  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3473  OPT_OUTPUT, { .off = OFFSET(shortest) },
3474  "finish encoding within shortest input" },
3475  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3476  OPT_OUTPUT, { .off = OFFSET(apad) },
3477  "audio pad", "" },
3478  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3479  "timestamp discontinuity delta threshold", "threshold" },
3480  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3481  "timestamp error delta threshold", "threshold" },
3482  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3483  "exit on error", "error" },
3484  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3485  "abort on the specified condition flags", "flags" },
3486  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3487  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3488  "copy initial non-keyframes" },
3489  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3490  "copy or discard frames before start time" },
3491  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3492  "set the number of frames to output", "number" },
3493  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3494  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3495  "force codec tag/fourcc", "fourcc/tag" },
3496  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3497  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3498  "use fixed quality scale (VBR)", "q" },
3499  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3500  OPT_OUTPUT, { .func_arg = opt_qscale },
3501  "use fixed quality scale (VBR)", "q" },
3502  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3503  "set profile", "profile" },
3504  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3505  "set stream filtergraph", "filter_graph" },
3506  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3507  "number of non-complex filter threads" },
3508  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3509  "read stream filtergraph description from a file", "filename" },
3510  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3511  "reinit filtergraph on input parameter changes", "" },
3512  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3513  "create a complex filtergraph", "graph_description" },
3514  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3515  "number of threads for -filter_complex" },
3516  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3517  "create a complex filtergraph", "graph_description" },
3518  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3519  "read complex filtergraph description from a file", "filename" },
3520  { "stats", OPT_BOOL, { &print_stats },
3521  "print progress report during encoding", },
3522  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3523  OPT_OUTPUT, { .func_arg = opt_attach },
3524  "add an attachment to the output file", "filename" },
3525  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3526  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3527  "extract an attachment into a file", "filename" },
3528  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3529  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3530  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3531  "print timestamp debugging info" },
3532  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3533  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3534  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3535  OPT_INPUT, { .off = OFFSET(discard) },
3536  "discard", "" },
3537  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3538  OPT_OUTPUT, { .off = OFFSET(disposition) },
3539  "disposition", "" },
3540  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3541  { .off = OFFSET(thread_queue_size) },
3542  "set the maximum number of queued packets from the demuxer" },
3543  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3544  "read and decode the streams to fill missing information with heuristics" },
3545 
3546  /* video options */
3547  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3548  "set the number of video frames to output", "number" },
3549  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3550  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3551  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3553  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3554  "set frame size (WxH or abbreviation)", "size" },
3555  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3556  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3557  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3558  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3559  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3560  "set pixel format", "format" },
3561  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3562  "set the number of bits per raw sample", "number" },
3563  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3564  "deprecated use -g 1" },
3566  "disable video" },
3567  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3568  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3569  "rate control override for specific intervals", "override" },
3570  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3571  OPT_OUTPUT, { .func_arg = opt_video_codec },
3572  "force video codec ('copy' to copy stream)", "codec" },
3573  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3574  "Removed" },
3575  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3576  "Removed" },
3577  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3578  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3579  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3580  "select the pass number (1 to 3)", "n" },
3581  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3582  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3583  "select two pass log file name prefix", "prefix" },
3584  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3585  "this option is deprecated, use the yadif filter instead" },
3586  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3587  "calculate PSNR of compressed frames" },
3588  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3589  "dump video coding statistics to file" },
3590  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3591  "dump video coding statistics to file", "file" },
3592  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3593  "Version of the vstats format to use."},
3594  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3595  "set video filters", "filter_graph" },
3596  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3597  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3598  "specify intra matrix coeffs", "matrix" },
3599  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3600  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3601  "specify inter matrix coeffs", "matrix" },
3602  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3603  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3604  "specify intra matrix coeffs", "matrix" },
3605  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3606  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3607  "top=1/bottom=0/auto=-1 field first", "" },
3608  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3609  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3610  "force video tag/fourcc", "fourcc/tag" },
3611  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3612  "show QP histogram" },
3613  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3614  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3615  "force the selected framerate, disable the best supported framerate selection" },
3616  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3617  OPT_OUTPUT, { .func_arg = opt_streamid },
3618  "set the value of an outfile streamid", "streamIndex:value" },
3619  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3620  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3621  "force key frames at specified timestamps", "timestamps" },
3622  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3623  "audio bitrate (please use -b:a)", "bitrate" },
3624  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3625  "video bitrate (please use -b:v)", "bitrate" },
3626  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3627  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3628  "use HW accelerated decoding", "hwaccel name" },
3629  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3630  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3631  "select a device for HW acceleration", "devicename" },
3632  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3633  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3634  "select output format used with HW accelerated decoding", "format" },
3635 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3636  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3637 #endif
3638  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3639  "show available HW acceleration methods" },
3640  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3641  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3642  "automatically insert correct rotate filters" },
3643  { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3644  "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3645 
3646  /* audio options */
3647  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3648  "set the number of audio frames to output", "number" },
3649  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3650  "set audio quality (codec-specific)", "quality", },
3651  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3652  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3653  "set audio sampling rate (in Hz)", "rate" },
3654  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3655  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3656  "set number of audio channels", "channels" },
3658  "disable audio" },
3659  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3660  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3661  "force audio codec ('copy' to copy stream)", "codec" },
3662  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3663  OPT_OUTPUT, { .func_arg = opt_old2new },
3664  "force audio tag/fourcc", "fourcc/tag" },
3665  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3666  "change audio volume (256=normal)" , "volume" },
3667  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3669  "set sample format", "format" },
3670  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3671  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3672  "set channel layout", "layout" },
3673  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3674  "set audio filters", "filter_graph" },
3675  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3676  "set the maximum number of channels to try to guess the channel layout" },
3677 
3678  /* subtitle options */
3680  "disable subtitle" },
3681  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3682  "force subtitle codec ('copy' to copy stream)", "codec" },
3683  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3684  , "force subtitle tag/fourcc", "fourcc/tag" },
3685  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3686  "fix subtitles duration" },
3687  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3688  "set canvas size (WxH or abbreviation)", "size" },
3689 
3690  /* grab options */
3691  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3692  "deprecated, use -channel", "channel" },
3693  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3694  "deprecated, use -standard", "standard" },
3695  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3696 
3697  /* muxer options */
3698  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3699  "set the maximum demux-decode delay", "seconds" },
3700  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3701  "set the initial demux-decode delay", "seconds" },
3702  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3703  "override the options from ffserver", "" },
3704  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3705  "specify a file in which to print sdp information", "file" },
3706 
3707  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3708  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3709  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3710  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3711  "two special values are defined - "
3712  "0 = use frame rate (video) or sample rate (audio),"
3713  "-1 = match source time base", "ratio" },
3714 
3715  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3716  "A comma-separated list of bitstream filters", "bitstream_filters" },
3717  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3718  "deprecated", "audio bitstream_filters" },
3719  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3720  "deprecated", "video bitstream_filters" },
3721 
3722  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723  "set the audio options to the indicated preset", "preset" },
3724  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3725  "set the video options to the indicated preset", "preset" },
3726  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3727  "set the subtitle options to the indicated preset", "preset" },
3728  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3729  "set options from indicated preset file", "filename" },
3730 
3731  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3732  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3733 
3734  /* data codec support */
3735  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3736  "force data codec ('copy' to copy stream)", "codec" },
3737  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3738  "disable data" },
3739 
3740 #if CONFIG_VAAPI
3741  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3742  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3743 #endif
3744 
3745 #if CONFIG_QSV
3746  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3747  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3748 #endif
3749 
3750  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3751  "initialise hardware device", "args" },
3752  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3753  "set hardware device used when filtering", "device" },
3754 
3755  { NULL, },
3756 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1556
int nb_bitstream_filters
Definition: ffmpeg.h:469
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:54
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:1076
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:413
AVRational enc_timebase
Definition: ffmpeg.h:467
char * vstats_filename
Definition: ffmpeg_opt.c:107
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:45
int nb_dump_attachment
Definition: ffmpeg.h:135
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2102
void show_usage(void)
Definition: ffmpeg_opt.c:3241
int nb_metadata
Definition: ffmpeg.h:175
int nb_streamid_map
Definition: ffmpeg.h:172
#define NULL
Definition: coverity.c:32
int width
Definition: ffmpeg.h:277
AVRational framerate
Definition: avcodec.h:3451
const char const char void * val
Definition: avisynth_c.h:771
int audio_sync_method
Definition: ffmpeg_opt.c:115
AVDictionary * resample_opts
Definition: cmdutils.h:337
int keep_pix_fmt
Definition: ffmpeg.h:534
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:161
float mux_preload
Definition: ffmpeg.h:161
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:521
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5967
#define OPT_EXPERT
Definition: cmdutils.h:168
int start_at_zero
Definition: ffmpeg_opt.c:124
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:567
void term_init(void)
Definition: ffmpeg.c:373
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
int nb_outputs
Definition: ffmpeg.h:299
int copy_tb
Definition: ffmpeg_opt.c:125
char * qsv_device
Definition: ffmpeg_qsv.c:31
AVDictionary * swr_opts
Definition: ffmpeg.h:515
int qp_hist
Definition: ffmpeg_opt.c:130
AVDictionary * swr_opts
Definition: cmdutils.h:339
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *avctx, AVCodec *codec, enum AVPixelFormat target)
Definition: ffmpeg_filter.c:63
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
void term_exit(void)
Definition: ffmpeg.c:315
int stream_copy
Definition: ffmpeg.h:520
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1256
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2937
int do_benchmark
Definition: ffmpeg_opt.c:119
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1605
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1342
AVOption.
Definition: opt.h:246
AVRational frame_rate
Definition: ffmpeg.h:484
int audio_channels
Definition: rtp.c:40
int64_t start_time_eof
Definition: ffmpeg.h:108
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:148
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c:2037
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:510
static AVInputFormat * file_iformat
Definition: ffplay.c:310
#define OPT_VIDEO
Definition: cmdutils.h:170
int data_disable
Definition: ffmpeg.h:168
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1956
float mux_max_delay
Definition: ffmpeg.h:162
int accurate_seek
Definition: ffmpeg.h:420
int * streamid_map
Definition: ffmpeg.h:171
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int video_sync_method
Definition: ffmpeg_opt.c:116
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:147
static void assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:904
int ostream_idx
Definition: ffmpeg.h:100
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:79
static int input_sync
Definition: ffmpeg_opt.c:143
const char * g
Definition: vf_curves.c:112
const char * desc
Definition: nvenc.c:60
hardware decoding through Videotoolbox
Definition: pixfmt.h:296
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:752
AVRational framerate
Definition: ffmpeg.h:340
void choose_sample_fmt(AVStream *st, AVCodec *codec)
Definition: ffmpeg_filter.c:92
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
enum AVCodecID video_codec
default video codec
Definition: avformat.h:535
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1994
#define OPT_AUDIO
Definition: cmdutils.h:171
int64_t max_pts
Definition: ffmpeg.h:329
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:154
AVFilterInOut * out_tmp
Definition: ffmpeg.h:273
int decoding_needed
Definition: ffmpeg.h:307
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4143
int qscale
Definition: avcodec.h:852
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:959
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:281
int rotate_overridden
Definition: ffmpeg.h:488
int index
stream index in AVFormatContext
Definition: avformat.h:890
int max_muxing_queue_size
Definition: ffmpeg.h:551
int nb_frame_pix_fmts
Definition: ffmpeg.h:123
#define AVIO_FLAG_READ
read-only
Definition: avio.h:660
int do_deinterlace
Definition: ffmpeg_opt.c:118
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3069
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1872
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:661
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
Definition: ffmpeg_opt.c:1986
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:2165
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:767
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1982
Convenience header that includes libavutil's core.
const char * arg
Definition: cmdutils.h:330
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3140
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
int cuvid_init(AVCodecContext *s)
Definition: ffmpeg_cuvid.c:30
#define OPT_DATA
Definition: cmdutils.h:177
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2931
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1943
enum AVMediaType type
Definition: avcodec.h:3743
int nb_program
Definition: ffmpeg.h:235
static int file_overwrite
Definition: ffmpeg_opt.c:140
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1292
discard all
Definition: avcodec.h:830
static int find_stream_info
Definition: ffmpeg_opt.c:148
int64_t input_ts_offset
Definition: ffmpeg.h:409
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3155
int nb_input_streams
Definition: ffmpeg.c:145
static int audio_disable
Definition: ffplay.c:317
const char * name
Definition: ffmpeg.h:75
AVDictionary * metadata
Definition: avformat.h:1310
static const char * audio_codec_name
Definition: ffplay.c:340
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1257
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5920
#define OPT_DOUBLE
Definition: cmdutils.h:185
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1525
#define OPT_FLOAT
Definition: cmdutils.h:173
AVCodec.
Definition: avcodec.h:3730
#define VSYNC_VFR
Definition: ffmpeg.h:55
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1313
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:231
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:2002
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4135
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:568
void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c)
int index
Definition: ffmpeg.h:290
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2963
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:470
Definition: ftp.c:34
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:122
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:283
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:46
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:726
int encoding_needed
Definition: ffmpeg.h:454
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3134
Format I/O context.
Definition: avformat.h:1349
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:295
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:478
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:81
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1492
enum HWAccelID id
Definition: ffmpeg.h:77
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val)
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:142
const char * name
Definition: opt.h:247
char * logfile_prefix
Definition: ffmpeg.h:505
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1463
int user_set_discard
Definition: ffmpeg.h:306
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:146
static int64_t start_time
Definition: ffplay.c:327
int copy_initial_nonkeyframes
Definition: ffmpeg.h:530
int filter_nbthreads
Definition: ffmpeg_opt.c:134
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2524
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:543
uint8_t
static int nb_streams
Definition: ffprobe.c:276
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:514
Opaque data information usually continuous.
Definition: avutil.h:203
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:544
#define OPT_OUTPUT
Definition: cmdutils.h:187
int width
Video only.
Definition: avcodec.h:4209
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:678
#define HAS_ARG
Definition: cmdutils.h:166
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2258
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:965
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3253
FILE * logfile
Definition: ffmpeg.h:506
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:478
AVDictionary * opts
Definition: ffmpeg.h:565
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:3549
int id
unique ID to identify the chapter
Definition: avformat.h:1307
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3075
int id
Format-specific stream ID.
Definition: avformat.h:896
#define OPT_OFFSET
Definition: cmdutils.h:180
int vstats_version
Definition: ffmpeg_opt.c:136
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4369
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)
Definition: cfhd.c:80
int nb_max_frames
Definition: ffmpeg.h:177
int shortest
Definition: ffmpeg.h:571
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2909
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2354
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
void av_codec_set_lowres(AVCodecContext *avctx, int val)
int channel_idx
Definition: ffmpeg.h:99
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:689
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int nb_streams
Definition: ffmpeg.h:416
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1460
int sync_file_index
Definition: ffmpeg.h:93
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4468
AVDictionary * resample_opts
Definition: ffmpeg.h:516
int seek_timestamp
Definition: ffmpeg.h:109
static int flags
Definition: log.c:57
list ifile
Definition: normalize.py:6
uint32_t tag
Definition: movenc.c:1407
int * formats
Definition: ffmpeg.h:284
#define OPT_SPEC
Definition: cmdutils.h:181
int nb_input_files
Definition: ffmpeg.c:147
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:168
int init_complex_filtergraph(FilterGraph *fg)
int print_stats
Definition: ffmpeg_opt.c:129
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:176
AVCodec * dec
Definition: ffmpeg.h:312
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:216
const OptionDef options[]
Definition: ffmpeg_opt.c:3367
int top_field_first
Definition: ffmpeg.h:341
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1477
int nb_output_streams
Definition: ffmpeg.c:150
int file_index
Definition: ffmpeg.h:303
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:184
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1513
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:326
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:271
float quality_factor
Definition: avcodec.h:853
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3036
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1368
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2059
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: utils.c:1261
AVDictionary * format_opts
Definition: cmdutils.c:72
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1893
int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:148
#define OPT_SUBTITLE
Definition: cmdutils.h:174
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:555
uint64_t channel_layout
Definition: ffmpeg.h:281
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:135
enum AVCodecID id
Definition: avcodec.h:3744
int rate_emu
Definition: ffmpeg.h:419
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:214
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3051
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1567
void check_filter_outputs(void)
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:381
FilterGraph ** filtergraphs
Definition: ffmpeg.c:154
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:464
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:3258
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:277
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:293
int64_t start_time
Definition: ffmpeg.h:107
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:253
int loop
Definition: ffmpeg.h:405
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:464
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:659
void av_format_set_data_codec(AVFormatContext *s, AVCodec *c)
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1112
int video_delay
Video only.
Definition: avcodec.h:4238
static int autorotate
Definition: ffplay.c:351
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1506
AudioChannelMap * audio_channel_maps
Definition: ffmpeg.h:148
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int debug_ts
Definition: ffmpeg_opt.c:126
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4139
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1849
const char * name
Definition: cmdutils.h:164
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3020
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:349
AVChapter ** chapters
Definition: avformat.h:1557
Definition: graph2dot.c:48
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
Definition: ffmpeg_opt.c:542
simple assert() macros that are a bit more flexible than ISO C assert().
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
const char * name
Name of the codec implementation.
Definition: avcodec.h:3737
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3011
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:622
int video_disable
Definition: ffmpeg.h:165
static int opt_sameq(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:244
HW acceleration through VDA, data[3] contains a CVPixelBufferRef.
Definition: pixfmt.h:224
int flags
Definition: cmdutils.h:165
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: ffmpeg_opt.c:569
int force_fps
Definition: ffmpeg.h:486
GLsizei count
Definition: opengl_enc.c:109