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