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