FFmpeg
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "config.h"
22 
23 #include <stdint.h>
24 
25 #if HAVE_SYS_RESOURCE_H
26 #include <sys/time.h>
27 #include <sys/resource.h>
28 #endif
29 
30 #include "ffmpeg.h"
31 #include "ffmpeg_sched.h"
32 #include "cmdutils.h"
33 #include "opt_common.h"
34 
35 #include "libavformat/avformat.h"
36 
37 #include "libavcodec/avcodec.h"
38 #include "libavcodec/bsf.h"
39 
40 #include "libavfilter/avfilter.h"
41 
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/avutil.h"
45 #include "libavutil/mathematics.h"
46 #include "libavutil/mem.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/stereo3d.h"
50 
52 
54 
57 float dts_error_threshold = 3600*30;
58 
59 #if FFMPEG_OPT_VSYNC
61 #endif
63 int do_benchmark = 0;
65 int do_hex_dump = 0;
66 int do_pkt_dump = 0;
67 int copy_ts = 0;
68 int start_at_zero = 0;
69 int copy_tb = -1;
70 int debug_ts = 0;
71 int exit_on_error = 0;
73 int print_stats = -1;
75 float max_error_rate = 2.0/3;
81 
82 
83 static int file_overwrite = 0;
84 static int no_file_overwrite = 0;
87 int recast_media = 0;
88 
89 // this struct is passed as the optctx argument
90 // to func_arg() for global options
91 typedef struct GlobalOptionsContext {
93 
94  char **filtergraphs;
97 
99 {
100  /* all OPT_SPEC and OPT_TYPE_STRING can be freed in generic way */
101  for (const OptionDef *po = options; po->name; po++) {
102  void *dst;
103 
104  if (!(po->flags & OPT_FLAG_OFFSET))
105  continue;
106 
107  dst = (uint8_t*)o + po->u.off;
108  if (po->flags & OPT_FLAG_SPEC) {
109  SpecifierOptList *so = dst;
110  for (int i = 0; i < so->nb_opt; i++) {
111  av_freep(&so->opt[i].specifier);
112  if (po->flags & OPT_FLAG_PERSTREAM)
114  if (po->type == OPT_TYPE_STRING)
115  av_freep(&so->opt[i].u.str);
116  }
117  av_freep(&so->opt);
118  so->nb_opt = 0;
119  } else if (po->type == OPT_TYPE_STRING)
120  av_freep(dst);
121  }
122 
123  for (int i = 0; i < o->nb_stream_maps; i++)
125  av_freep(&o->stream_maps);
126 
127  for (int i = 0; i < o->nb_attachments; i++)
128  av_freep(&o->attachments[i]);
129  av_freep(&o->attachments);
130 
131  av_dict_free(&o->streamid);
132 }
133 
135 {
136  memset(o, 0, sizeof(*o));
137 
138  o->stop_time = INT64_MAX;
139  o->mux_max_delay = 0.7;
142  o->recording_time = INT64_MAX;
143  o->limit_filesize = INT64_MAX;
144  o->chapters_input_file = INT_MAX;
145  o->accurate_seek = 1;
146  o->thread_queue_size = 0;
147  o->input_sync_ref = -1;
148  o->find_stream_info = 1;
149  o->shortest_buf_duration = 10.f;
150 }
151 
152 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
153 {
155 
156  printf("Hardware acceleration methods:\n");
157  while ((type = av_hwdevice_iterate_types(type)) !=
160  printf("\n");
161  return 0;
162 }
163 
165  char mediatype)
166 {
167  av_assert0(!sol->nb_opt || sol->type == OPT_TYPE_STRING);
168 
169  for (int i = 0; i < sol->nb_opt; i++) {
170  const char *spec = sol->opt[i].specifier;
171  if (spec[0] == mediatype && !spec[1])
172  return sol->opt[i].u.str;
173  }
174  return NULL;
175 }
176 
177 static unsigned opt_match_per_stream(void *logctx, enum OptionType type,
178  const SpecifierOptList *sol,
180 {
181  int matches = 0, match_idx = -1;
182 
183  av_assert0((type == sol->type) || !sol->nb_opt);
184 
185  for (int i = 0; i < sol->nb_opt; i++) {
186  const StreamSpecifier *ss = &sol->opt[i].stream_spec;
187 
188  if (stream_specifier_match(ss, fc, st, logctx)) {
189  match_idx = i;
190  matches++;
191  }
192  }
193 
194  if (matches > 1 && sol->opt_canon) {
195  const SpecifierOpt *so = &sol->opt[match_idx];
196  const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";
197 
198  char namestr[128] = "";
199  char optval_buf[32];
200  const char *optval = optval_buf;
201 
202  snprintf(namestr, sizeof(namestr), "-%s", sol->opt_canon->name);
203  if (sol->opt_canon->flags & OPT_HAS_ALT) {
204  const char * const *names_alt = sol->opt_canon->u1.names_alt;
205  for (int i = 0; names_alt[i]; i++)
206  av_strlcatf(namestr, sizeof(namestr), "/-%s", names_alt[i]);
207  }
208 
209  switch (sol->type) {
210  case OPT_TYPE_STRING: optval = so->u.str; break;
211  case OPT_TYPE_INT: snprintf(optval_buf, sizeof(optval_buf), "%d", so->u.i); break;
212  case OPT_TYPE_INT64: snprintf(optval_buf, sizeof(optval_buf), "%"PRId64, so->u.i64); break;
213  case OPT_TYPE_FLOAT: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.f); break;
214  case OPT_TYPE_DOUBLE: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.dbl); break;
215  default: av_assert0(0);
216  }
217 
218  av_log(logctx, AV_LOG_WARNING, "Multiple %s options specified for "
219  "stream %d, only the last option '-%s%s%s %s' will be used.\n",
220  namestr, st->index, sol->opt_canon->name, spec[0] ? ":" : "",
221  spec, optval);
222  }
223 
224  return match_idx + 1;
225 }
226 
227 #define OPT_MATCH_PER_STREAM(name, type, opt_type, m) \
228 void opt_match_per_stream_ ## name(void *logctx, const SpecifierOptList *sol, \
229  AVFormatContext *fc, AVStream *st, type *out) \
230 { \
231  unsigned ret = opt_match_per_stream(logctx, opt_type, sol, fc, st); \
232  if (ret > 0) \
233  *out = sol->opt[ret - 1].u.m; \
234 }
235 
236 OPT_MATCH_PER_STREAM(str, const char *, OPT_TYPE_STRING, str);
239 OPT_MATCH_PER_STREAM(dbl, double, OPT_TYPE_DOUBLE, dbl);
240 
241 int view_specifier_parse(const char **pspec, ViewSpecifier *vs)
242 {
243  const char *spec = *pspec;
244  char *endptr;
245 
247 
248  if (!strncmp(spec, "view:", 5)) {
249  spec += 5;
250 
251  if (!strncmp(spec, "all", 3)) {
252  spec += 3;
254  } else {
256  vs->val = strtoul(spec, &endptr, 0);
257  if (endptr == spec) {
258  av_log(NULL, AV_LOG_ERROR, "Invalid view ID: %s\n", spec);
259  return AVERROR(EINVAL);
260  }
261  spec = endptr;
262  }
263  } else if (!strncmp(spec, "vidx:", 5)) {
264  spec += 5;
266  vs->val = strtoul(spec, &endptr, 0);
267  if (endptr == spec) {
268  av_log(NULL, AV_LOG_ERROR, "Invalid view index: %s\n", spec);
269  return AVERROR(EINVAL);
270  }
271  spec = endptr;
272  } else if (!strncmp(spec, "vpos:", 5)) {
273  spec += 5;
275 
276  if (!strncmp(spec, "left", 4) && !cmdutils_isalnum(spec[4])) {
277  spec += 4;
279  } else if (!strncmp(spec, "right", 5) && !cmdutils_isalnum(spec[5])) {
280  spec += 5;
282  } else {
283  av_log(NULL, AV_LOG_ERROR, "Invalid view position: %s\n", spec);
284  return AVERROR(EINVAL);
285  }
286  } else
287  return 0;
288 
289  *pspec = spec;
290 
291  return 0;
292 }
293 
294 int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
295 {
296  if (!av_strcasecmp(arg, "cfr")) *vsync_var = VSYNC_CFR;
297  else if (!av_strcasecmp(arg, "vfr")) *vsync_var = VSYNC_VFR;
298  else if (!av_strcasecmp(arg, "passthrough")) *vsync_var = VSYNC_PASSTHROUGH;
299 #if FFMPEG_OPT_VSYNC_DROP
300  else if (!av_strcasecmp(arg, "drop")) {
301  av_log(NULL, AV_LOG_WARNING, "-vsync/fps_mode drop is deprecated\n");
302  *vsync_var = VSYNC_DROP;
303  }
304 #endif
305  else if (!is_global && !av_strcasecmp(arg, "auto")) *vsync_var = VSYNC_AUTO;
306  else if (!is_global) {
307  av_log(NULL, AV_LOG_FATAL, "Invalid value %s specified for fps_mode of #%d:%d.\n", arg, file_idx, st_idx);
308  return AVERROR(EINVAL);
309  }
310 
311 #if FFMPEG_OPT_VSYNC
312  if (is_global && *vsync_var == VSYNC_AUTO) {
313  int ret;
314  double num;
315 
316  ret = parse_number("vsync", arg, OPT_TYPE_INT, VSYNC_AUTO, VSYNC_VFR, &num);
317  if (ret < 0)
318  return ret;
319 
320  video_sync_method = num;
321  av_log(NULL, AV_LOG_WARNING, "Passing a number to -vsync is deprecated,"
322  " use a string argument as described in the manual.\n");
323  }
324 #endif
325 
326  return 0;
327 }
328 
329 /* Correct input file start times based on enabled streams */
330 static void correct_input_start_times(void)
331 {
332  for (int i = 0; i < nb_input_files; i++) {
333  InputFile *ifile = input_files[i];
334  AVFormatContext *is = ifile->ctx;
335  int64_t new_start_time = INT64_MAX, diff, abs_start_seek;
336 
337  ifile->start_time_effective = is->start_time;
338 
339  if (is->start_time == AV_NOPTS_VALUE ||
340  !(is->iformat->flags & AVFMT_TS_DISCONT))
341  continue;
342 
343  for (int j = 0; j < is->nb_streams; j++) {
344  AVStream *st = is->streams[j];
345  if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
346  continue;
347  new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
348  }
349 
350  diff = new_start_time - is->start_time;
351  if (diff) {
352  av_log(NULL, AV_LOG_VERBOSE, "Correcting start time of Input #%d by %"PRId64" us.\n", i, diff);
353  ifile->start_time_effective = new_start_time;
354  if (copy_ts && start_at_zero)
355  ifile->ts_offset = -new_start_time;
356  else if (!copy_ts) {
357  abs_start_seek = is->start_time + (ifile->start_time != AV_NOPTS_VALUE) ? ifile->start_time : 0;
358  ifile->ts_offset = abs_start_seek > new_start_time ? -abs_start_seek : -new_start_time;
359  } else if (copy_ts)
360  ifile->ts_offset = 0;
361 
362  ifile->ts_offset += ifile->input_ts_offset;
363  }
364  }
365 }
366 
367 static int apply_sync_offsets(void)
368 {
369  for (int i = 0; i < nb_input_files; i++) {
370  InputFile *ref, *self = input_files[i];
371  int64_t adjustment;
372  int64_t self_start_time, ref_start_time, self_seek_start, ref_seek_start;
373  int start_times_set = 1;
374 
375  if (self->input_sync_ref == -1 || self->input_sync_ref == i) continue;
376  if (self->input_sync_ref >= nb_input_files || self->input_sync_ref < -1) {
377  av_log(NULL, AV_LOG_FATAL, "-isync for input %d references non-existent input %d.\n", i, self->input_sync_ref);
378  return AVERROR(EINVAL);
379  }
380 
381  if (copy_ts && !start_at_zero) {
382  av_log(NULL, AV_LOG_FATAL, "Use of -isync requires that start_at_zero be set if copyts is set.\n");
383  return AVERROR(EINVAL);
384  }
385 
386  ref = input_files[self->input_sync_ref];
387  if (ref->input_sync_ref != -1 && ref->input_sync_ref != self->input_sync_ref) {
388  av_log(NULL, AV_LOG_ERROR, "-isync for input %d references a resynced input %d. Sync not set.\n", i, self->input_sync_ref);
389  continue;
390  }
391 
392  if (self->ctx->start_time_realtime != AV_NOPTS_VALUE && ref->ctx->start_time_realtime != AV_NOPTS_VALUE) {
393  self_start_time = self->ctx->start_time_realtime;
394  ref_start_time = ref->ctx->start_time_realtime;
395  } else if (self->start_time_effective != AV_NOPTS_VALUE && ref->start_time_effective != AV_NOPTS_VALUE) {
396  self_start_time = self->start_time_effective;
397  ref_start_time = ref->start_time_effective;
398  } else {
399  start_times_set = 0;
400  }
401 
402  if (start_times_set) {
403  self_seek_start = self->start_time == AV_NOPTS_VALUE ? 0 : self->start_time;
404  ref_seek_start = ref->start_time == AV_NOPTS_VALUE ? 0 : ref->start_time;
405 
406  adjustment = (self_start_time - ref_start_time) + !copy_ts*(self_seek_start - ref_seek_start) + ref->input_ts_offset;
407 
408  self->ts_offset += adjustment;
409 
410  av_log(NULL, AV_LOG_INFO, "Adjusted ts offset for Input #%d by %"PRId64" us to sync with Input #%d.\n", i, adjustment, self->input_sync_ref);
411  } else {
412  av_log(NULL, AV_LOG_INFO, "Unable to identify start times for Inputs #%d and %d both. No sync adjustment made.\n", i, self->input_sync_ref);
413  }
414  }
415 
416  return 0;
417 }
418 
419 static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
420 {
423  return 0;
424 }
425 
426 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
427 {
428  static const AVOption opts[] = {
429  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, (double)INT64_MAX, .unit = "flags" },
430  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
431  { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
432  { NULL },
433  };
434  static const AVClass class = {
435  .class_name = "",
436  .item_name = av_default_item_name,
437  .option = opts,
438  .version = LIBAVUTIL_VERSION_INT,
439  };
440  const AVClass *pclass = &class;
441 
442  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
443 }
444 
445 static int opt_stats_period(void *optctx, const char *opt, const char *arg)
446 {
447  int64_t user_stats_period;
448  int ret = av_parse_time(&user_stats_period, arg, 1);
449  if (ret < 0)
450  return ret;
451 
452  if (user_stats_period <= 0) {
453  av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
454  return AVERROR(EINVAL);
455  }
456 
457  stats_period = user_stats_period;
458  av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
459 
460  return 0;
461 }
462 
463 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
464 {
465  OptionsContext *o = optctx;
466  return parse_option(o, "codec:a", arg, options);
467 }
468 
469 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
470 {
471  OptionsContext *o = optctx;
472  return parse_option(o, "codec:v", arg, options);
473 }
474 
475 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
476 {
477  OptionsContext *o = optctx;
478  return parse_option(o, "codec:s", arg, options);
479 }
480 
481 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
482 {
483  OptionsContext *o = optctx;
484  return parse_option(o, "codec:d", arg, options);
485 }
486 
487 static int opt_map(void *optctx, const char *opt, const char *arg)
488 {
489  OptionsContext *o = optctx;
490  StreamMap *m = NULL;
492  int i, negative = 0, file_idx, disabled = 0;
493  int ret, allow_unused = 0;
494 
495  memset(&ss, 0, sizeof(ss));
496 
497  if (*arg == '-') {
498  negative = 1;
499  arg++;
500  }
501 
502  if (arg[0] == '[') {
503  /* this mapping refers to lavfi output */
504  const char *c = arg + 1;
505 
507  if (ret < 0)
508  goto fail;
509 
510  m = &o->stream_maps[o->nb_stream_maps - 1];
511  m->linklabel = av_get_token(&c, "]");
512  if (!m->linklabel) {
513  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", arg);
514  ret = AVERROR(EINVAL);
515  goto fail;
516  }
517  } else {
518  ViewSpecifier vs;
519  char *endptr;
520 
521  file_idx = strtol(arg, &endptr, 0);
522  if (file_idx >= nb_input_files || file_idx < 0) {
523  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
524  ret = AVERROR(EINVAL);
525  goto fail;
526  }
527  arg = endptr;
528 
529  ret = stream_specifier_parse(&ss, *arg == ':' ? arg + 1 : arg, 1, NULL);
530  if (ret < 0) {
531  av_log(NULL, AV_LOG_ERROR, "Invalid stream specifier: %s\n", arg);
532  goto fail;
533  }
534 
535  arg = ss.remainder ? ss.remainder : "";
536 
537  ret = view_specifier_parse(&arg, &vs);
538  if (ret < 0)
539  goto fail;
540 
541  if (*arg) {
542  if (!strcmp(arg, "?"))
543  allow_unused = 1;
544  else {
546  "Trailing garbage after stream specifier: %s\n", arg);
547  ret = AVERROR(EINVAL);
548  goto fail;
549  }
550  }
551 
552  if (negative)
553  /* disable some already defined maps */
554  for (i = 0; i < o->nb_stream_maps; i++) {
555  m = &o->stream_maps[i];
556  if (file_idx == m->file_index &&
560  NULL))
561  m->disabled = 1;
562  }
563  else
564  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
566  input_files[file_idx]->ctx,
567  input_files[file_idx]->ctx->streams[i],
568  NULL))
569  continue;
570  if (input_files[file_idx]->streams[i]->user_set_discard == AVDISCARD_ALL) {
571  disabled = 1;
572  continue;
573  }
575  if (ret < 0)
576  goto fail;
577 
578  m = &o->stream_maps[o->nb_stream_maps - 1];
579 
580  m->file_index = file_idx;
581  m->stream_index = i;
582  m->vs = vs;
583  }
584  }
585 
586  if (!m) {
587  if (allow_unused) {
588  av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
589  } else if (disabled) {
590  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
591  "To ignore this, add a trailing '?' to the map.\n", arg);
592  ret = AVERROR(EINVAL);
593  goto fail;
594  } else {
595  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
596  "To ignore this, add a trailing '?' to the map.\n", arg);
597  ret = AVERROR(EINVAL);
598  goto fail;
599  }
600  }
601  ret = 0;
602 fail:
604  return ret;
605 }
606 
607 static int opt_attach(void *optctx, const char *opt, const char *arg)
608 {
609  OptionsContext *o = optctx;
611  if (ret < 0)
612  return ret;
613 
614  o->attachments[o->nb_attachments - 1] = av_strdup(arg);
615  if (!o->attachments[o->nb_attachments - 1])
616  return AVERROR(ENOMEM);
617 
618  return 0;
619 }
620 
621 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
622 {
623  GlobalOptionsContext *go = optctx;
624  return sch_sdp_filename(go->sch, arg);
625 }
626 
627 #if CONFIG_VAAPI
628 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
629 {
630  const char *prefix = "vaapi:";
631  char *tmp;
632  int err;
633  tmp = av_asprintf("%s%s", prefix, arg);
634  if (!tmp)
635  return AVERROR(ENOMEM);
637  av_free(tmp);
638  return err;
639 }
640 #endif
641 
642 #if CONFIG_QSV
643 static int opt_qsv_device(void *optctx, const char *opt, const char *arg)
644 {
645  const char *prefix = "qsv=__qsv_device:hw_any,child_device=";
646  int err;
647  char *tmp = av_asprintf("%s%s", prefix, arg);
648 
649  if (!tmp)
650  return AVERROR(ENOMEM);
651 
653  av_free(tmp);
654 
655  return err;
656 }
657 #endif
658 
659 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
660 {
661  if (!strcmp(arg, "list")) {
663  printf("Supported hardware device types:\n");
664  while ((type = av_hwdevice_iterate_types(type)) !=
667  printf("\n");
668  return AVERROR_EXIT;
669  } else {
671  }
672 }
673 
674 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
675 {
676  if (filter_hw_device) {
677  av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
678  return AVERROR(EINVAL);
679  }
681  if (!filter_hw_device) {
682  av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
683  return AVERROR(EINVAL);
684  }
685  return 0;
686 }
687 
688 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
689 {
690  OptionsContext *o = optctx;
691  char buf[128];
692  int64_t recording_timestamp;
693  int ret;
694  struct tm time;
695 
696  ret = av_parse_time(&recording_timestamp, arg, 0);
697  if (ret < 0)
698  return ret;
699 
700  recording_timestamp /= 1e6;
701  time = *gmtime((time_t*)&recording_timestamp);
702  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
703  return -1;
704  parse_option(o, "metadata", buf, options);
705 
706  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
707  "tag instead.\n", opt);
708  return 0;
709 }
710 
711 int find_codec(void *logctx, const char *name,
712  enum AVMediaType type, int encoder, const AVCodec **pcodec)
713 {
714  const AVCodecDescriptor *desc;
715  const char *codec_string = encoder ? "encoder" : "decoder";
716  const AVCodec *codec;
717 
718  codec = encoder ?
721 
722  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
723  codec = encoder ? avcodec_find_encoder(desc->id) :
725  if (codec)
726  av_log(logctx, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
727  codec_string, codec->name, desc->name);
728  }
729 
730  if (!codec) {
731  av_log(logctx, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
732  return encoder ? AVERROR_ENCODER_NOT_FOUND :
734  }
735  if (codec->type != type && !recast_media) {
736  av_log(logctx, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
737  return AVERROR(EINVAL);
738  }
739 
740  *pcodec = codec;
741  return 0;;
742 }
743 
744 int assert_file_overwrite(const char *filename)
745 {
746  const char *proto_name = avio_find_protocol_name(filename);
747 
749  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
750  return AVERROR(EINVAL);
751  }
752 
753  if (!file_overwrite) {
754  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
756  fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
757  fflush(stderr);
758  term_exit();
759  signal(SIGINT, SIG_DFL);
760  if (!read_yesno()) {
761  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
762  return AVERROR_EXIT;
763  }
764  term_init();
765  }
766  else {
767  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
768  return AVERROR_EXIT;
769  }
770  }
771  }
772 
773  if (proto_name && !strcmp(proto_name, "file")) {
774  for (int i = 0; i < nb_input_files; i++) {
775  InputFile *file = input_files[i];
776  if (file->ctx->iformat->flags & AVFMT_NOFILE)
777  continue;
778  if (!strcmp(filename, file->ctx->url)) {
779  av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
780  av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
781  return AVERROR(EINVAL);
782  }
783  }
784  }
785 
786  return 0;
787 }
788 
789 /* arg format is "output-stream-index:streamid-value". */
790 static int opt_streamid(void *optctx, const char *opt, const char *arg)
791 {
792  OptionsContext *o = optctx;
793  char *p;
794  char idx_str[16];
795 
796  av_strlcpy(idx_str, arg, sizeof(idx_str));
797  p = strchr(idx_str, ':');
798  if (!p) {
800  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
801  arg, opt);
802  return AVERROR(EINVAL);
803  }
804  *p++ = '\0';
805 
806  return av_dict_set(&o->streamid, idx_str, p, 0);
807 }
808 
809 static int opt_target(void *optctx, const char *opt, const char *arg)
810 {
811  OptionsContext *o = optctx;
812  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
813  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
814 
815  if (!strncmp(arg, "pal-", 4)) {
816  norm = PAL;
817  arg += 4;
818  } else if (!strncmp(arg, "ntsc-", 5)) {
819  norm = NTSC;
820  arg += 5;
821  } else if (!strncmp(arg, "film-", 5)) {
822  norm = FILM;
823  arg += 5;
824  } else {
825  /* Try to determine PAL/NTSC by peeking in the input files */
826  if (nb_input_files) {
827  int i, j;
828  for (j = 0; j < nb_input_files; j++) {
829  for (i = 0; i < input_files[j]->nb_streams; i++) {
830  AVStream *st = input_files[j]->ctx->streams[i];
831  int64_t fr;
833  continue;
834  fr = st->time_base.den * 1000LL / st->time_base.num;
835  if (fr == 25000) {
836  norm = PAL;
837  break;
838  } else if ((fr == 29970) || (fr == 23976)) {
839  norm = NTSC;
840  break;
841  }
842  }
843  if (norm != UNKNOWN)
844  break;
845  }
846  }
847  if (norm != UNKNOWN)
848  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
849  }
850 
851  if (norm == UNKNOWN) {
852  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
853  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
854  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
855  return AVERROR(EINVAL);
856  }
857 
858  if (!strcmp(arg, "vcd")) {
859  opt_video_codec(o, "c:v", "mpeg1video");
860  opt_audio_codec(o, "c:a", "mp2");
861  parse_option(o, "f", "vcd", options);
862 
863  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
864  parse_option(o, "r", frame_rates[norm], options);
865  opt_default(NULL, "g", norm == PAL ? "15" : "18");
866 
867  opt_default(NULL, "b:v", "1150000");
868  opt_default(NULL, "maxrate:v", "1150000");
869  opt_default(NULL, "minrate:v", "1150000");
870  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
871 
872  opt_default(NULL, "b:a", "224000");
873  parse_option(o, "ar", "44100", options);
874  parse_option(o, "ac", "2", options);
875 
876  opt_default(NULL, "packetsize", "2324");
877  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
878 
879  /* We have to offset the PTS, so that it is consistent with the SCR.
880  SCR starts at 36000, but the first two packs contain only padding
881  and the first pack from the other stream, respectively, may also have
882  been written before.
883  So the real data starts at SCR 36000+3*1200. */
884  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
885  } else if (!strcmp(arg, "svcd")) {
886 
887  opt_video_codec(o, "c:v", "mpeg2video");
888  opt_audio_codec(o, "c:a", "mp2");
889  parse_option(o, "f", "svcd", options);
890 
891  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
892  parse_option(o, "r", frame_rates[norm], options);
893  parse_option(o, "pix_fmt", "yuv420p", options);
894  opt_default(NULL, "g", norm == PAL ? "15" : "18");
895 
896  opt_default(NULL, "b:v", "2040000");
897  opt_default(NULL, "maxrate:v", "2516000");
898  opt_default(NULL, "minrate:v", "0"); // 1145000;
899  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
900  opt_default(NULL, "scan_offset", "1");
901 
902  opt_default(NULL, "b:a", "224000");
903  parse_option(o, "ar", "44100", options);
904 
905  opt_default(NULL, "packetsize", "2324");
906 
907  } else if (!strcmp(arg, "dvd")) {
908 
909  opt_video_codec(o, "c:v", "mpeg2video");
910  opt_audio_codec(o, "c:a", "ac3");
911  parse_option(o, "f", "dvd", options);
912 
913  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
914  parse_option(o, "r", frame_rates[norm], options);
915  parse_option(o, "pix_fmt", "yuv420p", options);
916  opt_default(NULL, "g", norm == PAL ? "15" : "18");
917 
918  opt_default(NULL, "b:v", "6000000");
919  opt_default(NULL, "maxrate:v", "9000000");
920  opt_default(NULL, "minrate:v", "0"); // 1500000;
921  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
922 
923  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
924  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
925 
926  opt_default(NULL, "b:a", "448000");
927  parse_option(o, "ar", "48000", options);
928 
929  } else if (!strncmp(arg, "dv", 2)) {
930 
931  parse_option(o, "f", "dv", options);
932 
933  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
934  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
935  norm == PAL ? "yuv420p" : "yuv411p", options);
936  parse_option(o, "r", frame_rates[norm], options);
937 
938  parse_option(o, "ar", "48000", options);
939  parse_option(o, "ac", "2", options);
940 
941  } else {
942  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
943  return AVERROR(EINVAL);
944  }
945 
948 
949  return 0;
950 }
951 
952 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
953 {
956  return 0;
957 }
958 
959 static int opt_vstats(void *optctx, const char *opt, const char *arg)
960 {
961  char filename[40];
962  time_t today2 = time(NULL);
963  struct tm *today = localtime(&today2);
964 
965  if (!today) { // maybe tomorrow
966  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
967  return AVERROR(errno);
968  }
969 
970  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
971  today->tm_sec);
972  return opt_vstats_file(NULL, opt, filename);
973 }
974 
975 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
976 {
977  OptionsContext *o = optctx;
978  return parse_option(o, "frames:v", arg, options);
979 }
980 
981 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
982 {
983  OptionsContext *o = optctx;
984  return parse_option(o, "frames:a", arg, options);
985 }
986 
987 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
988 {
989  OptionsContext *o = optctx;
990  return parse_option(o, "frames:d", arg, options);
991 }
992 
993 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
994 {
995  int ret;
996  AVDictionary *cbak = codec_opts;
997  AVDictionary *fbak = format_opts;
998  codec_opts = NULL;
999  format_opts = NULL;
1000 
1001  ret = opt_default(NULL, opt, arg);
1002 
1003  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1007  codec_opts = cbak;
1008  format_opts = fbak;
1009 
1010  return ret;
1011 }
1012 
1013 static int opt_preset(void *optctx, const char *opt, const char *arg)
1014 {
1015  OptionsContext *o = optctx;
1016  FILE *f=NULL;
1017  char filename[1000], line[1000], tmp_line[1000];
1018  const char *codec_name = NULL;
1019  int ret = 0;
1020 
1021  codec_name = opt_match_per_type_str(&o->codec_names, *opt);
1022 
1023  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1024  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1025  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1026  }else
1027  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1028  return AVERROR(ENOENT);
1029  }
1030 
1031  while (fgets(line, sizeof(line), f)) {
1032  char *key = tmp_line, *value, *endptr;
1033 
1034  if (strcspn(line, "#\n\r") == 0)
1035  continue;
1036  av_strlcpy(tmp_line, line, sizeof(tmp_line));
1037  if (!av_strtok(key, "=", &value) ||
1038  !av_strtok(value, "\r\n", &endptr)) {
1039  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1040  ret = AVERROR(EINVAL);
1041  goto fail;
1042  }
1043  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1044 
1045  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1046  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1047  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1048  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1049  else if (opt_default_new(o, key, value) < 0) {
1050  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1051  filename, line, key, value);
1052  ret = AVERROR(EINVAL);
1053  goto fail;
1054  }
1055  }
1056 
1057 fail:
1058  fclose(f);
1059 
1060  return ret;
1061 }
1062 
1063 static int opt_old2new(void *optctx, const char *opt, const char *arg)
1064 {
1065  OptionsContext *o = optctx;
1066  int ret;
1067  char *s = av_asprintf("%s:%c", opt + 1, *opt);
1068  if (!s)
1069  return AVERROR(ENOMEM);
1070  ret = parse_option(o, s, arg, options);
1071  av_free(s);
1072  return ret;
1073 }
1074 
1075 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
1076 {
1077  OptionsContext *o = optctx;
1078 
1079  if(!strcmp(opt, "ab")){
1080  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
1081  return 0;
1082  } else if(!strcmp(opt, "b")){
1083  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
1084  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1085  return 0;
1086  }
1087  av_dict_set(&o->g->codec_opts, opt, arg, 0);
1088  return 0;
1089 }
1090 
1091 static int opt_qscale(void *optctx, const char *opt, const char *arg)
1092 {
1093  OptionsContext *o = optctx;
1094  char *s;
1095  int ret;
1096  if(!strcmp(opt, "qscale")){
1097  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
1098  return parse_option(o, "q:v", arg, options);
1099  }
1100  s = av_asprintf("q%s", opt + 6);
1101  if (!s)
1102  return AVERROR(ENOMEM);
1103  ret = parse_option(o, s, arg, options);
1104  av_free(s);
1105  return ret;
1106 }
1107 
1108 static int opt_profile(void *optctx, const char *opt, const char *arg)
1109 {
1110  OptionsContext *o = optctx;
1111  if(!strcmp(opt, "profile")){
1112  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
1113  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
1114  return 0;
1115  }
1116  av_dict_set(&o->g->codec_opts, opt, arg, 0);
1117  return 0;
1118 }
1119 
1120 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1121 {
1122  OptionsContext *o = optctx;
1123  return parse_option(o, "filter:v", arg, options);
1124 }
1125 
1126 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1127 {
1128  OptionsContext *o = optctx;
1129  return parse_option(o, "filter:a", arg, options);
1130 }
1131 
1132 #if FFMPEG_OPT_VSYNC
1133 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1134 {
1135  av_log(NULL, AV_LOG_WARNING, "-vsync is deprecated. Use -fps_mode\n");
1136  return parse_and_set_vsync(arg, &video_sync_method, -1, -1, 1);
1137 }
1138 #endif
1139 
1140 static int opt_timecode(void *optctx, const char *opt, const char *arg)
1141 {
1142  OptionsContext *o = optctx;
1143  int ret;
1144  char *tcr = av_asprintf("timecode=%s", arg);
1145  if (!tcr)
1146  return AVERROR(ENOMEM);
1147  ret = parse_option(o, "metadata:g", tcr, options);
1148  if (ret >= 0)
1149  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
1150  av_free(tcr);
1151  return ret;
1152 }
1153 
1154 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1155 {
1156  OptionsContext *o = optctx;
1157  return parse_option(o, "q:a", arg, options);
1158 }
1159 
1160 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1161 {
1162  GlobalOptionsContext *go = optctx;
1163  char *graph_desc;
1164  int ret;
1165 
1166  graph_desc = av_strdup(arg);
1167  if (!graph_desc)
1168  return AVERROR(ENOMEM);
1169 
1171  if (ret < 0) {
1172  av_freep(&graph_desc);
1173  return ret;
1174  }
1175  go->filtergraphs[go->nb_filtergraphs - 1] = graph_desc;
1176 
1177  return 0;
1178 }
1179 
1180 #if FFMPEG_OPT_FILTER_SCRIPT
1181 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1182 {
1183  GlobalOptionsContext *go = optctx;
1184  char *graph_desc;
1185  int ret;
1186 
1187  graph_desc = file_read(arg);
1188  if (!graph_desc)
1189  return AVERROR(EINVAL);
1190 
1191  av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -/filter_complex %s instead\n",
1192  opt, arg);
1193 
1195  if (ret < 0) {
1196  av_freep(&graph_desc);
1197  return ret;
1198  }
1199  go->filtergraphs[go->nb_filtergraphs - 1] = graph_desc;
1200 
1201  return 0;
1202 }
1203 #endif
1204 
1205 void show_help_default(const char *opt, const char *arg)
1206 {
1207  int show_advanced = 0, show_avoptions = 0;
1208 
1209  if (opt && *opt) {
1210  if (!strcmp(opt, "long"))
1211  show_advanced = 1;
1212  else if (!strcmp(opt, "full"))
1213  show_advanced = show_avoptions = 1;
1214  else
1215  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1216  }
1217 
1218  show_usage();
1219 
1220  printf("Getting help:\n"
1221  " -h -- print basic options\n"
1222  " -h long -- print more options\n"
1223  " -h full -- print all options (including all format and codec specific options, very long)\n"
1224  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
1225  " See man %s for detailed description of the options.\n"
1226  "\n"
1227  "Per-stream options can be followed by :<stream_spec> to apply that option to specific streams only. "
1228  "<stream_spec> can be a stream index, or v/a/s for video/audio/subtitle (see manual for full syntax).\n"
1229  "\n", program_name);
1230 
1231  show_help_options(options, "Print help / information / capabilities:",
1232  OPT_EXIT, OPT_EXPERT);
1233  if (show_advanced)
1234  show_help_options(options, "Advanced information / capabilities:",
1235  OPT_EXIT | OPT_EXPERT, 0);
1236 
1237  show_help_options(options, "Global options (affect whole program "
1238  "instead of just one file):",
1240  if (show_advanced)
1241  show_help_options(options, "Advanced global options:", OPT_EXPERT,
1242  OPT_PERFILE | OPT_EXIT);
1243 
1244  show_help_options(options, "Per-file options (input and output):",
1248  if (show_advanced)
1249  show_help_options(options, "Advanced per-file options (input and output):",
1253 
1254  show_help_options(options, "Per-file options (input-only):",
1258  if (show_advanced)
1259  show_help_options(options, "Advanced per-file options (input-only):",
1263 
1264  show_help_options(options, "Per-file options (output-only):",
1268  if (show_advanced)
1269  show_help_options(options, "Advanced per-file options (output-only):",
1273 
1274  show_help_options(options, "Per-stream options:",
1276  OPT_EXIT | OPT_EXPERT |
1278  if (show_advanced)
1279  show_help_options(options, "Advanced per-stream options:",
1281  OPT_EXIT |
1283 
1284  show_help_options(options, "Video options:",
1286  if (show_advanced)
1287  show_help_options(options, "Advanced Video options:",
1289 
1290  show_help_options(options, "Audio options:",
1292  if (show_advanced)
1293  show_help_options(options, "Advanced Audio options:",
1295 
1296  show_help_options(options, "Subtitle options:",
1298  if (show_advanced)
1299  show_help_options(options, "Advanced Subtitle options:",
1301 
1302  if (show_advanced)
1303  show_help_options(options, "Data stream options:",
1305  printf("\n");
1306 
1307  if (show_avoptions) {
1311 #if CONFIG_SWSCALE
1313 #endif
1314 #if CONFIG_SWRESAMPLE
1316 #endif
1319  }
1320 }
1321 
1322 void show_usage(void)
1323 {
1324  av_log(NULL, AV_LOG_INFO, "Universal media converter\n");
1325  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1326  av_log(NULL, AV_LOG_INFO, "\n");
1327 }
1328 
1329 enum OptGroup {
1330  GROUP_OUTFILE,
1331  GROUP_INFILE,
1332  GROUP_DECODER,
1333 };
1334 
1335 static const OptionGroupDef groups[] = {
1336  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
1337  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
1338  [GROUP_DECODER] = { "loopback decoder", "dec", OPT_DECODER },
1339 };
1340 
1341 static int open_files(OptionGroupList *l, const char *inout, Scheduler *sch,
1342  int (*open_file)(const OptionsContext*, const char*,
1343  Scheduler*))
1344 {
1345  int i, ret;
1346 
1347  for (i = 0; i < l->nb_groups; i++) {
1348  OptionGroup *g = &l->groups[i];
1349  OptionsContext o;
1350 
1351  init_options(&o);
1352  o.g = g;
1353 
1354  ret = parse_optgroup(&o, g, options);
1355  if (ret < 0) {
1356  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1357  "%s.\n", inout, g->arg);
1358  uninit_options(&o);
1359  return ret;
1360  }
1361 
1362  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1363  ret = open_file(&o, g->arg, sch);
1364  uninit_options(&o);
1365  if (ret < 0) {
1366  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1367  inout, g->arg);
1368  return ret;
1369  }
1370  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
1371  }
1372 
1373  return 0;
1374 }
1375 
1376 int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
1377 {
1378  GlobalOptionsContext go = { .sch = sch };
1379  OptionParseContext octx;
1380  const char *errmsg = NULL;
1381  int ret;
1382 
1383  memset(&octx, 0, sizeof(octx));
1384 
1385  /* split the commandline into an internal representation */
1386  ret = split_commandline(&octx, argc, argv, options, groups,
1387  FF_ARRAY_ELEMS(groups));
1388  if (ret < 0) {
1389  errmsg = "splitting the argument list";
1390  goto fail;
1391  }
1392 
1393  /* apply global options */
1394  ret = parse_optgroup(&go, &octx.global_opts, options);
1395  if (ret < 0) {
1396  errmsg = "parsing global options";
1397  goto fail;
1398  }
1399 
1400  /* configure terminal and setup signal handlers */
1401  term_init();
1402 
1403  /* create complex filtergraphs */
1404  for (int i = 0; i < go.nb_filtergraphs; i++) {
1405  ret = fg_create(NULL, go.filtergraphs[i], sch);
1406  go.filtergraphs[i] = NULL;
1407  if (ret < 0)
1408  goto fail;
1409  }
1410 
1411  /* open input files */
1412  ret = open_files(&octx.groups[GROUP_INFILE], "input", sch, ifile_open);
1413  if (ret < 0) {
1414  errmsg = "opening input files";
1415  goto fail;
1416  }
1417 
1418  /* open output files */
1419  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", sch, of_open);
1420  if (ret < 0) {
1421  errmsg = "opening output files";
1422  goto fail;
1423  }
1424 
1425  /* create loopback decoders */
1426  ret = open_files(&octx.groups[GROUP_DECODER], "decoder", sch, dec_create);
1427  if (ret < 0) {
1428  errmsg = "creating loopback decoders";
1429  goto fail;
1430  }
1431 
1432  // bind unbound filtegraph inputs/outputs and check consistency
1434  if (ret < 0) {
1435  errmsg = "binding filtergraph inputs/outputs";
1436  goto fail;
1437  }
1438 
1440 
1441  ret = apply_sync_offsets();
1442  if (ret < 0)
1443  goto fail;
1444 
1445 fail:
1446  for (int i = 0; i < go.nb_filtergraphs; i++)
1447  av_freep(&go.filtergraphs[i]);
1448  av_freep(&go.filtergraphs);
1449 
1450  uninit_parse_context(&octx);
1451  if (ret < 0 && ret != AVERROR_EXIT) {
1452  av_log(NULL, AV_LOG_FATAL, "Error %s: %s\n",
1453  errmsg ? errmsg : "", av_err2str(ret));
1454  }
1455  return ret;
1456 }
1457 
1458 static int opt_progress(void *optctx, const char *opt, const char *arg)
1459 {
1460  AVIOContext *avio = NULL;
1461  int ret;
1462 
1463  if (!strcmp(arg, "-"))
1464  arg = "pipe:";
1465  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
1466  if (ret < 0) {
1467  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
1468  arg, av_err2str(ret));
1469  return ret;
1470  }
1471  progress_avio = avio;
1472  return 0;
1473 }
1474 
1475 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1476 {
1477 #if HAVE_SETRLIMIT
1478  int ret;
1479  double lim;
1480  struct rlimit rl;
1481 
1482  ret = parse_number(opt, arg, OPT_TYPE_INT64, 0, INT_MAX, &lim);
1483  if (ret < 0)
1484  return ret;
1485 
1486  rl = (struct rlimit){ lim, lim + 1 };
1487  if (setrlimit(RLIMIT_CPU, &rl))
1488  perror("setrlimit");
1489 #else
1490  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1491 #endif
1492  return 0;
1493 }
1494 
1495 #if FFMPEG_OPT_QPHIST
1496 static int opt_qphist(void *optctx, const char *opt, const char *arg)
1497 {
1498  av_log(NULL, AV_LOG_WARNING, "Option -%s is deprecated and has no effect\n", opt);
1499  return 0;
1500 }
1501 #endif
1502 
1503 #if FFMPEG_OPT_ADRIFT_THRESHOLD
1504 static int opt_adrift_threshold(void *optctx, const char *opt, const char *arg)
1505 {
1506  av_log(NULL, AV_LOG_WARNING, "Option -%s is deprecated and has no effect\n", opt);
1507  return 0;
1508 }
1509 #endif
1510 
1511 static const char *const alt_bsf[] = { "absf", "vbsf", NULL };
1512 static const char *const alt_channel_layout[] = { "ch_layout", NULL};
1513 static const char *const alt_codec[] = { "c", "acodec", "vcodec", "scodec", "dcodec", NULL };
1514 static const char *const alt_filter[] = { "af", "vf", NULL };
1515 static const char *const alt_frames[] = { "aframes", "vframes", "dframes", NULL };
1516 static const char *const alt_pre[] = { "apre", "vpre", "spre", NULL};
1517 static const char *const alt_qscale[] = { "q", NULL};
1518 static const char *const alt_tag[] = { "atag", "vtag", "stag", NULL };
1519 
1520 #define OFFSET(x) offsetof(OptionsContext, x)
1521 const OptionDef options[] = {
1522  /* main options */
1525  { .off = OFFSET(format) },
1526  "force container format (auto-detected otherwise)", "fmt" },
1527  { "y", OPT_TYPE_BOOL, 0,
1528  { &file_overwrite },
1529  "overwrite output files" },
1530  { "n", OPT_TYPE_BOOL, 0,
1531  { &no_file_overwrite },
1532  "never overwrite output files" },
1533  { "ignore_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1535  "Ignore unknown stream types" },
1536  { "copy_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1537  { &copy_unknown_streams },
1538  "Copy unknown stream types" },
1539  { "recast_media", OPT_TYPE_BOOL, OPT_EXPERT,
1540  { &recast_media },
1541  "allow recasting stream type in order to force a decoder of different media type" },
1543  { .off = OFFSET(codec_names) },
1544  "select encoder/decoder ('copy' to copy stream without reencoding)", "codec",
1545  .u1.name_canon = "codec", },
1547  { .off = OFFSET(codec_names) },
1548  "alias for -c (select encoder/decoder)", "codec",
1549  .u1.names_alt = alt_codec, },
1551  { .off = OFFSET(presets) },
1552  "preset name", "preset",
1553  .u1.names_alt = alt_pre, },
1555  { .func_arg = opt_map },
1556  "set input stream mapping",
1557  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1558  { "map_metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1559  { .off = OFFSET(metadata_map) },
1560  "set metadata information of outfile from infile",
1561  "outfile[,metadata]:infile[,metadata]" },
1562  { "map_chapters", OPT_TYPE_INT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1563  { .off = OFFSET(chapters_input_file) },
1564  "set chapters mapping", "input_file_index" },
1566  { .off = OFFSET(recording_time) },
1567  "stop transcoding after specified duration",
1568  "duration" },
1570  { .off = OFFSET(stop_time) },
1571  "stop transcoding after specified time is reached",
1572  "time_stop" },
1574  { .off = OFFSET(limit_filesize) },
1575  "set the limit file size in bytes", "limit_size" },
1577  { .off = OFFSET(start_time) },
1578  "start transcoding at specified time", "time_off" },
1579  { "sseof", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1580  { .off = OFFSET(start_time_eof) },
1581  "set the start time offset relative to EOF", "time_off" },
1582  { "seek_timestamp", OPT_TYPE_INT, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1583  { .off = OFFSET(seek_timestamp) },
1584  "enable/disable seeking by timestamp with -ss" },
1585  { "accurate_seek", OPT_TYPE_BOOL, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1586  { .off = OFFSET(accurate_seek) },
1587  "enable/disable accurate seeking with -ss" },
1588  { "isync", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1589  { .off = OFFSET(input_sync_ref) },
1590  "Indicate the input index for sync reference", "sync ref" },
1591  { "itsoffset", OPT_TYPE_TIME, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1592  { .off = OFFSET(input_ts_offset) },
1593  "set the input ts offset", "time_off" },
1595  { .off = OFFSET(ts_scale) },
1596  "set the input ts scale", "scale" },
1598  { .func_arg = opt_recording_timestamp },
1599  "set the recording timestamp ('now' to set the current time)", "time" },
1600  { "metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
1601  { .off = OFFSET(metadata) },
1602  "add metadata", "key=value" },
1603  { "program", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
1604  { .off = OFFSET(program) },
1605  "add program with specified streams", "title=string:st=number..." },
1606  { "stream_group", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1607  { .off = OFFSET(stream_groups) },
1608  "add stream group with specified streams and group type-specific arguments", "id=number:st=number..." },
1610  { .func_arg = opt_data_frames },
1611  "set the number of data frames to output", "number",
1612  .u1.name_canon = "frames" },
1613  { "benchmark", OPT_TYPE_BOOL, OPT_EXPERT,
1614  { &do_benchmark },
1615  "add timings for benchmarking" },
1616  { "benchmark_all", OPT_TYPE_BOOL, OPT_EXPERT,
1617  { &do_benchmark_all },
1618  "add timings for each task" },
1619  { "progress", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1620  { .func_arg = opt_progress },
1621  "write program-readable progress information", "url" },
1622  { "stdin", OPT_TYPE_BOOL, OPT_EXPERT,
1623  { &stdin_interaction },
1624  "enable or disable interaction on standard input" },
1625  { "timelimit", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1626  { .func_arg = opt_timelimit },
1627  "set max runtime in seconds in CPU user time", "limit" },
1628  { "dump", OPT_TYPE_BOOL, OPT_EXPERT,
1629  { &do_pkt_dump },
1630  "dump each input packet" },
1631  { "hex", OPT_TYPE_BOOL, OPT_EXPERT,
1632  { &do_hex_dump },
1633  "when dumping packets, also dump the payload" },
1635  { .off = OFFSET(rate_emu) },
1636  "read input at native frame rate; equivalent to -readrate 1", "" },
1637  { "readrate", OPT_TYPE_FLOAT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1638  { .off = OFFSET(readrate) },
1639  "read input at specified rate", "speed" },
1640  { "readrate_initial_burst", OPT_TYPE_DOUBLE, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1641  { .off = OFFSET(readrate_initial_burst) },
1642  "The initial amount of input to burst read before imposing any readrate", "seconds" },
1644  { .func_arg = opt_target },
1645  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
1646  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
1647  { "frame_drop_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1648  { &frame_drop_threshold },
1649  "frame drop threshold", "" },
1650  { "copyts", OPT_TYPE_BOOL, OPT_EXPERT,
1651  { &copy_ts },
1652  "copy timestamps" },
1653  { "start_at_zero", OPT_TYPE_BOOL, OPT_EXPERT,
1654  { &start_at_zero },
1655  "shift input timestamps to start at 0 when using copyts" },
1656  { "copytb", OPT_TYPE_INT, OPT_EXPERT,
1657  { &copy_tb },
1658  "copy input stream time base when stream copying", "mode" },
1659  { "shortest", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1660  { .off = OFFSET(shortest) },
1661  "finish encoding within shortest input" },
1662  { "shortest_buf_duration", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1663  { .off = OFFSET(shortest_buf_duration) },
1664  "maximum buffering duration (in seconds) for the -shortest option" },
1666  { .off = OFFSET(bitexact) },
1667  "bitexact mode" },
1668  { "dts_delta_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1669  { &dts_delta_threshold },
1670  "timestamp discontinuity delta threshold", "threshold" },
1671  { "dts_error_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1672  { &dts_error_threshold },
1673  "timestamp error delta threshold", "threshold" },
1674  { "xerror", OPT_TYPE_BOOL, OPT_EXPERT,
1675  { &exit_on_error },
1676  "exit on error", "error" },
1677  { "abort_on", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1678  { .func_arg = opt_abort_on },
1679  "abort on the specified condition flags", "flags" },
1680  { "copyinkf", OPT_TYPE_BOOL, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1681  { .off = OFFSET(copy_initial_nonkeyframes) },
1682  "copy initial non-keyframes" },
1683  { "copypriorss", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1684  { .off = OFFSET(copy_prior_start) },
1685  "copy or discard frames before start time" },
1687  { .off = OFFSET(max_frames) },
1688  "set the number of frames to output", "number",
1689  .u1.names_alt = alt_frames, },
1691  { .off = OFFSET(codec_tags) },
1692  "force codec tag/fourcc", "fourcc/tag",
1693  .u1.names_alt = alt_tag, },
1695  { .off = OFFSET(qscale) },
1696  "use fixed quality scale (VBR)", "q",
1697  .u1.name_canon = "qscale", },
1699  { .func_arg = opt_qscale },
1700  "use fixed quality scale (VBR)", "q",
1701  .u1.names_alt = alt_qscale, },
1703  { .func_arg = opt_profile },
1704  "set profile", "profile" },
1706  { .off = OFFSET(filters) },
1707  "apply specified filters to audio/video", "filter_graph",
1708  .u1.names_alt = alt_filter, },
1709  { "filter_threads", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1710  { .func_arg = opt_filter_threads },
1711  "number of non-complex filter threads" },
1712 #if FFMPEG_OPT_FILTER_SCRIPT
1713  { "filter_script", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1714  { .off = OFFSET(filter_scripts) },
1715  "deprecated, use -/filter", "filename" },
1716 #endif
1717  { "reinit_filter", OPT_TYPE_INT, OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1718  { .off = OFFSET(reinit_filters) },
1719  "reinit filtergraph on input parameter changes", "" },
1720  { "filter_complex", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1721  { .func_arg = opt_filter_complex },
1722  "create a complex filtergraph", "graph_description" },
1723  { "filter_complex_threads", OPT_TYPE_INT, OPT_EXPERT,
1725  "number of threads for -filter_complex" },
1726  { "lavfi", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1727  { .func_arg = opt_filter_complex },
1728  "create a complex filtergraph", "graph_description" },
1729 #if FFMPEG_OPT_FILTER_SCRIPT
1730  { "filter_complex_script", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1731  { .func_arg = opt_filter_complex_script },
1732  "deprecated, use -/filter_complex instead", "filename" },
1733 #endif
1734  { "auto_conversion_filters", OPT_TYPE_BOOL, OPT_EXPERT,
1736  "enable automatic conversion filters globally" },
1737  { "stats", OPT_TYPE_BOOL, 0,
1738  { &print_stats },
1739  "print progress report during encoding", },
1740  { "stats_period", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1741  { .func_arg = opt_stats_period },
1742  "set the period at which ffmpeg updates stats and -progress output", "time" },
1744  { .func_arg = opt_attach },
1745  "add an attachment to the output file", "filename" },
1746  { "dump_attachment", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
1747  { .off = OFFSET(dump_attachment) },
1748  "extract an attachment into a file", "filename" },
1749  { "stream_loop", OPT_TYPE_INT, OPT_EXPERT | OPT_INPUT | OPT_OFFSET,
1750  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
1751  { "debug_ts", OPT_TYPE_BOOL, OPT_EXPERT,
1752  { &debug_ts },
1753  "print timestamp debugging info" },
1754  { "max_error_rate", OPT_TYPE_FLOAT, OPT_EXPERT,
1755  { &max_error_rate },
1756  "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
1758  { .off = OFFSET(discard) },
1759  "discard", "" },
1760  { "disposition", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT,
1761  { .off = OFFSET(disposition) },
1762  "disposition", "" },
1763  { "thread_queue_size", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT,
1764  { .off = OFFSET(thread_queue_size) },
1765  "set the maximum number of queued packets from the demuxer" },
1766  { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT | OPT_OFFSET,
1767  { .off = OFFSET(find_stream_info) },
1768  "read and decode the streams to fill missing information with heuristics" },
1769  { "bits_per_raw_sample", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1770  { .off = OFFSET(bits_per_raw_sample) },
1771  "set the number of bits per raw sample", "number" },
1772 
1773  { "stats_enc_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1774  { .off = OFFSET(enc_stats_pre) },
1775  "write encoding stats before encoding" },
1776  { "stats_enc_post", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1777  { .off = OFFSET(enc_stats_post) },
1778  "write encoding stats after encoding" },
1779  { "stats_mux_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1780  { .off = OFFSET(mux_stats) },
1781  "write packets stats before muxing" },
1782  { "stats_enc_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1783  { .off = OFFSET(enc_stats_pre_fmt) },
1784  "format of the stats written with -stats_enc_pre" },
1785  { "stats_enc_post_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1786  { .off = OFFSET(enc_stats_post_fmt) },
1787  "format of the stats written with -stats_enc_post" },
1788  { "stats_mux_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1789  { .off = OFFSET(mux_stats_fmt) },
1790  "format of the stats written with -stats_mux_pre" },
1791 
1792  /* video options */
1794  { .func_arg = opt_video_frames },
1795  "set the number of video frames to output", "number",
1796  .u1.name_canon = "frames", },
1798  { .off = OFFSET(frame_rates) },
1799  "override input framerate/convert to given output framerate (Hz value, fraction or abbreviation)", "rate" },
1801  { .off = OFFSET(max_frame_rates) },
1802  "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
1804  { .off = OFFSET(frame_sizes) },
1805  "set frame size (WxH or abbreviation)", "size" },
1807  { .off = OFFSET(frame_aspect_ratios) },
1808  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1810  { .off = OFFSET(frame_pix_fmts) },
1811  "set pixel format", "format" },
1812  { "display_rotation", OPT_TYPE_DOUBLE, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1813  { .off = OFFSET(display_rotations) },
1814  "set pure counter-clockwise rotation in degrees for stream(s)",
1815  "angle" },
1816  { "display_hflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1817  { .off = OFFSET(display_hflips) },
1818  "set display horizontal flip for stream(s) "
1819  "(overrides any display rotation if it is not set)"},
1820  { "display_vflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1821  { .off = OFFSET(display_vflips) },
1822  "set display vertical flip for stream(s) "
1823  "(overrides any display rotation if it is not set)"},
1825  { .off = OFFSET(video_disable) },
1826  "disable video" },
1828  { .off = OFFSET(rc_overrides) },
1829  "rate control override for specific intervals", "override" },
1831  { .func_arg = opt_video_codec },
1832  "alias for -c:v (select encoder/decoder for video streams)", "codec",
1833  .u1.name_canon = "codec", },
1835  { .func_arg = opt_timecode },
1836  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
1838  { .off = OFFSET(pass) },
1839  "select the pass number (1 to 3)", "n" },
1841  { .off = OFFSET(passlogfiles) },
1842  "select two pass log file name prefix", "prefix" },
1843  { "vstats", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
1844  { .func_arg = opt_vstats },
1845  "dump video coding statistics to file" },
1846  { "vstats_file", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT,
1847  { .func_arg = opt_vstats_file },
1848  "dump video coding statistics to file", "file" },
1849  { "vstats_version", OPT_TYPE_INT, OPT_VIDEO | OPT_EXPERT,
1850  { &vstats_version },
1851  "Version of the vstats format to use."},
1853  { .func_arg = opt_video_filters },
1854  "alias for -filter:v (apply filters to video streams)", "filter_graph",
1855  .u1.name_canon = "filter", },
1856  { "intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1857  { .off = OFFSET(intra_matrices) },
1858  "specify intra matrix coeffs", "matrix" },
1859  { "inter_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1860  { .off = OFFSET(inter_matrices) },
1861  "specify inter matrix coeffs", "matrix" },
1862  { "chroma_intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1863  { .off = OFFSET(chroma_intra_matrices) },
1864  "specify intra matrix coeffs", "matrix" },
1866  { .func_arg = opt_old2new },
1867  "force video tag/fourcc", "fourcc/tag",
1868  .u1.name_canon = "tag", },
1870  { .off = OFFSET(fps_mode) },
1871  "set framerate mode for matching video streams; overrides vsync" },
1873  { .off = OFFSET(force_fps) },
1874  "force the selected framerate, disable the best supported framerate selection" },
1876  { .func_arg = opt_streamid },
1877  "set the value of an outfile streamid", "streamIndex:value" },
1878  { "force_key_frames", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1879  { .off = OFFSET(forced_key_frames) },
1880  "force key frames at specified timestamps", "timestamps" },
1882  { .func_arg = opt_bitrate },
1883  "video bitrate (please use -b:v)", "bitrate" },
1885  { .off = OFFSET(hwaccels) },
1886  "use HW accelerated decoding", "hwaccel name" },
1887  { "hwaccel_device", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1888  { .off = OFFSET(hwaccel_devices) },
1889  "select a device for HW acceleration", "devicename" },
1890  { "hwaccel_output_format", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1891  { .off = OFFSET(hwaccel_output_formats) },
1892  "select output format used with HW accelerated decoding", "format" },
1893  { "hwaccels", OPT_TYPE_FUNC, OPT_EXIT | OPT_EXPERT,
1894  { .func_arg = show_hwaccels },
1895  "show available HW acceleration methods" },
1896  { "autorotate", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1897  { .off = OFFSET(autorotate) },
1898  "automatically insert correct rotate filters" },
1900  { .off = OFFSET(autoscale) },
1901  "automatically insert a scale filter at the end of the filter graph" },
1902  { "apply_cropping", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1903  { .off = OFFSET(apply_cropping) },
1904  "select the cropping to apply" },
1905  { "fix_sub_duration_heartbeat", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1906  { .off = OFFSET(fix_sub_duration_heartbeat) },
1907  "set this video output stream to be a heartbeat stream for "
1908  "fix_sub_duration, according to which subtitles should be split at "
1909  "random access points" },
1910 
1911  /* audio options */
1913  { .func_arg = opt_audio_frames },
1914  "set the number of audio frames to output", "number",
1915  .u1.name_canon = "frames", },
1917  { .func_arg = opt_audio_qscale },
1918  "set audio quality (codec-specific)", "quality", },
1920  { .off = OFFSET(audio_sample_rate) },
1921  "set audio sampling rate (in Hz)", "rate" },
1923  { .off = OFFSET(audio_channels) },
1924  "set number of audio channels", "channels" },
1926  { .off = OFFSET(audio_disable) },
1927  "disable audio" },
1929  { .func_arg = opt_audio_codec },
1930  "alias for -c:a (select encoder/decoder for audio streams)", "codec",
1931  .u1.name_canon = "codec", },
1933  { .func_arg = opt_bitrate },
1934  "alias for -b:a (select bitrate for audio streams)", "bitrate" },
1936  { .off = OFFSET(apad) },
1937  "audio pad", "" },
1939  { .func_arg = opt_old2new },
1940  "force audio tag/fourcc", "fourcc/tag",
1941  .u1.name_canon = "tag", },
1943  { .off = OFFSET(sample_fmts) },
1944  "set sample format", "format" },
1946  { .off = OFFSET(audio_ch_layouts) },
1947  "set channel layout", "layout",
1948  .u1.names_alt = alt_channel_layout, },
1950  { .off = OFFSET(audio_ch_layouts) },
1951  "set channel layout", "layout",
1952  .u1.name_canon = "channel_layout", },
1954  { .func_arg = opt_audio_filters },
1955  "alias for -filter:a (apply filters to audio streams)", "filter_graph",
1956  .u1.name_canon = "filter", },
1957  { "guess_layout_max", OPT_TYPE_INT, OPT_AUDIO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1958  { .off = OFFSET(guess_layout_max) },
1959  "set the maximum number of channels to try to guess the channel layout" },
1960 
1961  /* subtitle options */
1963  { .off = OFFSET(subtitle_disable) },
1964  "disable subtitle" },
1966  { .func_arg = opt_subtitle_codec },
1967  "alias for -c:s (select encoder/decoder for subtitle streams)", "codec",
1968  .u1.name_canon = "codec", },
1970  { .func_arg = opt_old2new }
1971  , "force subtitle tag/fourcc", "fourcc/tag",
1972  .u1.name_canon = "tag" },
1973  { "fix_sub_duration", OPT_TYPE_BOOL, OPT_EXPERT | OPT_SUBTITLE | OPT_PERSTREAM | OPT_INPUT,
1974  { .off = OFFSET(fix_sub_duration) },
1975  "fix subtitles duration" },
1977  { .off = OFFSET(canvas_sizes) },
1978  "set canvas size (WxH or abbreviation)", "size" },
1979 
1980  /* muxer options */
1981  { "muxdelay", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1982  { .off = OFFSET(mux_max_delay) },
1983  "set the maximum demux-decode delay", "seconds" },
1984  { "muxpreload", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1985  { .off = OFFSET(mux_preload) },
1986  "set the initial demux-decode delay", "seconds" },
1987  { "sdp_file", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_OUTPUT,
1988  { .func_arg = opt_sdp_file },
1989  "specify a file in which to print sdp information", "file" },
1990 
1991  { "time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1992  { .off = OFFSET(time_bases) },
1993  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
1994  { "enc_time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1995  { .off = OFFSET(enc_time_bases) },
1996  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
1997  "two special values are defined - "
1998  "0 = use frame rate (video) or sample rate (audio),"
1999  "-1 = match source time base", "ratio" },
2000 
2002  { .off = OFFSET(bitstream_filters) },
2003  "A comma-separated list of bitstream filters", "bitstream_filters", },
2004 
2006  { .func_arg = opt_preset },
2007  "set the audio options to the indicated preset", "preset",
2008  .u1.name_canon = "pre", },
2010  { .func_arg = opt_preset },
2011  "set the video options to the indicated preset", "preset",
2012  .u1.name_canon = "pre", },
2014  { .func_arg = opt_preset },
2015  "set the subtitle options to the indicated preset", "preset",
2016  .u1.name_canon = "pre", },
2018  { .func_arg = opt_preset },
2019  "set options from indicated preset file", "filename",
2020  .u1.name_canon = "pre", },
2021 
2022  { "max_muxing_queue_size", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
2023  { .off = OFFSET(max_muxing_queue_size) },
2024  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2025  { "muxing_queue_data_threshold", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
2026  { .off = OFFSET(muxing_queue_data_threshold) },
2027  "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
2028 
2029  /* data codec support */
2031  { .func_arg = opt_data_codec },
2032  "alias for -c:d (select encoder/decoder for data streams)", "codec",
2033  .u1.name_canon = "codec", },
2035  { .off = OFFSET(data_disable) }, "disable data" },
2036 
2037 #if CONFIG_VAAPI
2038  { "vaapi_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2039  { .func_arg = opt_vaapi_device },
2040  "set VAAPI hardware device (DirectX adapter index, DRM path or X11 display name)", "device" },
2041 #endif
2042 
2043 #if CONFIG_QSV
2044  { "qsv_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2045  { .func_arg = opt_qsv_device },
2046  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
2047 #endif
2048 
2049  { "init_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2050  { .func_arg = opt_init_hw_device },
2051  "initialise hardware device", "args" },
2052  { "filter_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2053  { .func_arg = opt_filter_hw_device },
2054  "set hardware device used when filtering", "device" },
2055 
2056  // deprecated options
2057 #if FFMPEG_OPT_ADRIFT_THRESHOLD
2058  { "adrift_threshold", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2059  { .func_arg = opt_adrift_threshold },
2060  "deprecated, does nothing", "threshold" },
2061 #endif
2062 #if FFMPEG_OPT_TOP
2064  { .off = OFFSET(top_field_first) },
2065  "deprecated, use the setfield video filter", "" },
2066 #endif
2067 #if FFMPEG_OPT_QPHIST
2068  { "qphist", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
2069  { .func_arg = opt_qphist },
2070  "deprecated, does nothing" },
2071 #endif
2072 #if FFMPEG_OPT_VSYNC
2073  { "vsync", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2074  { .func_arg = opt_vsync },
2075  "set video sync method globally; deprecated, use -fps_mode", "" },
2076 #endif
2077 
2078  { NULL, },
2079 };
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:203
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:107
AVCodec
AVCodec.
Definition: codec.h:187
fix_sub_duration_heartbeat
static int fix_sub_duration_heartbeat(DecoderPriv *dp, int64_t signal_pts)
Definition: ffmpeg_dec.c:617
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
InputFile::start_time
int64_t start_time
Definition: ffmpeg.h:482
ignore_unknown_streams
int ignore_unknown_streams
Definition: ffmpeg_opt.c:85
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:189
StreamMap::file_index
int file_index
Definition: ffmpeg.h:136
show_hwaccels
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:152
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
AV_STEREO3D_VIEW_LEFT
@ AV_STEREO3D_VIEW_LEFT
Frame contains only the left view.
Definition: stereo3d.h:158
opt_abort_on
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:426
VSYNC_VFR
@ VSYNC_VFR
Definition: ffmpeg.h:69
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:105
opt.h
assert_file_overwrite
int assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:744
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
opt_video_filters
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1120
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:1205
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:70
stats_period
int64_t stats_period
Definition: ffmpeg_opt.c:80
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:761
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
opt_old2new
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1063
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
stream_specifier_parse
int stream_specifier_parse(StreamSpecifier *ss, const char *spec, int allow_remainder, void *logctx)
Parse a stream specifier string into a form suitable for matching.
Definition: cmdutils.c:1009
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:201
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:85
no_file_overwrite
static int no_file_overwrite
Definition: ffmpeg_opt.c:84
opt_default_new
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:993
OptionsContext::nb_attachments
int nb_attachments
Definition: ffmpeg.h:184
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:1006
auto_conversion_filters
int auto_conversion_filters
Definition: ffmpeg_opt.c:79
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:463
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1368
OptionsContext::mux_max_delay
float mux_max_delay
Definition: ffmpeg.h:192
OPT_FLAG_OFFSET
#define OPT_FLAG_OFFSET
Definition: cmdutils.h:219
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:233
copy_unknown_streams
int copy_unknown_streams
Definition: ffmpeg_opt.c:86
parse_number
int parse_number(const char *context, const char *numstr, enum OptionType type, double min, double max, double *dst)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:84
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
StreamSpecifier
Definition: cmdutils.h:113
AVOption
AVOption.
Definition: opt.h:429
OptionGroupList::groups
OptionGroup * groups
Definition: cmdutils.h:356
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:357
opt_timelimit
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
filter_hw_device
HWDevice * filter_hw_device
Definition: ffmpeg_opt.c:51
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
progress_avio
AVIOContext * progress_avio
Definition: ffmpeg.c:102
opt_filter_hw_device
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:674
fg_create
int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch)
Create a new filtergraph in the global filtergraph list.
Definition: ffmpeg_filter.c:1055
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:472
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:140
av_hwdevice_iterate_types
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:121
autorotate
static int autorotate
Definition: ffplay.c:348
ViewSpecifier
Definition: ffmpeg.h:128
UNKNOWN
@ UNKNOWN
Definition: ftp.c:39
video_disable
static int video_disable
Definition: ffplay.c:315
mathematics.h
AVDictionary
Definition: dict.c:34
HWDevice
Definition: ffmpeg.h:109
hw_device_init_from_string
int hw_device_init_from_string(const char *arg, HWDevice **dev)
Definition: ffmpeg_hw.c:92
VIEW_SPECIFIER_TYPE_ALL
@ VIEW_SPECIFIER_TYPE_ALL
Definition: ffmpeg.h:125
do_benchmark
int do_benchmark
Definition: ffmpeg_opt.c:63
AV_STEREO3D_VIEW_RIGHT
@ AV_STEREO3D_VIEW_RIGHT
Frame contains only the right view.
Definition: stereo3d.h:163
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
GlobalOptionsContext
Definition: ffmpeg_opt.c:91
OptionDef
Definition: cmdutils.h:191
subtitle_disable
static int subtitle_disable
Definition: ffplay.c:316
OPT_DATA
#define OPT_DATA
Definition: cmdutils.h:211
stream_specifier_uninit
void stream_specifier_uninit(StreamSpecifier *ss)
Definition: cmdutils.c:1000
SpecifierOpt::i
int i
Definition: cmdutils.h:171
OptionsContext::chapters_input_file
int chapters_input_file
Definition: ffmpeg.h:186
opt_filter_threads
static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:419
do_hex_dump
int do_hex_dump
Definition: ffmpeg_opt.c:65
OptionGroupList
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:353
bsf.h
do_pkt_dump
int do_pkt_dump
Definition: ffmpeg_opt.c:66
uninit_options
static void uninit_options(OptionsContext *o)
Definition: ffmpeg_opt.c:98
presets
static const Preset presets[]
Definition: vf_pseudocolor.c:286
opt_timecode
static int opt_timecode(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1140
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:144
fail
#define fail()
Definition: checkasm.h:188
StreamMap::disabled
int disabled
Definition: ffmpeg.h:135
GlobalOptionsContext::nb_filtergraphs
int nb_filtergraphs
Definition: ffmpeg_opt.c:95
opt_data_frames
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:987
VIEW_SPECIFIER_TYPE_POS
@ VIEW_SPECIFIER_TYPE_POS
Definition: ffmpeg.h:123
ifile_open
int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_demux.c:1588
OptionParseContext
Definition: cmdutils.h:360
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
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:97
OptionsContext
Definition: ffmpeg.h:143
OPT_TYPE_FLOAT
@ OPT_TYPE_FLOAT
Definition: cmdutils.h:86
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
loop
static int loop
Definition: ffplay.c:335
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:1126
InputFile
Definition: ffmpeg.h:468
opt_filter_complex_script
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1181
OptionGroupDef
Definition: cmdutils.h:321
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
OptionsContext::recording_time
int64_t recording_time
Definition: ffmpeg.h:188
OPT_PERSTREAM
#define OPT_PERSTREAM
Definition: cmdutils.h:229
OptionsContext::nb_stream_maps
int nb_stream_maps
Definition: ffmpeg.h:182
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM
#define ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM
Definition: ffmpeg.h:501
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:343
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:181
StreamMap::vs
ViewSpecifier vs
Definition: ffmpeg.h:140
opt_attach
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:607
opt_recording_timestamp
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:688
StreamMap::linklabel
char * linklabel
Definition: ffmpeg.h:138
SpecifierOpt::specifier
char * specifier
Definition: cmdutils.h:165
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
stereo3d.h
SpecifierOptList::type
enum OptionType type
Definition: cmdutils.h:188
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:787
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::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1312
g
const char * g
Definition: vf_curves.c:128
OptionsContext::limit_filesize
int64_t limit_filesize
Definition: ffmpeg.h:190
VIEW_SPECIFIER_TYPE_NONE
@ VIEW_SPECIFIER_TYPE_NONE
Definition: ffmpeg.h:117
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:178
OPT_TYPE_DOUBLE
@ OPT_TYPE_DOUBLE
Definition: cmdutils.h:87
opt_audio_qscale
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1154
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:55
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
term_init
void term_init(void)
Definition: ffmpeg.c:201
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:71
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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:131
opt_match_per_stream
static unsigned opt_match_per_stream(void *logctx, enum OptionType type, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st)
Definition: ffmpeg_opt.c:177
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:112
do_benchmark_all
int do_benchmark_all
Definition: ffmpeg_opt.c:64
OptionsContext::accurate_seek
int accurate_seek
Definition: ffmpeg.h:167
key
const char * key
Definition: hwcontext_opencl.c:189
opt_video_frames
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:975
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:372
sch_sdp_filename
int sch_sdp_filename(Scheduler *sch, const char *sdp_filename)
Set the file path for the SDP.
Definition: ffmpeg_sched.c:619
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
OPT_SPEC
#define OPT_SPEC
Definition: cmdutils.h:225
OptionsContext::start_time
int64_t start_time
Definition: ffmpeg.h:147
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:344
opts
AVDictionary * opts
Definition: movenc.c:51
opt_target
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:809
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
open_file
static int open_file(AVFormatContext *avf, unsigned fileno)
Definition: concatdec.c:335
opt_profile
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
dec_create
int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch)
Create a standalone decoder.
Definition: ffmpeg_dec.c:1674
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:184
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:787
NULL
#define NULL
Definition: coverity.c:32
OPT_HAS_ALT
#define OPT_HAS_ALT
Definition: cmdutils.h:238
OptionParseContext::global_opts
OptionGroup global_opts
Definition: cmdutils.h:361
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:1039
av_bsf_get_class
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:99
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:207
swr_get_class
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:143
InputFile::start_time_effective
int64_t start_time_effective
Effective format start time based on enabled streams.
Definition: ffmpeg.h:479
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
parseutils.h
GlobalOptionsContext::sch
Scheduler * sch
Definition: ffmpeg_opt.c:92
ViewSpecifier::val
unsigned val
Definition: ffmpeg.h:130
double
double
Definition: af_crystalizer.c:132
parse_and_set_vsync
int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
Definition: ffmpeg_opt.c:294
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:589
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
stream_specifier_match
unsigned stream_specifier_match(const StreamSpecifier *ss, const AVFormatContext *s, const AVStream *st, void *logctx)
Definition: cmdutils.c:1224
OptionsContext::input_sync_ref
int input_sync_ref
Definition: ffmpeg.h:169
OptionGroup
Definition: cmdutils.h:336
correct_input_start_times
static void correct_input_start_times(void)
Definition: ffmpeg_opt.c:330
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:352
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
input_files
InputFile ** input_files
Definition: ffmpeg.c:104
Scheduler
Definition: ffmpeg_sched.c:275
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1011
opt_streamid
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:790
file_read
char * file_read(const char *filename)
Definition: cmdutils.c:1495
opt_preset
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1013
opt_vstats_file
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:952
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
options
const OptionDef options[]
VideoSyncMethod
VideoSyncMethod
Definition: ffmpeg.h:65
opt_bitrate
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1075
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:381
max_error_rate
float max_error_rate
Definition: ffmpeg_opt.c:75
frame_sizes
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
OptionsContext::thread_queue_size
int thread_queue_size
Definition: ffmpeg.h:168
AVMediaType
AVMediaType
Definition: avutil.h:199
OPT_TYPE_INT
@ OPT_TYPE_INT
Definition: cmdutils.h:84
opt_init_hw_device
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:659
SpecifierOptList
Definition: cmdutils.h:179
OPT_AUDIO
#define OPT_AUDIO
Definition: cmdutils.h:209
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
opt_map
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:487
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:122
start_time
static int64_t start_time
Definition: ffplay.c:326
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1416
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:921
StreamMap
Definition: ffmpeg.h:134
file_overwrite
static int file_overwrite
Definition: ffmpeg_opt.c:83
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
opt_subtitle_codec
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:475
OptionsContext::streamid
AVDictionary * streamid
Definition: ffmpeg.h:203
PAL
#define PAL
Definition: bktr.c:68
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:664
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:53
OPT_TYPE_INT64
@ OPT_TYPE_INT64
Definition: cmdutils.h:85
printf
printf("static const uint8_t my_array[100] = {\n")
OptionType
OptionType
Definition: cmdutils.h:80
show_usage
void show_usage(void)
Definition: ffmpeg_opt.c:1322
opt_sdp_file
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:621
fg_finalise_bindings
int fg_finalise_bindings(void)
Definition: ffmpeg_filter.c:1404
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
OPT_FLAG_SPEC
#define OPT_FLAG_SPEC
Definition: cmdutils.h:224
OptionsContext::find_stream_info
int find_stream_info
Definition: ffmpeg.h:170
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:180
line
Definition: graph2dot.c:48
opt_data_codec
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:481
init_options
static void init_options(OptionsContext *o)
Definition: ffmpeg_opt.c:134
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:223
NTSC
#define NTSC
Definition: bktr.c:70
OPT_TYPE_FUNC
@ OPT_TYPE_FUNC
Definition: cmdutils.h:81
OPT_DECODER
#define OPT_DECODER
Definition: cmdutils.h:244
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
video_sync_method
enum VideoSyncMethod video_sync_method
Definition: ffmpeg_opt.c:60
OPT_HAS_CANON
#define OPT_HAS_CANON
Definition: cmdutils.h:241
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
start_at_zero
int start_at_zero
Definition: ffmpeg_opt.c:68
OptionDef::u1
union OptionDef::@2 u1
apply_sync_offsets
static int apply_sync_offsets(void)
Definition: ffmpeg_opt.c:367
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
StreamMap::stream_index
int stream_index
Definition: ffmpeg.h:137
OPT_TYPE_TIME
@ OPT_TYPE_TIME
Definition: cmdutils.h:88
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:152
OptionsContext::stream_maps
StreamMap * stream_maps
Definition: ffmpeg.h:181
OptionsContext::start_time_eof
int64_t start_time_eof
Definition: ffmpeg.h:148
VSYNC_CFR
@ VSYNC_CFR
Definition: ffmpeg.h:68
OptionsContext::shortest_buf_duration
float shortest_buf_duration
Definition: ffmpeg.h:193
opt_video_codec
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:469
opt_qscale
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1091
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:74
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
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:473
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:358
OPT_FUNC_ARG
#define OPT_FUNC_ARG
Definition: cmdutils.h:201
opt_vstats
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:959
OPT_OUTPUT
#define OPT_OUTPUT
Definition: cmdutils.h:234
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
dts_error_threshold
float dts_error_threshold
Definition: ffmpeg_opt.c:57
cmdutils_isalnum
int cmdutils_isalnum(char c)
Definition: cmdutils.c:993
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:307
OPT_OFFSET
#define OPT_OFFSET
Definition: cmdutils.h:220
OptionParseContext::groups
OptionGroupList * groups
Definition: cmdutils.h:363
opt_audio_frames
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:981
avcodec.h
SpecifierOpt::i64
int64_t i64
Definition: cmdutils.h:172
SpecifierOptList::opt_canon
const struct OptionDef * opt_canon
Definition: cmdutils.h:184
av_opt_eval_flags
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
SpecifierOpt
Definition: cmdutils.h:163
find_codec
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **pcodec)
Definition: ffmpeg_opt.c:711
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:203
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:910
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:80
VIEW_SPECIFIER_TYPE_IDX
@ VIEW_SPECIFIER_TYPE_IDX
Definition: ffmpeg.h:119
VSYNC_DROP
@ VSYNC_DROP
Definition: ffmpeg.h:72
uninit_parse_context
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:762
OPT_PERFILE
#define OPT_PERFILE
Definition: cmdutils.h:215
SpecifierOpt::stream_spec
StreamSpecifier stream_spec
Definition: cmdutils.h:167
find_stream_info
static int find_stream_info
Definition: ffplay.c:349
avformat.h
CMDUTILS_COMMON_OPTIONS
#define CMDUTILS_COMMON_OPTIONS
Definition: opt_common.h:199
filter_nbthreads
char * filter_nbthreads
Definition: ffmpeg_opt.c:76
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
OPT_FLAG_PERSTREAM
#define OPT_FLAG_PERSTREAM
Definition: cmdutils.h:228
parse_option
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:377
OptionsContext::mux_preload
float mux_preload
Definition: ffmpeg.h:191
audio_drift_threshold
float audio_drift_threshold
Definition: ffmpeg_opt.c:55
OptionDef::names_alt
const char *const * names_alt
Definition: cmdutils.h:260
opt_match_per_type_str
const char * opt_match_per_type_str(const SpecifierOptList *sol, char mediatype)
Definition: ffmpeg_opt.c:164
opt_common.h
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:170
OPT_SUBTITLE
#define OPT_SUBTITLE
Definition: cmdutils.h:210
avfilter.h
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:143
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ffmpeg_parse_options
int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:532
InputFile::ts_offset
int64_t ts_offset
Definition: ffmpeg.h:480
VSYNC_AUTO
@ VSYNC_AUTO
Definition: ffmpeg.h:66
opt_vsync
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1133
parse_optgroup
int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
Parse an options group and write results into optctx.
Definition: cmdutils.c:453
GlobalOptionsContext::filtergraphs
char ** filtergraphs
Definition: ffmpeg_opt.c:94
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:54
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:596
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
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:356
desc
const char * desc
Definition: libsvtav1.c:79
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:56
avutil.h
ViewSpecifier::type
enum ViewSpecifierType type
Definition: ffmpeg.h:129
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
copy_tb
int copy_tb
Definition: ffmpeg_opt.c:69
SpecifierOpt::u
union SpecifierOpt::@0 u
opt_stats_period
static int opt_stats_period(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:445
vstats_version
int vstats_version
Definition: ffmpeg_opt.c:78
avio_open2
int avio_open2(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:491
of_open
int of_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_mux_init.c:3262
OptionDef::name
const char * name
Definition: cmdutils.h:192
ffmpeg_sched.h
OPT_VIDEO
#define OPT_VIDEO
Definition: cmdutils.h:208
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
OptionsContext::attachments
const char ** attachments
Definition: ffmpeg.h:183
SpecifierOpt::dbl
double dbl
Definition: cmdutils.h:175
OPT_TYPE_STRING
@ OPT_TYPE_STRING
Definition: cmdutils.h:83
audio_disable
static int audio_disable
Definition: ffplay.c:314
VIEW_SPECIFIER_TYPE_ID
@ VIEW_SPECIFIER_TYPE_ID
Definition: ffmpeg.h:121
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:88
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:237
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:67
cmdutils.h
OFFSET
#define OFFSET(x)
InputFile::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:474
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:657
codec_string
Definition: dashenc.c:209
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
frame_drop_threshold
float frame_drop_threshold
Definition: ffmpeg_opt.c:62
recast_media
int recast_media
Definition: ffmpeg_opt.c:87
view_specifier_parse
int view_specifier_parse(const char **pspec, ViewSpecifier *vs)
Definition: ffmpeg_opt.c:241
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:85
print_stats
int print_stats
Definition: ffmpeg_opt.c:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:797
avstring.h
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3774
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:488
OPT_MATCH_PER_STREAM
#define OPT_MATCH_PER_STREAM(name, type, opt_type, m)
Definition: ffmpeg_opt.c:227
hw_device_get_by_name
HWDevice * hw_device_get_by_name(const char *name)
Definition: ffmpeg_hw.c:42
avfilter_get_class
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1634
dump_attachment
static int dump_attachment(InputStream *ist, const char *filename)
Definition: ffmpeg_demux.c:1521
VSYNC_PASSTHROUGH
@ VSYNC_PASSTHROUGH
Definition: ffmpeg.h:67
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
ABORT_ON_FLAG_EMPTY_OUTPUT
#define ABORT_ON_FLAG_EMPTY_OUTPUT
Definition: ffmpeg.h:500
SpecifierOpt::f
float f
Definition: cmdutils.h:174
opt_filter_complex
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1160
avcodec_find_encoder_by_name
const AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:1034
dts_delta_threshold
float dts_delta_threshold
Definition: ffmpeg_opt.c:56
abort_on_flags
int abort_on_flags
Definition: ffmpeg_opt.c:72
filter_complex_nbthreads
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:77
OptionDef::flags
int flags
Definition: cmdutils.h:194