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