FFmpeg: fftools/cmdutils.c Source File

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"
36 #include "libswresample/swresample.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 
56  AVDictionary *sws_dict;
57  AVDictionary *swr_opts;
58  AVDictionary *format_opts, *codec_opts;
59 
60  int hide_banner = 0;
61 
62  void uninit_opts(void)
63 {
64  av_dict_free(&swr_opts);
65  av_dict_free(&sws_dict);
66  av_dict_free(&format_opts);
67  av_dict_free(&codec_opts);
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)) {
259  av_log(NULL, AV_LOG_FATAL,
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 = read_file_to_string(arg);
267  if (!arg_allocated) {
268  av_log(NULL, AV_LOG_FATAL,
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) {
340  ret = parse_number(opt, arg, OPT_TYPE_FLOAT, -INFINITY, INFINITY, &num);
341  if (ret < 0)
342  goto finish;
343 
344  *(float *)dst = num;
345  } else if (po->type == OPT_TYPE_DOUBLE) {
346  ret = parse_number(opt, arg, OPT_TYPE_DOUBLE, -INFINITY, INFINITY, &num);
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)) {
357  av_log(NULL, AV_LOG_ERROR,
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)
544  av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT | OPT_DECODER));
545 
546  if (po->type == OPT_TYPE_FUNC)
547  av_assert0(!(po->flags & (OPT_FLAG_OFFSET | OPT_FLAG_SPEC)));
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 
561  check_options(options);
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"))
614  av_log_set_level(AV_LOG_DEBUG);
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,
621  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
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,
628  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
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,
636  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
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,
655  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
656  av_dict_set(&swr_opts, opt, arg, FLAGS);
657  consumed = 1;
658  }
659 #endif
660 
661  if (consumed)
662  return 0;
663  return AVERROR_OPTION_NOT_FOUND;
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 
743  static int init_parse_context(OptionParseContext *octx,
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 
765  void uninit_parse_context(OptionParseContext *octx)
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);
774  av_dict_free(&l->groups[j].codec_opts);
775  av_dict_free(&l->groups[j].format_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);
901  return AVERROR_OPTION_NOT_FOUND;
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 
996  int cmdutils_isalnum(char c)
997 {
998  return (c >= '0' && c <= '9') ||
999  (c >= 'A' && c <= 'Z') ||
1000  (c >= 'a' && c <= 'z');
1001 }
1002 
1003  void stream_specifier_uninit(StreamSpecifier *ss)
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 
1012  int stream_specifier_parse(StreamSpecifier *ss, const char *spec,
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:
1223  stream_specifier_uninit(ss);
1224  return ret;
1225 }
1226 
1227  unsigned stream_specifier_match(const StreamSpecifier *ss,
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  }
1262  nb_streams = p->nb_stream_indexes;
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 {
1341  StreamSpecifier ss;
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);
1349  stream_specifier_uninit(&ss);
1350  return ret;
1351 }
1352 
1353  unsigned stream_group_specifier_match(const StreamSpecifier *ss,
1354  const AVFormatContext *s, const AVStreamGroup *stg,
1355  void *logctx)
1356 {
1357  int start_stream_group = 0, nb_stream_groups;
1358  int nb_matched = 0;
1359 
1360  if (ss->idx >= 0)
1361  return 0;
1362 
1363  switch (ss->stream_list) {
1364  case STREAM_LIST_STREAM_ID:
1365  case STREAM_LIST_ALL:
1366  case STREAM_LIST_PROGRAM:
1367  return 0;
1368  case STREAM_LIST_GROUP_ID:
1369  // <n-th> stream with given ID makes no sense and should be impossible to request
1370  av_assert0(ss->idx < 0);
1371  // return early if we know for sure the stream does not match
1372  if (stg->id != ss->list_id)
1373  return 0;
1374  start_stream_group = stg->index;
1375  nb_stream_groups = stg->index + 1;
1376  break;
1377  case STREAM_LIST_GROUP_IDX:
1378  start_stream_group = ss->list_id >= 0 ? 0 : stg->index;
1379  nb_stream_groups = stg->index + 1;
1380  break;
1381  default: av_assert0(0);
1382  }
1383 
1384  for (int i = start_stream_group; i < nb_stream_groups; i++) {
1385  const AVStreamGroup *candidate = s->stream_groups[i];
1386 
1387  if (ss->meta_key) {
1388  const AVDictionaryEntry *tag = av_dict_get(candidate->metadata,
1389  ss->meta_key, NULL, 0);
1390 
1391  if (!tag)
1392  continue;
1393  if (ss->meta_val && strcmp(tag->value, ss->meta_val))
1394  continue;
1395  }
1396 
1397  if (ss->usable_only) {
1398  switch (candidate->type) {
1399  case AV_STREAM_GROUP_PARAMS_TILE_GRID: {
1400  const AVStreamGroupTileGrid *tg = candidate->params.tile_grid;
1401  if (!tg->coded_width || !tg->coded_height || !tg->nb_tiles ||
1402  !tg->width || !tg->height || !tg->nb_tiles)
1403  continue;
1404  break;
1405  }
1406  default:
1407  continue;
1408  }
1409  }
1410 
1411  if (ss->disposition &&
1412  (candidate->disposition & ss->disposition) != ss->disposition)
1413  continue;
1414 
1415  if (stg == candidate)
1416  return ss->list_id < 0 || ss->list_id == nb_matched;
1417 
1418  nb_matched++;
1419  }
1420 
1421  return 0;
1422 }
1423 
1424  int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id,
1425  AVFormatContext *s, AVStream *st, const AVCodec *codec,
1426  AVDictionary **dst, AVDictionary **opts_used)
1427 {
1428  AVDictionary *ret = NULL;
1429  const AVDictionaryEntry *t = NULL;
1430  int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1431  : AV_OPT_FLAG_DECODING_PARAM;
1432  char prefix = 0;
1433  const AVClass *cc = avcodec_get_class();
1434 
1435  switch (st->codecpar->codec_type) {
1436  case AVMEDIA_TYPE_VIDEO:
1437  prefix = 'v';
1438  flags |= AV_OPT_FLAG_VIDEO_PARAM;
1439  break;
1440  case AVMEDIA_TYPE_AUDIO:
1441  prefix = 'a';
1442  flags |= AV_OPT_FLAG_AUDIO_PARAM;
1443  break;
1444  case AVMEDIA_TYPE_SUBTITLE:
1445  prefix = 's';
1446  flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1447  break;
1448  }
1449 
1450  while (t = av_dict_iterate(opts, t)) {
1451  const AVClass *priv_class;
1452  char *p = strchr(t->key, ':');
1453  int used = 0;
1454 
1455  /* check stream specification in opt name */
1456  if (p) {
1457  int err = check_stream_specifier(s, st, p + 1);
1458  if (err < 0) {
1459  av_dict_free(&ret);
1460  return err;
1461  } else if (!err)
1462  continue;
1463 
1464  *p = 0;
1465  }
1466 
1467  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1468  !codec ||
1469  ((priv_class = codec->priv_class) &&
1470  av_opt_find(&priv_class, t->key, NULL, flags,
1471  AV_OPT_SEARCH_FAKE_OBJ))) {
1472  av_dict_set(&ret, t->key, t->value, 0);
1473  used = 1;
1474  } else if (t->key[0] == prefix &&
1475  av_opt_find(&cc, t->key + 1, NULL, flags,
1476  AV_OPT_SEARCH_FAKE_OBJ)) {
1477  av_dict_set(&ret, t->key + 1, t->value, 0);
1478  used = 1;
1479  }
1480 
1481  if (p)
1482  *p = ':';
1483 
1484  if (used && opts_used)
1485  av_dict_set(opts_used, t->key, "", 0);
1486  }
1487 
1488  *dst = ret;
1489  return 0;
1490 }
1491 
1492  int setup_find_stream_info_opts(AVFormatContext *s,
1493  AVDictionary *local_codec_opts,
1494  AVDictionary ***dst)
1495 {
1496  int ret;
1497  AVDictionary **opts;
1498 
1499  *dst = NULL;
1500 
1501  if (!s->nb_streams)
1502  return 0;
1503 
1504  opts = av_calloc(s->nb_streams, sizeof(*opts));
1505  if (!opts)
1506  return AVERROR(ENOMEM);
1507 
1508  for (int i = 0; i < s->nb_streams; i++) {
1509  ret = filter_codec_opts(local_codec_opts, s->streams[i]->codecpar->codec_id,
1510  s, s->streams[i], NULL, &opts[i], NULL);
1511  if (ret < 0)
1512  goto fail;
1513  }
1514  *dst = opts;
1515  return 0;
1516 fail:
1517  for (int i = 0; i < s->nb_streams; i++)
1518  av_dict_free(&opts[i]);
1519  av_freep(&opts);
1520  return ret;
1521 }
1522 
1523  int grow_array(void **array, int elem_size, int *size, int new_size)
1524 {
1525  if (new_size >= INT_MAX / elem_size) {
1526  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1527  return AVERROR(ERANGE);
1528  }
1529  if (*size < new_size) {
1530  uint8_t *tmp = av_realloc_array(*array, new_size, elem_size);
1531  if (!tmp)
1532  return AVERROR(ENOMEM);
1533  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1534  *size = new_size;
1535  *array = tmp;
1536  return 0;
1537  }
1538  return 0;
1539 }
1540 
1541  void *allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
1542 {
1543  void *new_elem;
1544 
1545  new_elem = av_mallocz(elem_size);
1546  if (!new_elem)
1547  return NULL;
1548  if (av_dynarray_add_nofree(ptr, nb_elems, new_elem) < 0)
1549  av_freep(&new_elem);
1550 
1551  return new_elem;
1552 }
1553 
1554  double get_rotation(const int32_t *displaymatrix)
1555 {
1556  double theta = 0;
1557  if (displaymatrix)
1558  theta = -round(av_display_rotation_get(displaymatrix));
1559 
1560  theta -= 360*floor(theta/360 + 0.9/360);
1561 
1562  if (fabs(theta - 90*round(theta/90)) > 2)
1563  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
1564  "If you want to help, upload a sample "
1565  "of this file to https://streams.videolan.org/upload/ "
1566  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
1567 
1568  return theta;
1569 }
1570 
1571 /* read file contents into a string */
1572  char *read_file_to_string(const char *filename)
1573 {
1574  AVIOContext *pb = NULL;
1575  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1576  AVBPrint bprint;
1577  char *str;
1578 
1579  if (ret < 0) {
1580  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1581  return NULL;
1582  }
1583 
1584  av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
1585  ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX);
1586  avio_closep(&pb);
1587  if (ret < 0) {
1588  av_bprint_finalize(&bprint, NULL);
1589  return NULL;
1590  }
1591  ret = av_bprint_finalize(&bprint, &str);
1592  if (ret < 0)
1593  return NULL;
1594  return str;
1595 }
1596 
1597  void remove_avoptions(AVDictionary **a, AVDictionary *b)
1598 {
1599  const AVDictionaryEntry *t = NULL;
1600 
1601  while ((t = av_dict_iterate(b, t))) {
1602  av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
1603  }
1604 }
1605 
1606  int check_avoptions(AVDictionary *m)
1607 {
1608  const AVDictionaryEntry *t = av_dict_iterate(m, NULL);
1609  if (t) {
1610  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1611  return AVERROR_OPTION_NOT_FOUND;
1612  }
1613 
1614  return 0;
1615 }
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:207
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:341
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
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1117
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:1554
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1133
OptionDef::off
size_t off
Definition: cmdutils.h:253
libm.h
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: cmdutils.c:1606
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
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1175
OPT_FLAG_OFFSET
#define OPT_FLAG_OFFSET
Definition: cmdutils.h:223
init_report
int init_report(const char *env, FILE **file)
Definition: opt_common.c:1148
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:237
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:360
b
#define b
Definition: input.c:42
OptionDef::dst_ptr
void * dst_ptr
Definition: cmdutils.h:251
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:361
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:197
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:1523
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:350
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:195
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:357
fail
#define fail()
Definition: checkasm.h:207
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:951
OptionParseContext
Definition: cmdutils.h:364
init_parse_context
static int init_parse_context(OptionParseContext *octx, const OptionGroupDef *groups, int nb_groups)
Definition: cmdutils.c:743
AVStreamGroupTileGrid::coded_width
int coded_width
Width of the canvas.
Definition: avformat.h:966
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:319
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
AVStreamGroupTileGrid::coded_height
int coded_height
Width of the canvas.
Definition: avformat.h:972
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for SwsContext.
Definition: options.c:107
OPT_TYPE_FLOAT
@ OPT_TYPE_FLOAT
Definition: cmdutils.h:86
OptionGroup::nb_opts
int nb_opts
Definition: cmdutils.h:345
OptionGroupList::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:358
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
OptionDef::help
const char * help
Definition: cmdutils.h:255
OptionGroupDef
Definition: cmdutils.h:325
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:347
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:71
s
#define s(width, name)
Definition: cbs_vp9.c:198
OptionDef::argname
const char * argname
Definition: cmdutils.h:256
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:1254
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:321
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:494
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1109
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:340
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
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
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:348
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:365
Option::opt
const OptionDef * opt
Definition: cmdutils.h:320
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
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:1424
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:1252
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
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:344
OptionGroup
Definition: cmdutils.h:340
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
stream_group_specifier_match
unsigned stream_group_specifier_match(const StreamSpecifier *ss, const AVFormatContext *s, const AVStreamGroup *stg, void *logctx)
Definition: cmdutils.c:1353
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
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1091
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:183
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
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
AVStreamGroup::params
union AVStreamGroup::@421 params
Group type-specific parameters.
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:1541
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:228
AVStreamGroupTileGrid::nb_tiles
unsigned int nb_tiles
Amount of tiles in the grid.
Definition: avformat.h:959
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:248
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
OPT_HAS_CANON
#define OPT_HAS_CANON
Definition: cmdutils.h:245
OptionDef::u1
union OptionDef::@2 u1
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:475
bprint.h
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1036
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:1492
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:205
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:238
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:367
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:349
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:1995
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:342
AVStreamGroup::metadata
AVDictionary * metadata
Metadata that applies to the whole group.
Definition: avformat.h:1145
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:219
avformat.h
dict.h
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: cmdutils.c:1597
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:232
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
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
Option::val
const char * val
Definition: cmdutils.h:322
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:536
OptionDef::name_canon
const char * name_canon
Definition: cmdutils.h:261
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
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1125
AVCodecParameters::format
int format
Definition: codec_par.h:92
OptionDef::name
const char * name
Definition: cmdutils.h:196
STREAM_LIST_ALL
@ STREAM_LIST_ALL
Definition: cmdutils.h:106
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1046
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
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
read_file_to_string
char * read_file_to_string(const char *filename)
Definition: cmdutils.c:1572
OptionParseContext::nb_groups
int nb_groups
Definition: cmdutils.h:368
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:371
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:252
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:198
Generated on Mon Nov 17 2025 19:21:49 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /