FFmpeg
cmdutils.c
Go to the documentation of this file.
1 /*
2  * Various utilities for command line tools
3  * Copyright (c) 2000-2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <string.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <errno.h>
26 #include <math.h>
27 
28 /* Include only the enabled headers since some compilers (namely, Sun
29  Studio) will not omit unused inline functions and create undefined
30  references to libraries that are not being built. */
31 
32 #include "config.h"
33 #include "compat/va_copy.h"
34 #include "libavformat/avformat.h"
35 #include "libswscale/swscale.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/display.h"
41 #include "libavutil/getenv_utf8.h"
42 #include "libavutil/libm.h"
43 #include "libavutil/mem.h"
44 #include "libavutil/parseutils.h"
45 #include "libavutil/eval.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/opt.h"
48 #include "cmdutils.h"
49 #include "fopen_utf8.h"
50 #include "opt_common.h"
51 #ifdef _WIN32
52 #include <windows.h>
53 #include "compat/w32dlfcn.h"
54 #endif
55 
59 
60 int hide_banner = 0;
61 
62 void uninit_opts(void)
63 {
68 }
69 
70 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
71 {
72  vfprintf(stdout, fmt, vl);
73 }
74 
75 void init_dynload(void)
76 {
77 #if HAVE_SETDLLDIRECTORY && defined(_WIN32)
78  /* Calling SetDllDirectory with the empty string (but not NULL) removes the
79  * current working directory from the DLL search path as a security pre-caution. */
80  SetDllDirectory("");
81 #endif
82 }
83 
84 int parse_number(const char *context, const char *numstr, enum OptionType type,
85  double min, double max, double *dst)
86 {
87  char *tail;
88  const char *error;
89  double d = av_strtod(numstr, &tail);
90  if (*tail)
91  error = "Expected number for %s but found: %s\n";
92  else if (d < min || d > max)
93  error = "The value for %s was %s which is not within %f - %f\n";
94  else if (type == OPT_TYPE_INT64 && (int64_t)d != d)
95  error = "Expected int64 for %s but found %s\n";
96  else if (type == OPT_TYPE_INT && (int)d != d)
97  error = "Expected int for %s but found %s\n";
98  else {
99  *dst = d;
100  return 0;
101  }
102 
103  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
104  return AVERROR(EINVAL);
105 }
106 
107 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
108  int rej_flags)
109 {
110  const OptionDef *po;
111  int first;
112 
113  first = 1;
114  for (po = options; po->name; po++) {
115  char buf[128];
116 
117  if (((po->flags & req_flags) != req_flags) ||
118  (po->flags & rej_flags))
119  continue;
120 
121  if (first) {
122  printf("%s\n", msg);
123  first = 0;
124  }
125  av_strlcpy(buf, po->name, sizeof(buf));
126 
127  if (po->flags & OPT_FLAG_PERSTREAM)
128  av_strlcat(buf, "[:<stream_spec>]", sizeof(buf));
129  else if (po->flags & OPT_FLAG_SPEC)
130  av_strlcat(buf, "[:<spec>]", sizeof(buf));
131 
132  if (po->argname)
133  av_strlcatf(buf, sizeof(buf), " <%s>", po->argname);
134 
135  printf("-%-17s %s\n", buf, po->help);
136  }
137  printf("\n");
138 }
139 
140 void show_help_children(const AVClass *class, int flags)
141 {
142  void *iter = NULL;
143  const AVClass *child;
144  if (class->option) {
145  av_opt_show2(&class, NULL, flags, 0);
146  printf("\n");
147  }
148 
149  while (child = av_opt_child_class_iterate(class, &iter))
150  show_help_children(child, flags);
151 }
152 
153 static const OptionDef *find_option(const OptionDef *po, const char *name)
154 {
155  if (*name == '/')
156  name++;
157 
158  while (po->name) {
159  const char *end;
160  if (av_strstart(name, po->name, &end) && (!*end || *end == ':'))
161  break;
162  po++;
163  }
164  return po;
165 }
166 
167 /* _WIN32 means using the windows libc - cygwin doesn't define that
168  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
169  * it doesn't provide the actual command line via GetCommandLineW(). */
170 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
171 #include <shellapi.h>
172 /* Will be leaked on exit */
173 static char** win32_argv_utf8 = NULL;
174 static int win32_argc = 0;
175 
176 /**
177  * Prepare command line arguments for executable.
178  * For Windows - perform wide-char to UTF-8 conversion.
179  * Input arguments should be main() function arguments.
180  * @param argc_ptr Arguments number (including executable)
181  * @param argv_ptr Arguments list.
182  */
183 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
184 {
185  char *argstr_flat;
186  wchar_t **argv_w;
187  int i, buffsize = 0, offset = 0;
188 
189  if (win32_argv_utf8) {
190  *argc_ptr = win32_argc;
191  *argv_ptr = win32_argv_utf8;
192  return;
193  }
194 
195  win32_argc = 0;
196  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
197  if (win32_argc <= 0 || !argv_w)
198  return;
199 
200  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
201  for (i = 0; i < win32_argc; i++)
202  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
203  NULL, 0, NULL, NULL);
204 
205  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
206  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
207  if (!win32_argv_utf8) {
208  LocalFree(argv_w);
209  return;
210  }
211 
212  for (i = 0; i < win32_argc; i++) {
213  win32_argv_utf8[i] = &argstr_flat[offset];
214  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
215  &argstr_flat[offset],
216  buffsize - offset, NULL, NULL);
217  }
218  win32_argv_utf8[i] = NULL;
219  LocalFree(argv_w);
220 
221  *argc_ptr = win32_argc;
222  *argv_ptr = win32_argv_utf8;
223 }
224 #else
225 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
226 {
227  /* nothing to do */
228 }
229 #endif /* HAVE_COMMANDLINETOARGVW */
230 
231 static int opt_has_arg(const OptionDef *o)
232 {
233  if (o->type == OPT_TYPE_BOOL)
234  return 0;
235  if (o->type == OPT_TYPE_FUNC)
236  return !!(o->flags & OPT_FUNC_ARG);
237  return 1;
238 }
239 
240 static int write_option(void *optctx, const OptionDef *po, const char *opt,
241  const char *arg, const OptionDef *defs)
242 {
243  /* new-style options contain an offset into optctx, old-style address of
244  * a global var*/
245  void *dst = po->flags & OPT_FLAG_OFFSET ?
246  (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
247  char *arg_allocated = NULL;
248 
249  enum OptionType so_type = po->type;
250 
251  SpecifierOptList *sol = NULL;
252  double num;
253  int ret = 0;
254 
255  if (*opt == '/') {
256  opt++;
257 
258  if (!opt_has_arg(po)) {
260  "Requested to load an argument from file for an option '%s'"
261  " which does not take an argument\n",
262  po->name);
263  return AVERROR(EINVAL);
264  }
265 
266  arg_allocated = file_read(arg);
267  if (!arg_allocated) {
269  "Error reading the value for option '%s' from file: %s\n",
270  opt, arg);
271  return AVERROR(EINVAL);
272  }
273 
274  arg = arg_allocated;
275  }
276 
277  if (po->flags & OPT_FLAG_SPEC) {
278  char *p = strchr(opt, ':');
279  char *str;
280 
281  sol = dst;
282  ret = GROW_ARRAY(sol->opt, sol->nb_opt);
283  if (ret < 0)
284  goto finish;
285 
286  str = av_strdup(p ? p + 1 : "");
287  if (!str) {
288  ret = AVERROR(ENOMEM);
289  goto finish;
290  }
291  sol->opt[sol->nb_opt - 1].specifier = str;
292 
293  if (po->flags & OPT_FLAG_PERSTREAM) {
294  ret = stream_specifier_parse(&sol->opt[sol->nb_opt - 1].stream_spec,
295  str, 0, NULL);
296  if (ret < 0)
297  goto finish;
298  }
299 
300  dst = &sol->opt[sol->nb_opt - 1].u;
301  }
302 
303  if (po->type == OPT_TYPE_STRING) {
304  char *str;
305  if (arg_allocated) {
306  str = arg_allocated;
307  arg_allocated = NULL;
308  } else
309  str = av_strdup(arg);
310  av_freep(dst);
311 
312  if (!str) {
313  ret = AVERROR(ENOMEM);
314  goto finish;
315  }
316 
317  *(char **)dst = str;
318  } else if (po->type == OPT_TYPE_BOOL || po->type == OPT_TYPE_INT) {
319  ret = parse_number(opt, arg, OPT_TYPE_INT64, INT_MIN, INT_MAX, &num);
320  if (ret < 0)
321  goto finish;
322 
323  *(int *)dst = num;
324  so_type = OPT_TYPE_INT;
325  } else if (po->type == OPT_TYPE_INT64) {
326  ret = parse_number(opt, arg, OPT_TYPE_INT64, INT64_MIN, (double)INT64_MAX, &num);
327  if (ret < 0)
328  goto finish;
329 
330  *(int64_t *)dst = num;
331  } else if (po->type == OPT_TYPE_TIME) {
332  ret = av_parse_time(dst, arg, 1);
333  if (ret < 0) {
334  av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n",
335  opt, arg);
336  goto finish;
337  }
338  so_type = OPT_TYPE_INT64;
339  } else if (po->type == OPT_TYPE_FLOAT) {
341  if (ret < 0)
342  goto finish;
343 
344  *(float *)dst = num;
345  } else if (po->type == OPT_TYPE_DOUBLE) {
347  if (ret < 0)
348  goto finish;
349 
350  *(double *)dst = num;
351  } else {
352  av_assert0(po->type == OPT_TYPE_FUNC && po->u.func_arg);
353 
354  ret = po->u.func_arg(optctx, opt, arg);
355  if (ret < 0) {
356  if ((strcmp(opt, "init_hw_device") != 0) || (strcmp(arg, "list") != 0)) {
358  "Failed to set value '%s' for option '%s': %s\n",
359  arg, opt, av_err2str(ret));
360  }
361  goto finish;
362  }
363  }
364  if (po->flags & OPT_EXIT) {
365  ret = AVERROR_EXIT;
366  goto finish;
367  }
368 
369  if (sol) {
370  sol->type = so_type;
371  sol->opt_canon = (po->flags & OPT_HAS_CANON) ?
372  find_option(defs, po->u1.name_canon) : po;
373  }
374 
375 finish:
376  av_freep(&arg_allocated);
377  return ret;
378 }
379 
380 int parse_option(void *optctx, const char *opt, const char *arg,
381  const OptionDef *options)
382 {
383  static const OptionDef opt_avoptions = {
384  .name = "AVOption passthrough",
385  .type = OPT_TYPE_FUNC,
386  .flags = OPT_FUNC_ARG,
387  .u.func_arg = opt_default,
388  };
389 
390  const OptionDef *po;
391  int ret;
392 
393  po = find_option(options, opt);
394  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
395  /* handle 'no' bool option */
396  po = find_option(options, opt + 2);
397  if ((po->name && po->type == OPT_TYPE_BOOL))
398  arg = "0";
399  } else if (po->type == OPT_TYPE_BOOL)
400  arg = "1";
401 
402  if (!po->name)
403  po = &opt_avoptions;
404  if (!po->name) {
405  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
406  return AVERROR(EINVAL);
407  }
408  if (opt_has_arg(po) && !arg) {
409  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
410  return AVERROR(EINVAL);
411  }
412 
413  ret = write_option(optctx, po, opt, arg, options);
414  if (ret < 0)
415  return ret;
416 
417  return opt_has_arg(po);
418 }
419 
420 int parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
421  int (*parse_arg_function)(void *, const char*))
422 {
423  const char *opt;
424  int optindex, handleoptions = 1, ret;
425 
426  /* perform system-dependent conversions for arguments list */
427  prepare_app_arguments(&argc, &argv);
428 
429  /* parse options */
430  optindex = 1;
431  while (optindex < argc) {
432  opt = argv[optindex++];
433 
434  if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
435  if (opt[1] == '-' && opt[2] == '\0') {
436  handleoptions = 0;
437  continue;
438  }
439  opt++;
440 
441  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
442  return ret;
443  optindex += ret;
444  } else {
445  if (parse_arg_function) {
446  ret = parse_arg_function(optctx, opt);
447  if (ret < 0)
448  return ret;
449  }
450  }
451  }
452 
453  return 0;
454 }
455 
456 int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
457 {
458  int i, ret;
459 
460  av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
461  g->group_def->name, g->arg);
462 
463  for (i = 0; i < g->nb_opts; i++) {
464  Option *o = &g->opts[i];
465 
466  if (g->group_def->flags &&
467  !(g->group_def->flags & o->opt->flags)) {
468  av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
469  "%s %s -- you are trying to apply an input option to an "
470  "output file or vice versa. Move this option before the "
471  "file it belongs to.\n", o->key, o->opt->help,
472  g->group_def->name, g->arg);
473  return AVERROR(EINVAL);
474  }
475 
476  av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
477  o->key, o->opt->help, o->val);
478 
479  ret = write_option(optctx, o->opt, o->key, o->val, defs);
480  if (ret < 0)
481  return ret;
482  }
483 
484  av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
485 
486  return 0;
487 }
488 
489 int locate_option(int argc, char **argv, const OptionDef *options,
490  const char *optname)
491 {
492  const OptionDef *po;
493  int i;
494 
495  for (i = 1; i < argc; i++) {
496  const char *cur_opt = argv[i];
497 
498  if (!(cur_opt[0] == '-' && cur_opt[1]))
499  continue;
500  cur_opt++;
501 
502  po = find_option(options, cur_opt);
503  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
504  po = find_option(options, cur_opt + 2);
505 
506  if ((!po->name && !strcmp(cur_opt, optname)) ||
507  (po->name && !strcmp(optname, po->name)))
508  return i;
509 
510  if (!po->name || opt_has_arg(po))
511  i++;
512  }
513  return 0;
514 }
515 
516 static void dump_argument(FILE *report_file, const char *a)
517 {
518  const unsigned char *p;
519 
520  for (p = a; *p; p++)
521  if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
522  *p == '_' || (*p >= 'a' && *p <= 'z')))
523  break;
524  if (!*p) {
525  fputs(a, report_file);
526  return;
527  }
528  fputc('"', report_file);
529  for (p = a; *p; p++) {
530  if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
531  fprintf(report_file, "\\%c", *p);
532  else if (*p < ' ' || *p > '~')
533  fprintf(report_file, "\\x%02x", *p);
534  else
535  fputc(*p, report_file);
536  }
537  fputc('"', report_file);
538 }
539 
540 static void check_options(const OptionDef *po)
541 {
542  while (po->name) {
543  if (po->flags & OPT_PERFILE)
545 
546  if (po->type == OPT_TYPE_FUNC)
548 
549  // OPT_FUNC_ARG can only be ser for OPT_TYPE_FUNC
550  av_assert0((po->type == OPT_TYPE_FUNC) || !(po->flags & OPT_FUNC_ARG));
551 
552  po++;
553  }
554 }
555 
556 void parse_loglevel(int argc, char **argv, const OptionDef *options)
557 {
558  int idx;
559  char *env;
560 
562 
563  idx = locate_option(argc, argv, options, "loglevel");
564  if (!idx)
565  idx = locate_option(argc, argv, options, "v");
566  if (idx && argv[idx + 1])
567  opt_loglevel(NULL, "loglevel", argv[idx + 1]);
568  idx = locate_option(argc, argv, options, "report");
569  env = getenv_utf8("FFREPORT");
570  if (env || idx) {
571  FILE *report_file = NULL;
572  init_report(env, &report_file);
573  if (report_file) {
574  int i;
575  fprintf(report_file, "Command line:\n");
576  for (i = 0; i < argc; i++) {
577  dump_argument(report_file, argv[i]);
578  fputc(i < argc - 1 ? ' ' : '\n', report_file);
579  }
580  fflush(report_file);
581  }
582  }
583  freeenv_utf8(env);
584  idx = locate_option(argc, argv, options, "hide_banner");
585  if (idx)
586  hide_banner = 1;
587 }
588 
589 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
590  int opt_flags, int search_flags)
591 {
592  const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
593  if(o && !o->flags)
594  return NULL;
595  return o;
596 }
597 
598 #define FLAGS ((o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0)
599 int opt_default(void *optctx, const char *opt, const char *arg)
600 {
601  const AVOption *o;
602  int consumed = 0;
603  char opt_stripped[128];
604  const char *p;
605  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
606 #if CONFIG_SWSCALE
607  const AVClass *sc = sws_get_class();
608 #endif
609 #if CONFIG_SWRESAMPLE
610  const AVClass *swr_class = swr_get_class();
611 #endif
612 
613  if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
615 
616  if (!(p = strchr(opt, ':')))
617  p = opt + strlen(opt);
618  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
619 
620  if ((o = opt_find(&cc, opt_stripped, NULL, 0,
622  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
623  (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
624  av_dict_set(&codec_opts, opt, arg, FLAGS);
625  consumed = 1;
626  }
627  if ((o = opt_find(&fc, opt, NULL, 0,
629  av_dict_set(&format_opts, opt, arg, FLAGS);
630  if (consumed)
631  av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
632  consumed = 1;
633  }
634 #if CONFIG_SWSCALE
635  if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
637  if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
638  !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
639  !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
640  av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
641  return AVERROR(EINVAL);
642  }
643  av_dict_set(&sws_dict, opt, arg, FLAGS);
644 
645  consumed = 1;
646  }
647 #else
648  if (!consumed && !strcmp(opt, "sws_flags")) {
649  av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
650  consumed = 1;
651  }
652 #endif
653 #if CONFIG_SWRESAMPLE
654  if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
656  av_dict_set(&swr_opts, opt, arg, FLAGS);
657  consumed = 1;
658  }
659 #endif
660 
661  if (consumed)
662  return 0;
664 }
665 
666 /*
667  * Check whether given option is a group separator.
668  *
669  * @return index of the group definition that matched or -1 if none
670  */
671 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
672  const char *opt)
673 {
674  int i;
675 
676  for (i = 0; i < nb_groups; i++) {
677  const OptionGroupDef *p = &groups[i];
678  if (p->sep && !strcmp(p->sep, opt))
679  return i;
680  }
681 
682  return -1;
683 }
684 
685 /*
686  * Finish parsing an option group.
687  *
688  * @param group_idx which group definition should this group belong to
689  * @param arg argument of the group delimiting option
690  */
691 static int finish_group(OptionParseContext *octx, int group_idx,
692  const char *arg)
693 {
694  OptionGroupList *l = &octx->groups[group_idx];
695  OptionGroup *g;
696  int ret;
697 
698  ret = GROW_ARRAY(l->groups, l->nb_groups);
699  if (ret < 0)
700  return ret;
701 
702  g = &l->groups[l->nb_groups - 1];
703 
704  *g = octx->cur_group;
705  g->arg = arg;
706  g->group_def = l->group_def;
707  g->sws_dict = sws_dict;
708  g->swr_opts = swr_opts;
709  g->codec_opts = codec_opts;
710  g->format_opts = format_opts;
711 
712  codec_opts = NULL;
713  format_opts = NULL;
714  sws_dict = NULL;
715  swr_opts = NULL;
716 
717  memset(&octx->cur_group, 0, sizeof(octx->cur_group));
718 
719  return ret;
720 }
721 
722 /*
723  * Add an option instance to currently parsed group.
724  */
725 static int add_opt(OptionParseContext *octx, const OptionDef *opt,
726  const char *key, const char *val)
727 {
728  int global = !(opt->flags & OPT_PERFILE);
729  OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
730  int ret;
731 
732  ret = GROW_ARRAY(g->opts, g->nb_opts);
733  if (ret < 0)
734  return ret;
735 
736  g->opts[g->nb_opts - 1].opt = opt;
737  g->opts[g->nb_opts - 1].key = key;
738  g->opts[g->nb_opts - 1].val = val;
739 
740  return 0;
741 }
742 
744  const OptionGroupDef *groups, int nb_groups)
745 {
746  static const OptionGroupDef global_group = { "global" };
747  int i;
748 
749  memset(octx, 0, sizeof(*octx));
750 
751  octx->groups = av_calloc(nb_groups, sizeof(*octx->groups));
752  if (!octx->groups)
753  return AVERROR(ENOMEM);
754  octx->nb_groups = nb_groups;
755 
756  for (i = 0; i < octx->nb_groups; i++)
757  octx->groups[i].group_def = &groups[i];
758 
759  octx->global_opts.group_def = &global_group;
760  octx->global_opts.arg = "";
761 
762  return 0;
763 }
764 
766 {
767  int i, j;
768 
769  for (i = 0; i < octx->nb_groups; i++) {
770  OptionGroupList *l = &octx->groups[i];
771 
772  for (j = 0; j < l->nb_groups; j++) {
773  av_freep(&l->groups[j].opts);
776 
777  av_dict_free(&l->groups[j].sws_dict);
778  av_dict_free(&l->groups[j].swr_opts);
779  }
780  av_freep(&l->groups);
781  }
782  av_freep(&octx->groups);
783 
784  av_freep(&octx->cur_group.opts);
785  av_freep(&octx->global_opts.opts);
786 
787  uninit_opts();
788 }
789 
790 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
791  const OptionDef *options,
792  const OptionGroupDef *groups, int nb_groups)
793 {
794  int ret;
795  int optindex = 1;
796  int dashdash = -2;
797 
798  /* perform system-dependent conversions for arguments list */
799  prepare_app_arguments(&argc, &argv);
800 
801  ret = init_parse_context(octx, groups, nb_groups);
802  if (ret < 0)
803  return ret;
804 
805  av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
806 
807  while (optindex < argc) {
808  const char *opt = argv[optindex++], *arg;
809  const OptionDef *po;
810  int group_idx;
811 
812  av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
813 
814  if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
815  dashdash = optindex;
816  continue;
817  }
818  /* unnamed group separators, e.g. output filename */
819  if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
820  ret = finish_group(octx, 0, opt);
821  if (ret < 0)
822  return ret;
823 
824  av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
825  continue;
826  }
827  opt++;
828 
829 #define GET_ARG(arg) \
830 do { \
831  arg = argv[optindex++]; \
832  if (!arg) { \
833  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
834  return AVERROR(EINVAL); \
835  } \
836 } while (0)
837 
838  /* named group separators, e.g. -i */
839  group_idx = match_group_separator(groups, nb_groups, opt);
840  if (group_idx >= 0) {
841  GET_ARG(arg);
842  ret = finish_group(octx, group_idx, arg);
843  if (ret < 0)
844  return ret;
845 
846  av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
847  groups[group_idx].name, arg);
848  continue;
849  }
850 
851  /* normal options */
852  po = find_option(options, opt);
853  if (po->name) {
854  if (po->flags & OPT_EXIT) {
855  /* optional argument, e.g. -h */
856  arg = argv[optindex++];
857  } else if (opt_has_arg(po)) {
858  GET_ARG(arg);
859  } else {
860  arg = "1";
861  }
862 
863  ret = add_opt(octx, po, opt, arg);
864  if (ret < 0)
865  return ret;
866 
867  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
868  "argument '%s'.\n", po->name, po->help, arg);
869  continue;
870  }
871 
872  /* AVOptions */
873  if (argv[optindex]) {
874  ret = opt_default(NULL, opt, argv[optindex]);
875  if (ret >= 0) {
876  av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
877  "argument '%s'.\n", opt, argv[optindex]);
878  optindex++;
879  continue;
880  } else if (ret != AVERROR_OPTION_NOT_FOUND) {
881  av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
882  "with argument '%s'.\n", opt, argv[optindex]);
883  return ret;
884  }
885  }
886 
887  /* boolean -nofoo options */
888  if (opt[0] == 'n' && opt[1] == 'o' &&
889  (po = find_option(options, opt + 2)) &&
890  po->name && po->type == OPT_TYPE_BOOL) {
891  ret = add_opt(octx, po, opt, "0");
892  if (ret < 0)
893  return ret;
894 
895  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
896  "argument 0.\n", po->name, po->help);
897  continue;
898  }
899 
900  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
902  }
903 
904  if (octx->cur_group.nb_opts || codec_opts || format_opts)
905  av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
906  "command: may be ignored.\n");
907 
908  av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
909 
910  return 0;
911 }
912 
913 int read_yesno(void)
914 {
915  int c = getchar();
916  int yesno = (av_toupper(c) == 'Y');
917 
918  while (c != '\n' && c != EOF)
919  c = getchar();
920 
921  return yesno;
922 }
923 
924 FILE *get_preset_file(char *filename, size_t filename_size,
925  const char *preset_name, int is_path,
926  const char *codec_name)
927 {
928  FILE *f = NULL;
929  int i;
930 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
931  char *datadir = NULL;
932 #endif
933  char *env_home = getenv_utf8("HOME");
934  char *env_ffmpeg_datadir = getenv_utf8("FFMPEG_DATADIR");
935  const char *base[3] = { env_ffmpeg_datadir,
936  env_home, /* index=1(HOME) is special: search in a .ffmpeg subfolder */
937  FFMPEG_DATADIR, };
938 
939  if (is_path) {
940  av_strlcpy(filename, preset_name, filename_size);
941  f = fopen_utf8(filename, "r");
942  } else {
943 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
944  wchar_t *datadir_w = get_module_filename(NULL);
945  base[2] = NULL;
946 
947  if (wchartoutf8(datadir_w, &datadir))
948  datadir = NULL;
949  av_free(datadir_w);
950 
951  if (datadir)
952  {
953  char *ls;
954  for (ls = datadir; *ls; ls++)
955  if (*ls == '\\') *ls = '/';
956 
957  if (ls = strrchr(datadir, '/'))
958  {
959  ptrdiff_t datadir_len = ls - datadir;
960  size_t desired_size = datadir_len + strlen("/ffpresets") + 1;
961  char *new_datadir = av_realloc_array(
962  datadir, desired_size, sizeof *datadir);
963  if (new_datadir) {
964  datadir = new_datadir;
965  datadir[datadir_len] = 0;
966  strncat(datadir, "/ffpresets", desired_size - 1 - datadir_len);
967  base[2] = datadir;
968  }
969  }
970  }
971 #endif
972  for (i = 0; i < 3 && !f; i++) {
973  if (!base[i])
974  continue;
975  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
976  i != 1 ? "" : "/.ffmpeg", preset_name);
977  f = fopen_utf8(filename, "r");
978  if (!f && codec_name) {
979  snprintf(filename, filename_size,
980  "%s%s/%s-%s.ffpreset",
981  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
982  preset_name);
983  f = fopen_utf8(filename, "r");
984  }
985  }
986  }
987 
988 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
989  av_free(datadir);
990 #endif
991  freeenv_utf8(env_ffmpeg_datadir);
992  freeenv_utf8(env_home);
993  return f;
994 }
995 
997 {
998  return (c >= '0' && c <= '9') ||
999  (c >= 'A' && c <= 'Z') ||
1000  (c >= 'a' && c <= 'z');
1001 }
1002 
1004 {
1005  av_freep(&ss->meta_key);
1006  av_freep(&ss->meta_val);
1007  av_freep(&ss->remainder);
1008 
1009  memset(ss, 0, sizeof(*ss));
1010 }
1011 
1013  int allow_remainder, void *logctx)
1014 {
1015  char *endptr;
1016  int ret;
1017 
1018  memset(ss, 0, sizeof(*ss));
1019 
1020  ss->idx = -1;
1021  ss->media_type = AVMEDIA_TYPE_UNKNOWN;
1022  ss->stream_list = STREAM_LIST_ALL;
1023 
1024  av_log(logctx, AV_LOG_TRACE, "Parsing stream specifier: %s\n", spec);
1025 
1026  while (*spec) {
1027  if (*spec <= '9' && *spec >= '0') { /* opt:index */
1028  ss->idx = strtol(spec, &endptr, 0);
1029 
1030  av_assert0(endptr > spec);
1031  spec = endptr;
1032 
1033  av_log(logctx, AV_LOG_TRACE,
1034  "Parsed index: %d; remainder: %s\n", ss->idx, spec);
1035 
1036  // this terminates the specifier
1037  break;
1038  } else if ((*spec == 'v' || *spec == 'a' || *spec == 's' ||
1039  *spec == 'd' || *spec == 't' || *spec == 'V') &&
1040  !cmdutils_isalnum(*(spec + 1))) { /* opt:[vasdtV] */
1041  if (ss->media_type != AVMEDIA_TYPE_UNKNOWN) {
1042  av_log(logctx, AV_LOG_ERROR, "Stream type specified multiple times\n");
1043  ret = AVERROR(EINVAL);
1044  goto fail;
1045  }
1046 
1047  switch (*spec++) {
1048  case 'v': ss->media_type = AVMEDIA_TYPE_VIDEO; break;
1049  case 'a': ss->media_type = AVMEDIA_TYPE_AUDIO; break;
1050  case 's': ss->media_type = AVMEDIA_TYPE_SUBTITLE; break;
1051  case 'd': ss->media_type = AVMEDIA_TYPE_DATA; break;
1052  case 't': ss->media_type = AVMEDIA_TYPE_ATTACHMENT; break;
1053  case 'V': ss->media_type = AVMEDIA_TYPE_VIDEO;
1054  ss->no_apic = 1; break;
1055  default: av_assert0(0);
1056  }
1057 
1058  av_log(logctx, AV_LOG_TRACE, "Parsed media type: %s; remainder: %s\n",
1059  av_get_media_type_string(ss->media_type), spec);
1060  } else if (*spec == 'g' && *(spec + 1) == ':') {
1061  if (ss->stream_list != STREAM_LIST_ALL)
1062  goto multiple_stream_lists;
1063 
1064  spec += 2;
1065  if (*spec == '#' || (*spec == 'i' && *(spec + 1) == ':')) {
1066  ss->stream_list = STREAM_LIST_GROUP_ID;
1067 
1068  spec += 1 + (*spec == 'i');
1069  } else
1070  ss->stream_list = STREAM_LIST_GROUP_IDX;
1071 
1072  ss->list_id = strtol(spec, &endptr, 0);
1073  if (spec == endptr) {
1074  av_log(logctx, AV_LOG_ERROR, "Expected stream group idx/ID, got: %s\n", spec);
1075  ret = AVERROR(EINVAL);
1076  goto fail;
1077  }
1078  spec = endptr;
1079 
1080  av_log(logctx, AV_LOG_TRACE, "Parsed stream group %s: %"PRId64"; remainder: %s\n",
1081  ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index", ss->list_id, spec);
1082  } else if (*spec == 'p' && *(spec + 1) == ':') {
1083  if (ss->stream_list != STREAM_LIST_ALL)
1084  goto multiple_stream_lists;
1085 
1086  ss->stream_list = STREAM_LIST_PROGRAM;
1087 
1088  spec += 2;
1089  ss->list_id = strtol(spec, &endptr, 0);
1090  if (spec == endptr) {
1091  av_log(logctx, AV_LOG_ERROR, "Expected program ID, got: %s\n", spec);
1092  ret = AVERROR(EINVAL);
1093  goto fail;
1094  }
1095  spec = endptr;
1096 
1097  av_log(logctx, AV_LOG_TRACE,
1098  "Parsed program ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1099  } else if (!strncmp(spec, "disp:", 5)) {
1100  const AVClass *st_class = av_stream_get_class();
1101  const AVOption *o = av_opt_find(&st_class, "disposition", NULL, 0, AV_OPT_SEARCH_FAKE_OBJ);
1102  char *disp = NULL;
1103  size_t len;
1104 
1105  av_assert0(o);
1106 
1107  if (ss->disposition) {
1108  av_log(logctx, AV_LOG_ERROR, "Multiple disposition specifiers\n");
1109  ret = AVERROR(EINVAL);
1110  goto fail;
1111  }
1112 
1113  spec += 5;
1114 
1115  for (len = 0; cmdutils_isalnum(spec[len]) ||
1116  spec[len] == '_' || spec[len] == '+'; len++)
1117  continue;
1118 
1119  disp = av_strndup(spec, len);
1120  if (!disp) {
1121  ret = AVERROR(ENOMEM);
1122  goto fail;
1123  }
1124 
1125  ret = av_opt_eval_flags(&st_class, o, disp, &ss->disposition);
1126  av_freep(&disp);
1127  if (ret < 0) {
1128  av_log(logctx, AV_LOG_ERROR, "Invalid disposition specifier\n");
1129  goto fail;
1130  }
1131 
1132  spec += len;
1133 
1134  av_log(logctx, AV_LOG_TRACE,
1135  "Parsed disposition: 0x%x; remainder: %s\n", ss->disposition, spec);
1136  } else if (*spec == '#' ||
1137  (*spec == 'i' && *(spec + 1) == ':')) {
1138  if (ss->stream_list != STREAM_LIST_ALL)
1139  goto multiple_stream_lists;
1140 
1141  ss->stream_list = STREAM_LIST_STREAM_ID;
1142 
1143  spec += 1 + (*spec == 'i');
1144  ss->list_id = strtol(spec, &endptr, 0);
1145  if (spec == endptr) {
1146  av_log(logctx, AV_LOG_ERROR, "Expected stream ID, got: %s\n", spec);
1147  ret = AVERROR(EINVAL);
1148  goto fail;
1149  }
1150  spec = endptr;
1151 
1152  av_log(logctx, AV_LOG_TRACE,
1153  "Parsed stream ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1154 
1155  // this terminates the specifier
1156  break;
1157  } else if (*spec == 'm' && *(spec + 1) == ':') {
1158  av_assert0(!ss->meta_key && !ss->meta_val);
1159 
1160  spec += 2;
1161  ss->meta_key = av_get_token(&spec, ":");
1162  if (!ss->meta_key) {
1163  ret = AVERROR(ENOMEM);
1164  goto fail;
1165  }
1166  if (*spec == ':') {
1167  spec++;
1168  ss->meta_val = av_get_token(&spec, ":");
1169  if (!ss->meta_val) {
1170  ret = AVERROR(ENOMEM);
1171  goto fail;
1172  }
1173  }
1174 
1175  av_log(logctx, AV_LOG_TRACE,
1176  "Parsed metadata: %s:%s; remainder: %s", ss->meta_key,
1177  ss->meta_val ? ss->meta_val : "<any value>", spec);
1178 
1179  // this terminates the specifier
1180  break;
1181  } else if (*spec == 'u' && (*(spec + 1) == '\0' || *(spec + 1) == ':')) {
1182  ss->usable_only = 1;
1183  spec++;
1184  av_log(logctx, AV_LOG_ERROR, "Parsed 'usable only'\n");
1185 
1186  // this terminates the specifier
1187  break;
1188  } else
1189  break;
1190 
1191  if (*spec == ':')
1192  spec++;
1193  }
1194 
1195  if (*spec) {
1196  if (!allow_remainder) {
1197  av_log(logctx, AV_LOG_ERROR,
1198  "Trailing garbage at the end of a stream specifier: %s\n",
1199  spec);
1200  ret = AVERROR(EINVAL);
1201  goto fail;
1202  }
1203 
1204  if (*spec == ':')
1205  spec++;
1206 
1207  ss->remainder = av_strdup(spec);
1208  if (!ss->remainder) {
1209  ret = AVERROR(EINVAL);
1210  goto fail;
1211  }
1212  }
1213 
1214  return 0;
1215 
1216 multiple_stream_lists:
1217  av_log(logctx, AV_LOG_ERROR,
1218  "Cannot combine multiple program/group designators in a "
1219  "single stream specifier");
1220  ret = AVERROR(EINVAL);
1221 
1222 fail:
1224  return ret;
1225 }
1226 
1228  const AVFormatContext *s, const AVStream *st,
1229  void *logctx)
1230 {
1231  const AVStreamGroup *g = NULL;
1232  const AVProgram *p = NULL;
1233  int start_stream = 0, nb_streams;
1234  int nb_matched = 0;
1235 
1236  switch (ss->stream_list) {
1237  case STREAM_LIST_STREAM_ID:
1238  // <n-th> stream with given ID makes no sense and should be impossible to request
1239  av_assert0(ss->idx < 0);
1240  // return early if we know for sure the stream does not match
1241  if (st->id != ss->list_id)
1242  return 0;
1243  start_stream = st->index;
1244  nb_streams = st->index + 1;
1245  break;
1246  case STREAM_LIST_ALL:
1247  start_stream = ss->idx >= 0 ? 0 : st->index;
1248  nb_streams = st->index + 1;
1249  break;
1250  case STREAM_LIST_PROGRAM:
1251  for (unsigned i = 0; i < s->nb_programs; i++) {
1252  if (s->programs[i]->id == ss->list_id) {
1253  p = s->programs[i];
1254  break;
1255  }
1256  }
1257  if (!p) {
1258  av_log(logctx, AV_LOG_WARNING, "No program with ID %"PRId64" exists,"
1259  " stream specifier can never match\n", ss->list_id);
1260  return 0;
1261  }
1263  break;
1264  case STREAM_LIST_GROUP_ID:
1265  for (unsigned i = 0; i < s->nb_stream_groups; i++) {
1266  if (ss->list_id == s->stream_groups[i]->id) {
1267  g = s->stream_groups[i];
1268  break;
1269  }
1270  }
1271  // fall-through
1272  case STREAM_LIST_GROUP_IDX:
1273  if (ss->stream_list == STREAM_LIST_GROUP_IDX &&
1274  ss->list_id >= 0 && ss->list_id < s->nb_stream_groups)
1275  g = s->stream_groups[ss->list_id];
1276 
1277  if (!g) {
1278  av_log(logctx, AV_LOG_WARNING, "No stream group with group %s %"
1279  PRId64" exists, stream specifier can never match\n",
1280  ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index",
1281  ss->list_id);
1282  return 0;
1283  }
1284  nb_streams = g->nb_streams;
1285  break;
1286  default: av_assert0(0);
1287  }
1288 
1289  for (int i = start_stream; i < nb_streams; i++) {
1290  const AVStream *candidate = s->streams[g ? g->streams[i]->index :
1291  p ? p->stream_index[i] : i];
1292 
1293  if (ss->media_type != AVMEDIA_TYPE_UNKNOWN &&
1294  (ss->media_type != candidate->codecpar->codec_type ||
1295  (ss->no_apic && (candidate->disposition & AV_DISPOSITION_ATTACHED_PIC))))
1296  continue;
1297 
1298  if (ss->meta_key) {
1299  const AVDictionaryEntry *tag = av_dict_get(candidate->metadata,
1300  ss->meta_key, NULL, 0);
1301 
1302  if (!tag)
1303  continue;
1304  if (ss->meta_val && strcmp(tag->value, ss->meta_val))
1305  continue;
1306  }
1307 
1308  if (ss->usable_only) {
1309  const AVCodecParameters *par = candidate->codecpar;
1310 
1311  switch (par->codec_type) {
1312  case AVMEDIA_TYPE_AUDIO:
1313  if (!par->sample_rate || !par->ch_layout.nb_channels ||
1314  par->format == AV_SAMPLE_FMT_NONE)
1315  continue;
1316  break;
1317  case AVMEDIA_TYPE_VIDEO:
1318  if (!par->width || !par->height || par->format == AV_PIX_FMT_NONE)
1319  continue;
1320  break;
1321  case AVMEDIA_TYPE_UNKNOWN:
1322  continue;
1323  }
1324  }
1325 
1326  if (ss->disposition &&
1327  (candidate->disposition & ss->disposition) != ss->disposition)
1328  continue;
1329 
1330  if (st == candidate)
1331  return ss->idx < 0 || ss->idx == nb_matched;
1332 
1333  nb_matched++;
1334  }
1335 
1336  return 0;
1337 }
1338 
1339 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1340 {
1342  int ret;
1343 
1344  ret = stream_specifier_parse(&ss, spec, 0, NULL);
1345  if (ret < 0)
1346  return ret;
1347 
1348  ret = stream_specifier_match(&ss, s, st, NULL);
1350  return ret;
1351 }
1352 
1354  AVFormatContext *s, AVStream *st, const AVCodec *codec,
1355  AVDictionary **dst, AVDictionary **opts_used)
1356 {
1357  AVDictionary *ret = NULL;
1358  const AVDictionaryEntry *t = NULL;
1359  int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1361  char prefix = 0;
1362  const AVClass *cc = avcodec_get_class();
1363 
1364  switch (st->codecpar->codec_type) {
1365  case AVMEDIA_TYPE_VIDEO:
1366  prefix = 'v';
1368  break;
1369  case AVMEDIA_TYPE_AUDIO:
1370  prefix = 'a';
1372  break;
1373  case AVMEDIA_TYPE_SUBTITLE:
1374  prefix = 's';
1376  break;
1377  }
1378 
1379  while (t = av_dict_iterate(opts, t)) {
1380  const AVClass *priv_class;
1381  char *p = strchr(t->key, ':');
1382  int used = 0;
1383 
1384  /* check stream specification in opt name */
1385  if (p) {
1386  int err = check_stream_specifier(s, st, p + 1);
1387  if (err < 0) {
1388  av_dict_free(&ret);
1389  return err;
1390  } else if (!err)
1391  continue;
1392 
1393  *p = 0;
1394  }
1395 
1396  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1397  !codec ||
1398  ((priv_class = codec->priv_class) &&
1399  av_opt_find(&priv_class, t->key, NULL, flags,
1401  av_dict_set(&ret, t->key, t->value, 0);
1402  used = 1;
1403  } else if (t->key[0] == prefix &&
1404  av_opt_find(&cc, t->key + 1, NULL, flags,
1406  av_dict_set(&ret, t->key + 1, t->value, 0);
1407  used = 1;
1408  }
1409 
1410  if (p)
1411  *p = ':';
1412 
1413  if (used && opts_used)
1414  av_dict_set(opts_used, t->key, "", 0);
1415  }
1416 
1417  *dst = ret;
1418  return 0;
1419 }
1420 
1422  AVDictionary *local_codec_opts,
1423  AVDictionary ***dst)
1424 {
1425  int ret;
1426  AVDictionary **opts;
1427 
1428  *dst = NULL;
1429 
1430  if (!s->nb_streams)
1431  return 0;
1432 
1433  opts = av_calloc(s->nb_streams, sizeof(*opts));
1434  if (!opts)
1435  return AVERROR(ENOMEM);
1436 
1437  for (int i = 0; i < s->nb_streams; i++) {
1438  ret = filter_codec_opts(local_codec_opts, s->streams[i]->codecpar->codec_id,
1439  s, s->streams[i], NULL, &opts[i], NULL);
1440  if (ret < 0)
1441  goto fail;
1442  }
1443  *dst = opts;
1444  return 0;
1445 fail:
1446  for (int i = 0; i < s->nb_streams; i++)
1447  av_dict_free(&opts[i]);
1448  av_freep(&opts);
1449  return ret;
1450 }
1451 
1452 int grow_array(void **array, int elem_size, int *size, int new_size)
1453 {
1454  if (new_size >= INT_MAX / elem_size) {
1455  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1456  return AVERROR(ERANGE);
1457  }
1458  if (*size < new_size) {
1459  uint8_t *tmp = av_realloc_array(*array, new_size, elem_size);
1460  if (!tmp)
1461  return AVERROR(ENOMEM);
1462  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1463  *size = new_size;
1464  *array = tmp;
1465  return 0;
1466  }
1467  return 0;
1468 }
1469 
1470 void *allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
1471 {
1472  void *new_elem;
1473 
1474  if (!(new_elem = av_mallocz(elem_size)) ||
1475  av_dynarray_add_nofree(ptr, nb_elems, new_elem) < 0)
1476  return NULL;
1477  return new_elem;
1478 }
1479 
1480 double get_rotation(const int32_t *displaymatrix)
1481 {
1482  double theta = 0;
1483  if (displaymatrix)
1484  theta = -round(av_display_rotation_get(displaymatrix));
1485 
1486  theta -= 360*floor(theta/360 + 0.9/360);
1487 
1488  if (fabs(theta - 90*round(theta/90)) > 2)
1489  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
1490  "If you want to help, upload a sample "
1491  "of this file to https://streams.videolan.org/upload/ "
1492  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
1493 
1494  return theta;
1495 }
1496 
1497 /* read file contents into a string */
1498 char *file_read(const char *filename)
1499 {
1500  AVIOContext *pb = NULL;
1501  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1502  AVBPrint bprint;
1503  char *str;
1504 
1505  if (ret < 0) {
1506  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1507  return NULL;
1508  }
1509 
1511  ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX);
1512  avio_closep(&pb);
1513  if (ret < 0) {
1514  av_bprint_finalize(&bprint, NULL);
1515  return NULL;
1516  }
1517  ret = av_bprint_finalize(&bprint, &str);
1518  if (ret < 0)
1519  return NULL;
1520  return str;
1521 }
1522 
1524 {
1525  const AVDictionaryEntry *t = NULL;
1526 
1527  while ((t = av_dict_iterate(b, t))) {
1529  }
1530 }
1531 
1533 {
1534  const AVDictionaryEntry *t = av_dict_iterate(m, NULL);
1535  if (t) {
1536  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1537  return AVERROR_OPTION_NOT_FOUND;
1538  }
1539 
1540  return 0;
1541 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
flags
const SwsFlags flags[]
Definition: swscale.c:61
fopen_utf8
static FILE * fopen_utf8(const char *path, const char *mode)
Definition: fopen_utf8.h:66
GET_ARG
#define GET_ARG(arg)
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:172
OptionGroup::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:337
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
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
level
uint8_t level
Definition: svq3.c:208
INFINITY
#define INFINITY
Definition: mathematics.h:118
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
printf
__device__ int printf(const char *,...)
opt.h
get_rotation
double get_rotation(const int32_t *displaymatrix)
Definition: cmdutils.c:1480
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
OptionDef::off
size_t off
Definition: cmdutils.h:249
libm.h
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1193
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: cmdutils.c:1532
av_opt_child_class_iterate
const AVClass * av_opt_child_class_iterate(const AVClass *parent, void **iter)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:2050
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:206
va_copy.h
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:670
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:1012
sws_dict
AVDictionary * sws_dict
Definition: cmdutils.c:56
int64_t
long long int64_t
Definition: coverity.c:34
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:190
OPT_FLAG_OFFSET
#define OPT_FLAG_OFFSET
Definition: cmdutils.h:219
init_report
int init_report(const char *env, FILE **file)
Definition: opt_common.c:1146
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:233
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
StreamSpecifier
Definition: cmdutils.h:113
AVOption
AVOption.
Definition: opt.h:429
OptionGroupList::groups
OptionGroup * groups
Definition: cmdutils.h:356
b
#define b
Definition: input.c:42
OptionDef::dst_ptr
void * dst_ptr
Definition: cmdutils.h:247
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:357
avio_open
int avio_open(AVIOContext **s, const char *filename, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:498
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
OptionDef::type
enum OptionType type
Definition: cmdutils.h:193
grow_array
int grow_array(void **array, int elem_size, int *size, int new_size)
Realloc array to hold new_size elements of elem_size.
Definition: cmdutils.c:1452
FLAGS
#define FLAGS
Definition: cmdutils.c:598
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
base
uint8_t base
Definition: vp3data.h:128
freeenv_utf8
static void freeenv_utf8(char *var)
Definition: getenv_utf8.h:72
OptionGroup::swr_opts
AVDictionary * swr_opts
Definition: cmdutils.h:346
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
AVOption::flags
int flags
A combination of AV_OPT_FLAG_*.
Definition: opt.h:472
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:32
finish_group
static int finish_group(OptionParseContext *octx, int group_idx, const char *arg)
Definition: cmdutils.c:691
hide_banner
int hide_banner
Definition: cmdutils.c:60
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
STREAM_LIST_GROUP_ID
@ STREAM_LIST_GROUP_ID
Definition: cmdutils.h:109
opt_has_arg
static int opt_has_arg(const OptionDef *o)
Definition: cmdutils.c:231
OptionDef
Definition: cmdutils.h:191
stream_specifier_uninit
void stream_specifier_uninit(StreamSpecifier *ss)
Definition: cmdutils.c:1003
finish
static void finish(void)
Definition: movenc.c:374
fopen_utf8.h
OptionGroupList
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:353
fail
#define fail()
Definition: checkasm.h:196
OptionParseContext
Definition: cmdutils.h:360
init_parse_context
static int init_parse_context(OptionParseContext *octx, const OptionGroupDef *groups, int nb_groups)
Definition: cmdutils.c:743
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
Option
An option extracted from the commandline.
Definition: cmdutils.h:315
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:106
OPT_TYPE_FLOAT
@ OPT_TYPE_FLOAT
Definition: cmdutils.h:86
OptionGroup::nb_opts
int nb_opts
Definition: cmdutils.h:341
OptionGroupList::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:354
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
OptionDef::help
const char * help
Definition: cmdutils.h:251
OptionGroupDef
Definition: cmdutils.h:321
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
check_stream_specifier
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1339
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:236
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:343
check_options
static void check_options(const OptionDef *po)
Definition: cmdutils.c:540
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
class
#define class
Definition: math.h:25
report_file
static FILE * report_file
Definition: opt_common.c:70
s
#define s(width, name)
Definition: cbs_vp9.c:198
OptionDef::argname
const char * argname
Definition: cmdutils.h:252
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:790
avio_read_to_bprint
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
Definition: aviobuf.c:1251
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
g
const char * g
Definition: vf_curves.c:128
AVDictionaryEntry::key
char * key
Definition: dict.h:91
Option::key
const char * key
Definition: cmdutils.h:317
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
OPT_TYPE_DOUBLE
@ OPT_TYPE_DOUBLE
Definition: cmdutils.h:87
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:493
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
nb_streams
static int nb_streams
Definition: ffprobe.c:334
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
key
const char * key
Definition: hwcontext_opencl.c:189
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
context
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 keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:75
opts
AVDictionary * opts
Definition: movenc.c:51
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:344
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
STREAM_LIST_PROGRAM
@ STREAM_LIST_PROGRAM
Definition: cmdutils.h:108
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:184
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
OptionParseContext::global_opts
OptionGroup global_opts
Definition: cmdutils.h:361
Option::opt
const OptionDef * opt
Definition: cmdutils.h:316
add_opt
static int add_opt(OptionParseContext *octx, const OptionDef *opt, const char *key, const char *val)
Definition: cmdutils.c:725
prepare_app_arguments
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
Definition: cmdutils.c:225
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
swr_get_class
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:143
filter_codec_opts
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst, AVDictionary **opts_used)
Filter out options for given codec.
Definition: cmdutils.c:1353
parseutils.h
opt_loglevel
int opt_loglevel(void *optctx, const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: opt_common.c:1250
STREAM_LIST_STREAM_ID
@ STREAM_LIST_STREAM_ID
Definition: cmdutils.h:107
getenv_utf8
static char * getenv_utf8(const char *varname)
Definition: getenv_utf8.h:67
options
Definition: swscale.c:43
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1192
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:824
AV_OPT_SEARCH_FAKE_OBJ
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poin...
Definition: opt.h:613
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:592
stream_specifier_match
unsigned stream_specifier_match(const StreamSpecifier *ss, const AVFormatContext *s, const AVStream *st, void *logctx)
Definition: cmdutils.c:1227
STREAM_LIST_GROUP_IDX
@ STREAM_LIST_GROUP_IDX
Definition: cmdutils.h:110
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
OptionGroup::opts
Option * opts
Definition: cmdutils.h:340
OptionGroup
Definition: cmdutils.h:336
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
swresample.h
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
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
file_read
char * file_read(const char *filename)
Definition: cmdutils.c:1498
locate_option
int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
Return index of option opt in argv or 0 if not found.
Definition: cmdutils.c:489
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
eval.h
av_opt_find
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1991
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
OPT_TYPE_INT
@ OPT_TYPE_INT
Definition: cmdutils.h:84
SpecifierOptList
Definition: cmdutils.h:179
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
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
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:924
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:62
size
int size
Definition: twinvq_data.h:10344
OPT_TYPE_INT64
@ OPT_TYPE_INT64
Definition: cmdutils.h:85
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:199
OptionType
OptionType
Definition: cmdutils.h:80
allocate_array_elem
void * allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
Atomically add a new element to an array of pointers, i.e.
Definition: cmdutils.c:1470
getenv_utf8.h
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
OPT_FLAG_SPEC
#define OPT_FLAG_SPEC
Definition: cmdutils.h:224
offset
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 offset
Definition: writing_filters.txt:86
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:233
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
OPT_TYPE_FUNC
@ OPT_TYPE_FUNC
Definition: cmdutils.h:81
av_opt_show2
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1666
OPT_DECODER
#define OPT_DECODER
Definition: cmdutils.h:244
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
OPT_HAS_CANON
#define OPT_HAS_CANON
Definition: cmdutils.h:241
OptionDef::u1
union OptionDef::@2 u1
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:474
bprint.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
round
static av_always_inline av_const double round(double x)
Definition: libm.h:446
OPT_TYPE_TIME
@ OPT_TYPE_TIME
Definition: cmdutils.h:88
setup_find_stream_info_opts
int setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *local_codec_opts, AVDictionary ***dst)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1421
swr_opts
AVDictionary * swr_opts
Definition: cmdutils.c:57
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_OPT_FLAG_SUBTITLE_PARAM
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:359
display.h
parse_options
int parse_options(void *optctx, int argc, char **argv, const OptionDef *options, int(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:420
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:227
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:204
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
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1188
OPT_OUTPUT
#define OPT_OUTPUT
Definition: cmdutils.h:234
len
int len
Definition: vorbis_enc_data.h:426
cmdutils_isalnum
int cmdutils_isalnum(char c)
Definition: cmdutils.c:996
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
OptionParseContext::groups
OptionGroupList * groups
Definition: cmdutils.h:363
OptionDef::u
union OptionDef::@1 u
parse_loglevel
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
Definition: cmdutils.c:556
OptionGroup::sws_dict
AVDictionary * sws_dict
Definition: cmdutils.h:345
av_opt_eval_flags
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:813
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:116
tag
uint32_t tag
Definition: movenc.c:1907
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:756
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:204
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:913
av_strtod
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:107
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:95
OptionGroup::arg
const char * arg
Definition: cmdutils.h:338
uninit_parse_context
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:765
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:70
OPT_PERFILE
#define OPT_PERFILE
Definition: cmdutils.h:215
avformat.h
dict.h
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: cmdutils.c:1523
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:315
AVStreamGroup
Definition: avformat.h:1098
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:750
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:380
opt_common.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
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
write_option
static int write_option(void *optctx, const OptionDef *po, const char *opt, const char *arg, const OptionDef *defs)
Definition: cmdutils.c:240
Option::val
const char * val
Definition: cmdutils.h:318
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:532
OptionDef::name_canon
const char * name_canon
Definition: cmdutils.h:257
parse_optgroup
int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
Parse an options group and write results into optctx.
Definition: cmdutils.c:456
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
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:599
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
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
AVCodecParameters::format
int format
Definition: codec_par.h:92
OptionDef::name
const char * name
Definition: cmdutils.h:192
STREAM_LIST_ALL
@ STREAM_LIST_ALL
Definition: cmdutils.h:106
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
OPT_TYPE_STRING
@ OPT_TYPE_STRING
Definition: cmdutils.h:83
OptionGroupDef::sep
const char * sep
Option to be used as group separator.
Definition: cmdutils.h:328
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:650
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
cmdutils.h
int32_t
int32_t
Definition: audioconvert.c:56
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
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
OptionParseContext::nb_groups
int nb_groups
Definition: cmdutils.h:364
find_option
static const OptionDef * find_option(const OptionDef *po, const char *name)
Definition: cmdutils.c:153
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
AVDictionaryEntry::value
char * value
Definition: dict.h:92
avstring.h
av_stream_get_class
const AVClass * av_stream_get_class(void)
Get the AVClass for AVStream.
Definition: options.c:239
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:284
snprintf
#define snprintf
Definition: snprintf.h:34
OptionParseContext::cur_group
OptionGroup cur_group
Definition: cmdutils.h:367
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
dump_argument
static void dump_argument(FILE *report_file, const char *a)
Definition: cmdutils.c:516
swscale.h
match_group_separator
static int match_group_separator(const OptionGroupDef *groups, int nb_groups, const char *opt)
Definition: cmdutils.c:671
w32dlfcn.h
OptionDef::func_arg
int(* func_arg)(void *, const char *, const char *)
Definition: cmdutils.h:248
opt_find
static const AVOption * opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Definition: cmdutils.c:589
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:35
min
float min
Definition: vorbis_enc_data.h:429
OptionDef::flags
int flags
Definition: cmdutils.h:194