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