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