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 "libavfilter/avfilter.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
40 #include "libavutil/attributes.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/bprint.h"
45 #include "libavutil/display.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/imgutils.h"
48 #include "libavutil/libm.h"
49 #include "libavutil/parseutils.h"
50 #include "libavutil/pixdesc.h"
51 #include "libavutil/eval.h"
52 #include "libavutil/dict.h"
53 #include "libavutil/opt.h"
54 #include "libavutil/cpu.h"
55 #include "libavutil/ffversion.h"
56 #include "libavutil/version.h"
57 #include "libavcodec/bsf.h"
58 #include "cmdutils.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/time.h>
61 #include <sys/resource.h>
62 #endif
63 #ifdef _WIN32
64 #include <windows.h>
65 #endif
66 
67 static int init_report(const char *env);
68 
72 
73 static FILE *report_file;
75 int hide_banner = 0;
76 
81 };
82 
83 void uninit_opts(void)
84 {
89 }
90 
91 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
92 {
93  vfprintf(stdout, fmt, vl);
94 }
95 
96 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
97 {
98  va_list vl2;
99  char line[1024];
100  static int print_prefix = 1;
101 
102  va_copy(vl2, vl);
103  av_log_default_callback(ptr, level, fmt, vl);
104  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
105  va_end(vl2);
106  if (report_file_level >= level) {
107  fputs(line, report_file);
108  fflush(report_file);
109  }
110 }
111 
112 void init_dynload(void)
113 {
114 #if HAVE_SETDLLDIRECTORY && defined(_WIN32)
115  /* Calling SetDllDirectory with the empty string (but not NULL) removes the
116  * current working directory from the DLL search path as a security pre-caution. */
117  SetDllDirectory("");
118 #endif
119 }
120 
121 static void (*program_exit)(int ret);
122 
123 void register_exit(void (*cb)(int ret))
124 {
125  program_exit = cb;
126 }
127 
128 void exit_program(int ret)
129 {
130  if (program_exit)
131  program_exit(ret);
132 
133  exit(ret);
134 }
135 
136 double parse_number_or_die(const char *context, const char *numstr, int type,
137  double min, double max)
138 {
139  char *tail;
140  const char *error;
141  double d = av_strtod(numstr, &tail);
142  if (*tail)
143  error = "Expected number for %s but found: %s\n";
144  else if (d < min || d > max)
145  error = "The value for %s was %s which is not within %f - %f\n";
146  else if (type == OPT_INT64 && (int64_t)d != d)
147  error = "Expected int64 for %s but found %s\n";
148  else if (type == OPT_INT && (int)d != d)
149  error = "Expected int for %s but found %s\n";
150  else
151  return d;
152  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
153  exit_program(1);
154  return 0;
155 }
156 
157 int64_t parse_time_or_die(const char *context, const char *timestr,
158  int is_duration)
159 {
160  int64_t us;
161  if (av_parse_time(&us, timestr, is_duration) < 0) {
162  av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
163  is_duration ? "duration" : "date", context, timestr);
164  exit_program(1);
165  }
166  return us;
167 }
168 
169 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
170  int rej_flags, int alt_flags)
171 {
172  const OptionDef *po;
173  int first;
174 
175  first = 1;
176  for (po = options; po->name; po++) {
177  char buf[128];
178 
179  if (((po->flags & req_flags) != req_flags) ||
180  (alt_flags && !(po->flags & alt_flags)) ||
181  (po->flags & rej_flags))
182  continue;
183 
184  if (first) {
185  printf("%s\n", msg);
186  first = 0;
187  }
188  av_strlcpy(buf, po->name, sizeof(buf));
189  if (po->argname) {
190  av_strlcat(buf, " ", sizeof(buf));
191  av_strlcat(buf, po->argname, sizeof(buf));
192  }
193  printf("-%-17s %s\n", buf, po->help);
194  }
195  printf("\n");
196 }
197 
198 void show_help_children(const AVClass *class, int flags)
199 {
200  void *iter = NULL;
201  const AVClass *child;
202  if (class->option) {
203  av_opt_show2(&class, NULL, flags, 0);
204  printf("\n");
205  }
206 
207  while (child = av_opt_child_class_iterate(class, &iter))
208  show_help_children(child, flags);
209 }
210 
211 static const OptionDef *find_option(const OptionDef *po, const char *name)
212 {
213  while (po->name) {
214  const char *end;
215  if (av_strstart(name, po->name, &end) && (!*end || *end == ':'))
216  break;
217  po++;
218  }
219  return po;
220 }
221 
222 /* _WIN32 means using the windows libc - cygwin doesn't define that
223  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
224  * it doesn't provide the actual command line via GetCommandLineW(). */
225 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
226 #include <shellapi.h>
227 /* Will be leaked on exit */
228 static char** win32_argv_utf8 = NULL;
229 static int win32_argc = 0;
230 
231 /**
232  * Prepare command line arguments for executable.
233  * For Windows - perform wide-char to UTF-8 conversion.
234  * Input arguments should be main() function arguments.
235  * @param argc_ptr Arguments number (including executable)
236  * @param argv_ptr Arguments list.
237  */
238 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
239 {
240  char *argstr_flat;
241  wchar_t **argv_w;
242  int i, buffsize = 0, offset = 0;
243 
244  if (win32_argv_utf8) {
245  *argc_ptr = win32_argc;
246  *argv_ptr = win32_argv_utf8;
247  return;
248  }
249 
250  win32_argc = 0;
251  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
252  if (win32_argc <= 0 || !argv_w)
253  return;
254 
255  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
256  for (i = 0; i < win32_argc; i++)
257  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
258  NULL, 0, NULL, NULL);
259 
260  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
261  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
262  if (!win32_argv_utf8) {
263  LocalFree(argv_w);
264  return;
265  }
266 
267  for (i = 0; i < win32_argc; i++) {
268  win32_argv_utf8[i] = &argstr_flat[offset];
269  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
270  &argstr_flat[offset],
271  buffsize - offset, NULL, NULL);
272  }
273  win32_argv_utf8[i] = NULL;
274  LocalFree(argv_w);
275 
276  *argc_ptr = win32_argc;
277  *argv_ptr = win32_argv_utf8;
278 }
279 #else
280 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
281 {
282  /* nothing to do */
283 }
284 #endif /* HAVE_COMMANDLINETOARGVW */
285 
286 static int write_option(void *optctx, const OptionDef *po, const char *opt,
287  const char *arg)
288 {
289  /* new-style options contain an offset into optctx, old-style address of
290  * a global var*/
291  void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
292  (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
293  int *dstcount;
294 
295  if (po->flags & OPT_SPEC) {
296  SpecifierOpt **so = dst;
297  char *p = strchr(opt, ':');
298  char *str;
299 
300  dstcount = (int *)(so + 1);
301  *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
302  str = av_strdup(p ? p + 1 : "");
303  if (!str)
304  return AVERROR(ENOMEM);
305  (*so)[*dstcount - 1].specifier = str;
306  dst = &(*so)[*dstcount - 1].u;
307  }
308 
309  if (po->flags & OPT_STRING) {
310  char *str;
311  str = av_strdup(arg);
312  av_freep(dst);
313  if (!str)
314  return AVERROR(ENOMEM);
315  *(char **)dst = str;
316  } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
317  *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
318  } else if (po->flags & OPT_INT64) {
319  *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
320  } else if (po->flags & OPT_TIME) {
321  *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
322  } else if (po->flags & OPT_FLOAT) {
323  *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
324  } else if (po->flags & OPT_DOUBLE) {
325  *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
326  } else if (po->u.func_arg) {
327  int ret = po->u.func_arg(optctx, opt, arg);
328  if (ret < 0) {
330  "Failed to set value '%s' for option '%s': %s\n",
331  arg, opt, av_err2str(ret));
332  return ret;
333  }
334  }
335  if (po->flags & OPT_EXIT)
336  exit_program(0);
337 
338  return 0;
339 }
340 
341 int parse_option(void *optctx, const char *opt, const char *arg,
342  const OptionDef *options)
343 {
344  const OptionDef *po;
345  int ret;
346 
347  po = find_option(options, opt);
348  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
349  /* handle 'no' bool option */
350  po = find_option(options, opt + 2);
351  if ((po->name && (po->flags & OPT_BOOL)))
352  arg = "0";
353  } else if (po->flags & OPT_BOOL)
354  arg = "1";
355 
356  if (!po->name)
357  po = find_option(options, "default");
358  if (!po->name) {
359  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
360  return AVERROR(EINVAL);
361  }
362  if (po->flags & HAS_ARG && !arg) {
363  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
364  return AVERROR(EINVAL);
365  }
366 
367  ret = write_option(optctx, po, opt, arg);
368  if (ret < 0)
369  return ret;
370 
371  return !!(po->flags & HAS_ARG);
372 }
373 
374 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
375  void (*parse_arg_function)(void *, const char*))
376 {
377  const char *opt;
378  int optindex, handleoptions = 1, ret;
379 
380  /* perform system-dependent conversions for arguments list */
381  prepare_app_arguments(&argc, &argv);
382 
383  /* parse options */
384  optindex = 1;
385  while (optindex < argc) {
386  opt = argv[optindex++];
387 
388  if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
389  if (opt[1] == '-' && opt[2] == '\0') {
390  handleoptions = 0;
391  continue;
392  }
393  opt++;
394 
395  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
396  exit_program(1);
397  optindex += ret;
398  } else {
399  if (parse_arg_function)
400  parse_arg_function(optctx, opt);
401  }
402  }
403 }
404 
405 int parse_optgroup(void *optctx, OptionGroup *g)
406 {
407  int i, ret;
408 
409  av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
410  g->group_def->name, g->arg);
411 
412  for (i = 0; i < g->nb_opts; i++) {
413  Option *o = &g->opts[i];
414 
415  if (g->group_def->flags &&
416  !(g->group_def->flags & o->opt->flags)) {
417  av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
418  "%s %s -- you are trying to apply an input option to an "
419  "output file or vice versa. Move this option before the "
420  "file it belongs to.\n", o->key, o->opt->help,
421  g->group_def->name, g->arg);
422  return AVERROR(EINVAL);
423  }
424 
425  av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
426  o->key, o->opt->help, o->val);
427 
428  ret = write_option(optctx, o->opt, o->key, o->val);
429  if (ret < 0)
430  return ret;
431  }
432 
433  av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
434 
435  return 0;
436 }
437 
438 int locate_option(int argc, char **argv, const OptionDef *options,
439  const char *optname)
440 {
441  const OptionDef *po;
442  int i;
443 
444  for (i = 1; i < argc; i++) {
445  const char *cur_opt = argv[i];
446 
447  if (*cur_opt++ != '-')
448  continue;
449 
450  po = find_option(options, cur_opt);
451  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
452  po = find_option(options, cur_opt + 2);
453 
454  if ((!po->name && !strcmp(cur_opt, optname)) ||
455  (po->name && !strcmp(optname, po->name)))
456  return i;
457 
458  if (!po->name || po->flags & HAS_ARG)
459  i++;
460  }
461  return 0;
462 }
463 
464 static void dump_argument(const char *a)
465 {
466  const unsigned char *p;
467 
468  for (p = a; *p; p++)
469  if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
470  *p == '_' || (*p >= 'a' && *p <= 'z')))
471  break;
472  if (!*p) {
473  fputs(a, report_file);
474  return;
475  }
476  fputc('"', report_file);
477  for (p = a; *p; p++) {
478  if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
479  fprintf(report_file, "\\%c", *p);
480  else if (*p < ' ' || *p > '~')
481  fprintf(report_file, "\\x%02x", *p);
482  else
483  fputc(*p, report_file);
484  }
485  fputc('"', report_file);
486 }
487 
488 static void check_options(const OptionDef *po)
489 {
490  while (po->name) {
491  if (po->flags & OPT_PERFILE)
493  po++;
494  }
495 }
496 
497 void parse_loglevel(int argc, char **argv, const OptionDef *options)
498 {
499  int idx = locate_option(argc, argv, options, "loglevel");
500  const char *env;
501 
503 
504  if (!idx)
505  idx = locate_option(argc, argv, options, "v");
506  if (idx && argv[idx + 1])
507  opt_loglevel(NULL, "loglevel", argv[idx + 1]);
508  idx = locate_option(argc, argv, options, "report");
509  if ((env = getenv("FFREPORT")) || idx) {
510  init_report(env);
511  if (report_file) {
512  int i;
513  fprintf(report_file, "Command line:\n");
514  for (i = 0; i < argc; i++) {
515  dump_argument(argv[i]);
516  fputc(i < argc - 1 ? ' ' : '\n', report_file);
517  }
518  fflush(report_file);
519  }
520  }
521  idx = locate_option(argc, argv, options, "hide_banner");
522  if (idx)
523  hide_banner = 1;
524 }
525 
526 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
527  int opt_flags, int search_flags)
528 {
529  const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
530  if(o && !o->flags)
531  return NULL;
532  return o;
533 }
534 
535 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
536 int opt_default(void *optctx, const char *opt, const char *arg)
537 {
538  const AVOption *o;
539  int consumed = 0;
540  char opt_stripped[128];
541  const char *p;
542  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
543 #if CONFIG_SWSCALE
544  const AVClass *sc = sws_get_class();
545 #endif
546 #if CONFIG_SWRESAMPLE
547  const AVClass *swr_class = swr_get_class();
548 #endif
549 
550  if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
552 
553  if (!(p = strchr(opt, ':')))
554  p = opt + strlen(opt);
555  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
556 
557  if ((o = opt_find(&cc, opt_stripped, NULL, 0,
559  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
560  (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
561  av_dict_set(&codec_opts, opt, arg, FLAGS);
562  consumed = 1;
563  }
564  if ((o = opt_find(&fc, opt, NULL, 0,
566  av_dict_set(&format_opts, opt, arg, FLAGS);
567  if (consumed)
568  av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
569  consumed = 1;
570  }
571 #if CONFIG_SWSCALE
572  if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
574  struct SwsContext *sws = sws_alloc_context();
575  int ret = av_opt_set(sws, opt, arg, 0);
576  sws_freeContext(sws);
577  if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
578  !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
579  !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
580  av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
581  return AVERROR(EINVAL);
582  }
583  if (ret < 0) {
584  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
585  return ret;
586  }
587 
588  av_dict_set(&sws_dict, opt, arg, FLAGS);
589 
590  consumed = 1;
591  }
592 #else
593  if (!consumed && !strcmp(opt, "sws_flags")) {
594  av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
595  consumed = 1;
596  }
597 #endif
598 #if CONFIG_SWRESAMPLE
599  if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
601  struct SwrContext *swr = swr_alloc();
602  int ret = av_opt_set(swr, opt, arg, 0);
603  swr_free(&swr);
604  if (ret < 0) {
605  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
606  return ret;
607  }
608  av_dict_set(&swr_opts, opt, arg, FLAGS);
609  consumed = 1;
610  }
611 #endif
612 
613  if (consumed)
614  return 0;
616 }
617 
618 /*
619  * Check whether given option is a group separator.
620  *
621  * @return index of the group definition that matched or -1 if none
622  */
623 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
624  const char *opt)
625 {
626  int i;
627 
628  for (i = 0; i < nb_groups; i++) {
629  const OptionGroupDef *p = &groups[i];
630  if (p->sep && !strcmp(p->sep, opt))
631  return i;
632  }
633 
634  return -1;
635 }
636 
637 /*
638  * Finish parsing an option group.
639  *
640  * @param group_idx which group definition should this group belong to
641  * @param arg argument of the group delimiting option
642  */
643 static void finish_group(OptionParseContext *octx, int group_idx,
644  const char *arg)
645 {
646  OptionGroupList *l = &octx->groups[group_idx];
647  OptionGroup *g;
648 
649  GROW_ARRAY(l->groups, l->nb_groups);
650  g = &l->groups[l->nb_groups - 1];
651 
652  *g = octx->cur_group;
653  g->arg = arg;
654  g->group_def = l->group_def;
655  g->sws_dict = sws_dict;
656  g->swr_opts = swr_opts;
657  g->codec_opts = codec_opts;
658  g->format_opts = format_opts;
659 
660  codec_opts = NULL;
661  format_opts = NULL;
662  sws_dict = NULL;
663  swr_opts = NULL;
664 
665  memset(&octx->cur_group, 0, sizeof(octx->cur_group));
666 }
667 
668 /*
669  * Add an option instance to currently parsed group.
670  */
671 static void add_opt(OptionParseContext *octx, const OptionDef *opt,
672  const char *key, const char *val)
673 {
674  int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
675  OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
676 
677  GROW_ARRAY(g->opts, g->nb_opts);
678  g->opts[g->nb_opts - 1].opt = opt;
679  g->opts[g->nb_opts - 1].key = key;
680  g->opts[g->nb_opts - 1].val = val;
681 }
682 
684  const OptionGroupDef *groups, int nb_groups)
685 {
686  static const OptionGroupDef global_group = { "global" };
687  int i;
688 
689  memset(octx, 0, sizeof(*octx));
690 
691  octx->nb_groups = nb_groups;
692  octx->groups = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
693  if (!octx->groups)
694  exit_program(1);
695 
696  for (i = 0; i < octx->nb_groups; i++)
697  octx->groups[i].group_def = &groups[i];
698 
699  octx->global_opts.group_def = &global_group;
700  octx->global_opts.arg = "";
701 }
702 
704 {
705  int i, j;
706 
707  for (i = 0; i < octx->nb_groups; i++) {
708  OptionGroupList *l = &octx->groups[i];
709 
710  for (j = 0; j < l->nb_groups; j++) {
711  av_freep(&l->groups[j].opts);
714 
715  av_dict_free(&l->groups[j].sws_dict);
716  av_dict_free(&l->groups[j].swr_opts);
717  }
718  av_freep(&l->groups);
719  }
720  av_freep(&octx->groups);
721 
722  av_freep(&octx->cur_group.opts);
723  av_freep(&octx->global_opts.opts);
724 
725  uninit_opts();
726 }
727 
728 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
729  const OptionDef *options,
730  const OptionGroupDef *groups, int nb_groups)
731 {
732  int optindex = 1;
733  int dashdash = -2;
734 
735  /* perform system-dependent conversions for arguments list */
736  prepare_app_arguments(&argc, &argv);
737 
738  init_parse_context(octx, groups, nb_groups);
739  av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
740 
741  while (optindex < argc) {
742  const char *opt = argv[optindex++], *arg;
743  const OptionDef *po;
744  int ret;
745 
746  av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
747 
748  if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
749  dashdash = optindex;
750  continue;
751  }
752  /* unnamed group separators, e.g. output filename */
753  if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
754  finish_group(octx, 0, opt);
755  av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
756  continue;
757  }
758  opt++;
759 
760 #define GET_ARG(arg) \
761 do { \
762  arg = argv[optindex++]; \
763  if (!arg) { \
764  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
765  return AVERROR(EINVAL); \
766  } \
767 } while (0)
768 
769  /* named group separators, e.g. -i */
770  if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
771  GET_ARG(arg);
772  finish_group(octx, ret, arg);
773  av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
774  groups[ret].name, arg);
775  continue;
776  }
777 
778  /* normal options */
779  po = find_option(options, opt);
780  if (po->name) {
781  if (po->flags & OPT_EXIT) {
782  /* optional argument, e.g. -h */
783  arg = argv[optindex++];
784  } else if (po->flags & HAS_ARG) {
785  GET_ARG(arg);
786  } else {
787  arg = "1";
788  }
789 
790  add_opt(octx, po, opt, arg);
791  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
792  "argument '%s'.\n", po->name, po->help, arg);
793  continue;
794  }
795 
796  /* AVOptions */
797  if (argv[optindex]) {
798  ret = opt_default(NULL, opt, argv[optindex]);
799  if (ret >= 0) {
800  av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
801  "argument '%s'.\n", opt, argv[optindex]);
802  optindex++;
803  continue;
804  } else if (ret != AVERROR_OPTION_NOT_FOUND) {
805  av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
806  "with argument '%s'.\n", opt, argv[optindex]);
807  return ret;
808  }
809  }
810 
811  /* boolean -nofoo options */
812  if (opt[0] == 'n' && opt[1] == 'o' &&
813  (po = find_option(options, opt + 2)) &&
814  po->name && po->flags & OPT_BOOL) {
815  add_opt(octx, po, opt, "0");
816  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
817  "argument 0.\n", po->name, po->help);
818  continue;
819  }
820 
821  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
823  }
824 
825  if (octx->cur_group.nb_opts || codec_opts || format_opts)
826  av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
827  "command: may be ignored.\n");
828 
829  av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
830 
831  return 0;
832 }
833 
834 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
835 {
836  int ret;
837  unsigned flags = av_get_cpu_flags();
838 
839  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
840  return ret;
841 
843  return 0;
844 }
845 
846 int opt_cpucount(void *optctx, const char *opt, const char *arg)
847 {
848  int ret;
849  int count;
850 
851  static const AVOption opts[] = {
852  {"count", NULL, 0, AV_OPT_TYPE_INT, { .i64 = -1}, -1, INT_MAX},
853  {NULL},
854  };
855  static const AVClass class = {
856  .class_name = "cpucount",
857  .item_name = av_default_item_name,
858  .option = opts,
859  .version = LIBAVUTIL_VERSION_INT,
860  };
861  const AVClass *pclass = &class;
862 
863  ret = av_opt_eval_int(&pclass, opts, arg, &count);
864 
865  if (!ret) {
866  av_cpu_force_count(count);
867  }
868 
869  return ret;
870 }
871 
872 int opt_loglevel(void *optctx, const char *opt, const char *arg)
873 {
874  const struct { const char *name; int level; } log_levels[] = {
875  { "quiet" , AV_LOG_QUIET },
876  { "panic" , AV_LOG_PANIC },
877  { "fatal" , AV_LOG_FATAL },
878  { "error" , AV_LOG_ERROR },
879  { "warning", AV_LOG_WARNING },
880  { "info" , AV_LOG_INFO },
881  { "verbose", AV_LOG_VERBOSE },
882  { "debug" , AV_LOG_DEBUG },
883  { "trace" , AV_LOG_TRACE },
884  };
885  const char *token;
886  char *tail;
887  int flags = av_log_get_flags();
888  int level = av_log_get_level();
889  int cmd, i = 0;
890 
891  av_assert0(arg);
892  while (*arg) {
893  token = arg;
894  if (*token == '+' || *token == '-') {
895  cmd = *token++;
896  } else {
897  cmd = 0;
898  }
899  if (!i && !cmd) {
900  flags = 0; /* missing relative prefix, build absolute value */
901  }
902  if (av_strstart(token, "repeat", &arg)) {
903  if (cmd == '-') {
905  } else {
907  }
908  } else if (av_strstart(token, "level", &arg)) {
909  if (cmd == '-') {
911  } else {
913  }
914  } else {
915  break;
916  }
917  i++;
918  }
919  if (!*arg) {
920  goto end;
921  } else if (*arg == '+') {
922  arg++;
923  } else if (!i) {
924  flags = av_log_get_flags(); /* level value without prefix, reset flags */
925  }
926 
927  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
928  if (!strcmp(log_levels[i].name, arg)) {
929  level = log_levels[i].level;
930  goto end;
931  }
932  }
933 
934  level = strtol(arg, &tail, 10);
935  if (*tail) {
936  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
937  "Possible levels are numbers or:\n", arg);
938  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
939  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
940  exit_program(1);
941  }
942 
943 end:
946  return 0;
947 }
948 
949 static void expand_filename_template(AVBPrint *bp, const char *template,
950  struct tm *tm)
951 {
952  int c;
953 
954  while ((c = *(template++))) {
955  if (c == '%') {
956  if (!(c = *(template++)))
957  break;
958  switch (c) {
959  case 'p':
960  av_bprintf(bp, "%s", program_name);
961  break;
962  case 't':
963  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
964  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
965  tm->tm_hour, tm->tm_min, tm->tm_sec);
966  break;
967  case '%':
968  av_bprint_chars(bp, c, 1);
969  break;
970  }
971  } else {
972  av_bprint_chars(bp, c, 1);
973  }
974  }
975 }
976 
977 static int init_report(const char *env)
978 {
979  char *filename_template = NULL;
980  char *key, *val;
981  int ret, count = 0;
982  int prog_loglevel, envlevel = 0;
983  time_t now;
984  struct tm *tm;
985  AVBPrint filename;
986 
987  if (report_file) /* already opened */
988  return 0;
989  time(&now);
990  tm = localtime(&now);
991 
992  while (env && *env) {
993  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
994  if (count)
996  "Failed to parse FFREPORT environment variable: %s\n",
997  av_err2str(ret));
998  break;
999  }
1000  if (*env)
1001  env++;
1002  count++;
1003  if (!strcmp(key, "file")) {
1004  av_free(filename_template);
1005  filename_template = val;
1006  val = NULL;
1007  } else if (!strcmp(key, "level")) {
1008  char *tail;
1009  report_file_level = strtol(val, &tail, 10);
1010  if (*tail) {
1011  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1012  exit_program(1);
1013  }
1014  envlevel = 1;
1015  } else {
1016  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1017  }
1018  av_free(val);
1019  av_free(key);
1020  }
1021 
1023  expand_filename_template(&filename,
1024  av_x_if_null(filename_template, "%p-%t.log"), tm);
1025  av_free(filename_template);
1026  if (!av_bprint_is_complete(&filename)) {
1027  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1028  return AVERROR(ENOMEM);
1029  }
1030 
1031  prog_loglevel = av_log_get_level();
1032  if (!envlevel)
1033  report_file_level = FFMAX(report_file_level, prog_loglevel);
1034 
1035  report_file = fopen(filename.str, "w");
1036  if (!report_file) {
1037  int ret = AVERROR(errno);
1038  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1039  filename.str, strerror(errno));
1040  return ret;
1041  }
1044  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1045  "Report written to \"%s\"\n"
1046  "Log level: %d\n",
1047  program_name,
1048  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1049  tm->tm_hour, tm->tm_min, tm->tm_sec,
1050  filename.str, report_file_level);
1051  av_bprint_finalize(&filename, NULL);
1052  return 0;
1053 }
1054 
1055 int opt_report(void *optctx, const char *opt, const char *arg)
1056 {
1057  return init_report(NULL);
1058 }
1059 
1060 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1061 {
1062  char *tail;
1063  size_t max;
1064 
1065  max = strtol(arg, &tail, 10);
1066  if (*tail) {
1067  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1068  exit_program(1);
1069  }
1070  av_max_alloc(max);
1071  return 0;
1072 }
1073 
1074 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1075 {
1076 #if HAVE_SETRLIMIT
1077  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1078  struct rlimit rl = { lim, lim + 1 };
1079  if (setrlimit(RLIMIT_CPU, &rl))
1080  perror("setrlimit");
1081 #else
1082  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1083 #endif
1084  return 0;
1085 }
1086 
1087 void print_error(const char *filename, int err)
1088 {
1089  char errbuf[128];
1090  const char *errbuf_ptr = errbuf;
1091 
1092  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
1093  errbuf_ptr = strerror(AVUNERROR(err));
1094  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
1095 }
1096 
1097 static int warned_cfg = 0;
1098 
1099 #define INDENT 1
1100 #define SHOW_VERSION 2
1101 #define SHOW_CONFIG 4
1102 #define SHOW_COPYRIGHT 8
1103 
1104 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
1105  if (CONFIG_##LIBNAME) { \
1106  const char *indent = flags & INDENT? " " : ""; \
1107  if (flags & SHOW_VERSION) { \
1108  unsigned int version = libname##_version(); \
1109  av_log(NULL, level, \
1110  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
1111  indent, #libname, \
1112  LIB##LIBNAME##_VERSION_MAJOR, \
1113  LIB##LIBNAME##_VERSION_MINOR, \
1114  LIB##LIBNAME##_VERSION_MICRO, \
1115  AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
1116  AV_VERSION_MICRO(version)); \
1117  } \
1118  if (flags & SHOW_CONFIG) { \
1119  const char *cfg = libname##_configuration(); \
1120  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
1121  if (!warned_cfg) { \
1122  av_log(NULL, level, \
1123  "%sWARNING: library configuration mismatch\n", \
1124  indent); \
1125  warned_cfg = 1; \
1126  } \
1127  av_log(NULL, level, "%s%-11s configuration: %s\n", \
1128  indent, #libname, cfg); \
1129  } \
1130  } \
1131  } \
1132 
1133 static void print_all_libs_info(int flags, int level)
1134 {
1135  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
1136  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
1137  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
1138  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
1139  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
1140  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
1141  PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
1142  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
1143 }
1144 
1145 static void print_program_info(int flags, int level)
1146 {
1147  const char *indent = flags & INDENT? " " : "";
1148 
1149  av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
1150  if (flags & SHOW_COPYRIGHT)
1151  av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
1152  program_birth_year, CONFIG_THIS_YEAR);
1153  av_log(NULL, level, "\n");
1154  av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
1155 
1156  av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
1157 }
1158 
1159 static void print_buildconf(int flags, int level)
1160 {
1161  const char *indent = flags & INDENT ? " " : "";
1162  char str[] = { FFMPEG_CONFIGURATION };
1163  char *conflist, *remove_tilde, *splitconf;
1164 
1165  // Change all the ' --' strings to '~--' so that
1166  // they can be identified as tokens.
1167  while ((conflist = strstr(str, " --")) != NULL) {
1168  conflist[0] = '~';
1169  }
1170 
1171  // Compensate for the weirdness this would cause
1172  // when passing 'pkg-config --static'.
1173  while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
1174  remove_tilde[sizeof("pkg-config~") - 2] = ' ';
1175  }
1176 
1177  splitconf = strtok(str, "~");
1178  av_log(NULL, level, "\n%sconfiguration:\n", indent);
1179  while (splitconf != NULL) {
1180  av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
1181  splitconf = strtok(NULL, "~");
1182  }
1183 }
1184 
1185 void show_banner(int argc, char **argv, const OptionDef *options)
1186 {
1187  int idx = locate_option(argc, argv, options, "version");
1188  if (hide_banner || idx)
1189  return;
1190 
1194 }
1195 
1196 int show_version(void *optctx, const char *opt, const char *arg)
1197 {
1201 
1202  return 0;
1203 }
1204 
1205 int show_buildconf(void *optctx, const char *opt, const char *arg)
1206 {
1209 
1210  return 0;
1211 }
1212 
1213 int show_license(void *optctx, const char *opt, const char *arg)
1214 {
1215 #if CONFIG_NONFREE
1216  printf(
1217  "This version of %s has nonfree parts compiled in.\n"
1218  "Therefore it is not legally redistributable.\n",
1219  program_name );
1220 #elif CONFIG_GPLV3
1221  printf(
1222  "%s is free software; you can redistribute it and/or modify\n"
1223  "it under the terms of the GNU General Public License as published by\n"
1224  "the Free Software Foundation; either version 3 of the License, or\n"
1225  "(at your option) any later version.\n"
1226  "\n"
1227  "%s is distributed in the hope that it will be useful,\n"
1228  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1229  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1230  "GNU General Public License for more details.\n"
1231  "\n"
1232  "You should have received a copy of the GNU General Public License\n"
1233  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1235 #elif CONFIG_GPL
1236  printf(
1237  "%s is free software; you can redistribute it and/or modify\n"
1238  "it under the terms of the GNU General Public License as published by\n"
1239  "the Free Software Foundation; either version 2 of the License, or\n"
1240  "(at your option) any later version.\n"
1241  "\n"
1242  "%s is distributed in the hope that it will be useful,\n"
1243  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1244  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1245  "GNU General Public License for more details.\n"
1246  "\n"
1247  "You should have received a copy of the GNU General Public License\n"
1248  "along with %s; if not, write to the Free Software\n"
1249  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1251 #elif CONFIG_LGPLV3
1252  printf(
1253  "%s is free software; you can redistribute it and/or modify\n"
1254  "it under the terms of the GNU Lesser General Public License as published by\n"
1255  "the Free Software Foundation; either version 3 of the License, or\n"
1256  "(at your option) any later version.\n"
1257  "\n"
1258  "%s is distributed in the hope that it will be useful,\n"
1259  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1260  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1261  "GNU Lesser General Public License for more details.\n"
1262  "\n"
1263  "You should have received a copy of the GNU Lesser General Public License\n"
1264  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1266 #else
1267  printf(
1268  "%s is free software; you can redistribute it and/or\n"
1269  "modify it under the terms of the GNU Lesser General Public\n"
1270  "License as published by the Free Software Foundation; either\n"
1271  "version 2.1 of the License, or (at your option) any later version.\n"
1272  "\n"
1273  "%s is distributed in the hope that it will be useful,\n"
1274  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1275  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
1276  "Lesser General Public License for more details.\n"
1277  "\n"
1278  "You should have received a copy of the GNU Lesser General Public\n"
1279  "License along with %s; if not, write to the Free Software\n"
1280  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1282 #endif
1283 
1284  return 0;
1285 }
1286 
1287 static int is_device(const AVClass *avclass)
1288 {
1289  if (!avclass)
1290  return 0;
1291  return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
1292 }
1293 
1294 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
1295 {
1296  void *ifmt_opaque = NULL;
1297  const AVInputFormat *ifmt = NULL;
1298  void *ofmt_opaque = NULL;
1299  const AVOutputFormat *ofmt = NULL;
1300  const char *last_name;
1301  int is_dev;
1302 
1303  printf("%s\n"
1304  " D. = Demuxing supported\n"
1305  " .E = Muxing supported\n"
1306  " --\n", device_only ? "Devices:" : "File formats:");
1307  last_name = "000";
1308  for (;;) {
1309  int decode = 0;
1310  int encode = 0;
1311  const char *name = NULL;
1312  const char *long_name = NULL;
1313 
1314  if (muxdemuxers !=SHOW_DEMUXERS) {
1315  ofmt_opaque = NULL;
1316  while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
1317  is_dev = is_device(ofmt->priv_class);
1318  if (!is_dev && device_only)
1319  continue;
1320  if ((!name || strcmp(ofmt->name, name) < 0) &&
1321  strcmp(ofmt->name, last_name) > 0) {
1322  name = ofmt->name;
1323  long_name = ofmt->long_name;
1324  encode = 1;
1325  }
1326  }
1327  }
1328  if (muxdemuxers != SHOW_MUXERS) {
1329  ifmt_opaque = NULL;
1330  while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
1331  is_dev = is_device(ifmt->priv_class);
1332  if (!is_dev && device_only)
1333  continue;
1334  if ((!name || strcmp(ifmt->name, name) < 0) &&
1335  strcmp(ifmt->name, last_name) > 0) {
1336  name = ifmt->name;
1337  long_name = ifmt->long_name;
1338  encode = 0;
1339  }
1340  if (name && strcmp(ifmt->name, name) == 0)
1341  decode = 1;
1342  }
1343  }
1344  if (!name)
1345  break;
1346  last_name = name;
1347 
1348  printf(" %c%c %-15s %s\n",
1349  decode ? 'D' : ' ',
1350  encode ? 'E' : ' ',
1351  name,
1352  long_name ? long_name:" ");
1353  }
1354  return 0;
1355 }
1356 
1357 int show_formats(void *optctx, const char *opt, const char *arg)
1358 {
1359  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
1360 }
1361 
1362 int show_muxers(void *optctx, const char *opt, const char *arg)
1363 {
1364  return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
1365 }
1366 
1367 int show_demuxers(void *optctx, const char *opt, const char *arg)
1368 {
1369  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
1370 }
1371 
1372 int show_devices(void *optctx, const char *opt, const char *arg)
1373 {
1374  return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
1375 }
1376 
1377 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
1378  if (codec->field) { \
1379  const type *p = codec->field; \
1380  \
1381  printf(" Supported " list_name ":"); \
1382  while (*p != term) { \
1383  get_name(*p); \
1384  printf(" %s", name); \
1385  p++; \
1386  } \
1387  printf("\n"); \
1388  } \
1389 
1390 static void print_codec(const AVCodec *c)
1391 {
1392  int encoder = av_codec_is_encoder(c);
1393 
1394  printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
1395  c->long_name ? c->long_name : "");
1396 
1397  printf(" General capabilities: ");
1398  if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
1399  printf("horizband ");
1400  if (c->capabilities & AV_CODEC_CAP_DR1)
1401  printf("dr1 ");
1402  if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
1403  printf("trunc ");
1404  if (c->capabilities & AV_CODEC_CAP_DELAY)
1405  printf("delay ");
1406  if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
1407  printf("small ");
1408  if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
1409  printf("subframes ");
1410  if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
1411  printf("exp ");
1412  if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
1413  printf("chconf ");
1414  if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
1415  printf("paramchange ");
1416  if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
1417  printf("variable ");
1418  if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1421  printf("threads ");
1422  if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
1423  printf("avoidprobe ");
1424  if (c->capabilities & AV_CODEC_CAP_HARDWARE)
1425  printf("hardware ");
1426  if (c->capabilities & AV_CODEC_CAP_HYBRID)
1427  printf("hybrid ");
1428  if (!c->capabilities)
1429  printf("none");
1430  printf("\n");
1431 
1432  if (c->type == AVMEDIA_TYPE_VIDEO ||
1433  c->type == AVMEDIA_TYPE_AUDIO) {
1434  printf(" Threading capabilities: ");
1435  switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1439  AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
1440  case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
1441  case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
1442  case AV_CODEC_CAP_OTHER_THREADS: printf("other"); break;
1443  default: printf("none"); break;
1444  }
1445  printf("\n");
1446  }
1447 
1448  if (avcodec_get_hw_config(c, 0)) {
1449  printf(" Supported hardware devices: ");
1450  for (int i = 0;; i++) {
1452  if (!config)
1453  break;
1454  printf("%s ", av_hwdevice_get_type_name(config->device_type));
1455  }
1456  printf("\n");
1457  }
1458 
1459  if (c->supported_framerates) {
1460  const AVRational *fps = c->supported_framerates;
1461 
1462  printf(" Supported framerates:");
1463  while (fps->num) {
1464  printf(" %d/%d", fps->num, fps->den);
1465  fps++;
1466  }
1467  printf("\n");
1468  }
1469  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
1471  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
1473  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1475  PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1476  0, GET_CH_LAYOUT_DESC);
1477 
1478  if (c->priv_class) {
1479  show_help_children(c->priv_class,
1482  }
1483 }
1484 
1486 {
1487  switch (type) {
1488  case AVMEDIA_TYPE_VIDEO: return 'V';
1489  case AVMEDIA_TYPE_AUDIO: return 'A';
1490  case AVMEDIA_TYPE_DATA: return 'D';
1491  case AVMEDIA_TYPE_SUBTITLE: return 'S';
1492  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
1493  default: return '?';
1494  }
1495 }
1496 
1497 static const AVCodec *next_codec_for_id(enum AVCodecID id, void **iter,
1498  int encoder)
1499 {
1500  const AVCodec *c;
1501  while ((c = av_codec_iterate(iter))) {
1502  if (c->id == id &&
1503  (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
1504  return c;
1505  }
1506  return NULL;
1507 }
1508 
1509 static int compare_codec_desc(const void *a, const void *b)
1510 {
1511  const AVCodecDescriptor * const *da = a;
1512  const AVCodecDescriptor * const *db = b;
1513 
1514  return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
1515  strcmp((*da)->name, (*db)->name);
1516 }
1517 
1518 static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
1519 {
1520  const AVCodecDescriptor *desc = NULL;
1521  const AVCodecDescriptor **codecs;
1522  unsigned nb_codecs = 0, i = 0;
1523 
1524  while ((desc = avcodec_descriptor_next(desc)))
1525  nb_codecs++;
1526  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
1527  av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
1528  exit_program(1);
1529  }
1530  desc = NULL;
1531  while ((desc = avcodec_descriptor_next(desc)))
1532  codecs[i++] = desc;
1533  av_assert0(i == nb_codecs);
1534  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
1535  *rcodecs = codecs;
1536  return nb_codecs;
1537 }
1538 
1539 static void print_codecs_for_id(enum AVCodecID id, int encoder)
1540 {
1541  void *iter = NULL;
1542  const AVCodec *codec;
1543 
1544  printf(" (%s: ", encoder ? "encoders" : "decoders");
1545 
1546  while ((codec = next_codec_for_id(id, &iter, encoder)))
1547  printf("%s ", codec->name);
1548 
1549  printf(")");
1550 }
1551 
1552 int show_codecs(void *optctx, const char *opt, const char *arg)
1553 {
1554  const AVCodecDescriptor **codecs;
1555  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1556 
1557  printf("Codecs:\n"
1558  " D..... = Decoding supported\n"
1559  " .E.... = Encoding supported\n"
1560  " ..V... = Video codec\n"
1561  " ..A... = Audio codec\n"
1562  " ..S... = Subtitle codec\n"
1563  " ...I.. = Intra frame-only codec\n"
1564  " ....L. = Lossy compression\n"
1565  " .....S = Lossless compression\n"
1566  " -------\n");
1567  for (i = 0; i < nb_codecs; i++) {
1568  const AVCodecDescriptor *desc = codecs[i];
1569  const AVCodec *codec;
1570  void *iter = NULL;
1571 
1572  if (strstr(desc->name, "_deprecated"))
1573  continue;
1574 
1575  printf(" ");
1576  printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1577  printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1578 
1579  printf("%c", get_media_type_char(desc->type));
1580  printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1581  printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
1582  printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
1583 
1584  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1585 
1586  /* print decoders/encoders when there's more than one or their
1587  * names are different from codec name */
1588  while ((codec = next_codec_for_id(desc->id, &iter, 0))) {
1589  if (strcmp(codec->name, desc->name)) {
1590  print_codecs_for_id(desc->id, 0);
1591  break;
1592  }
1593  }
1594  iter = NULL;
1595  while ((codec = next_codec_for_id(desc->id, &iter, 1))) {
1596  if (strcmp(codec->name, desc->name)) {
1597  print_codecs_for_id(desc->id, 1);
1598  break;
1599  }
1600  }
1601 
1602  printf("\n");
1603  }
1604  av_free(codecs);
1605  return 0;
1606 }
1607 
1608 static void print_codecs(int encoder)
1609 {
1610  const AVCodecDescriptor **codecs;
1611  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1612 
1613  printf("%s:\n"
1614  " V..... = Video\n"
1615  " A..... = Audio\n"
1616  " S..... = Subtitle\n"
1617  " .F.... = Frame-level multithreading\n"
1618  " ..S... = Slice-level multithreading\n"
1619  " ...X.. = Codec is experimental\n"
1620  " ....B. = Supports draw_horiz_band\n"
1621  " .....D = Supports direct rendering method 1\n"
1622  " ------\n",
1623  encoder ? "Encoders" : "Decoders");
1624  for (i = 0; i < nb_codecs; i++) {
1625  const AVCodecDescriptor *desc = codecs[i];
1626  const AVCodec *codec;
1627  void *iter = NULL;
1628 
1629  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
1630  printf(" %c", get_media_type_char(desc->type));
1631  printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1632  printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1633  printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
1634  printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
1635  printf((codec->capabilities & AV_CODEC_CAP_DR1) ? "D" : ".");
1636 
1637  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1638  if (strcmp(codec->name, desc->name))
1639  printf(" (codec %s)", desc->name);
1640 
1641  printf("\n");
1642  }
1643  }
1644  av_free(codecs);
1645 }
1646 
1647 int show_decoders(void *optctx, const char *opt, const char *arg)
1648 {
1649  print_codecs(0);
1650  return 0;
1651 }
1652 
1653 int show_encoders(void *optctx, const char *opt, const char *arg)
1654 {
1655  print_codecs(1);
1656  return 0;
1657 }
1658 
1659 int show_bsfs(void *optctx, const char *opt, const char *arg)
1660 {
1661  const AVBitStreamFilter *bsf = NULL;
1662  void *opaque = NULL;
1663 
1664  printf("Bitstream filters:\n");
1665  while ((bsf = av_bsf_iterate(&opaque)))
1666  printf("%s\n", bsf->name);
1667  printf("\n");
1668  return 0;
1669 }
1670 
1671 int show_protocols(void *optctx, const char *opt, const char *arg)
1672 {
1673  void *opaque = NULL;
1674  const char *name;
1675 
1676  printf("Supported file protocols:\n"
1677  "Input:\n");
1678  while ((name = avio_enum_protocols(&opaque, 0)))
1679  printf(" %s\n", name);
1680  printf("Output:\n");
1681  while ((name = avio_enum_protocols(&opaque, 1)))
1682  printf(" %s\n", name);
1683  return 0;
1684 }
1685 
1686 int show_filters(void *optctx, const char *opt, const char *arg)
1687 {
1688 #if CONFIG_AVFILTER
1689  const AVFilter *filter = NULL;
1690  char descr[64], *descr_cur;
1691  void *opaque = NULL;
1692  int i, j;
1693  const AVFilterPad *pad;
1694 
1695  printf("Filters:\n"
1696  " T.. = Timeline support\n"
1697  " .S. = Slice threading\n"
1698  " ..C = Command support\n"
1699  " A = Audio input/output\n"
1700  " V = Video input/output\n"
1701  " N = Dynamic number and/or type of input/output\n"
1702  " | = Source or sink filter\n");
1703  while ((filter = av_filter_iterate(&opaque))) {
1704  descr_cur = descr;
1705  for (i = 0; i < 2; i++) {
1706  unsigned nb_pads;
1707  if (i) {
1708  *(descr_cur++) = '-';
1709  *(descr_cur++) = '>';
1710  }
1711  pad = i ? filter->outputs : filter->inputs;
1712  nb_pads = avfilter_filter_pad_count(filter, i);
1713  for (j = 0; j < nb_pads; j++) {
1714  if (descr_cur >= descr + sizeof(descr) - 4)
1715  break;
1716  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
1717  }
1718  if (!j)
1719  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1720  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1721  }
1722  *descr_cur = 0;
1723  printf(" %c%c%c %-17s %-10s %s\n",
1724  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1725  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
1726  filter->process_command ? 'C' : '.',
1727  filter->name, descr, filter->description);
1728  }
1729 #else
1730  printf("No filters available: libavfilter disabled\n");
1731 #endif
1732  return 0;
1733 }
1734 
1735 int show_colors(void *optctx, const char *opt, const char *arg)
1736 {
1737  const char *name;
1738  const uint8_t *rgb;
1739  int i;
1740 
1741  printf("%-32s #RRGGBB\n", "name");
1742 
1743  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1744  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1745 
1746  return 0;
1747 }
1748 
1749 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1750 {
1751  const AVPixFmtDescriptor *pix_desc = NULL;
1752 
1753  printf("Pixel formats:\n"
1754  "I.... = Supported Input format for conversion\n"
1755  ".O... = Supported Output format for conversion\n"
1756  "..H.. = Hardware accelerated format\n"
1757  "...P. = Paletted format\n"
1758  "....B = Bitstream format\n"
1759  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1760  "-----\n");
1761 
1762 #if !CONFIG_SWSCALE
1763 # define sws_isSupportedInput(x) 0
1764 # define sws_isSupportedOutput(x) 0
1765 #endif
1766 
1767  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1769  printf("%c%c%c%c%c %-16s %d %2d\n",
1770  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
1771  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
1772  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
1773  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
1774  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1775  pix_desc->name,
1776  pix_desc->nb_components,
1777  av_get_bits_per_pixel(pix_desc));
1778  }
1779  return 0;
1780 }
1781 
1782 int show_layouts(void *optctx, const char *opt, const char *arg)
1783 {
1784  int i = 0;
1785  uint64_t layout, j;
1786  const char *name, *descr;
1787 
1788  printf("Individual channels:\n"
1789  "NAME DESCRIPTION\n");
1790  for (i = 0; i < 63; i++) {
1791  name = av_get_channel_name((uint64_t)1 << i);
1792  if (!name)
1793  continue;
1794  descr = av_get_channel_description((uint64_t)1 << i);
1795  printf("%-14s %s\n", name, descr);
1796  }
1797  printf("\nStandard channel layouts:\n"
1798  "NAME DECOMPOSITION\n");
1799  for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1800  if (name) {
1801  printf("%-14s ", name);
1802  for (j = 1; j; j <<= 1)
1803  if ((layout & j))
1804  printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1805  printf("\n");
1806  }
1807  }
1808  return 0;
1809 }
1810 
1811 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1812 {
1813  int i;
1814  char fmt_str[128];
1815  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1816  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1817  return 0;
1818 }
1819 
1820 static void show_help_codec(const char *name, int encoder)
1821 {
1822  const AVCodecDescriptor *desc;
1823  const AVCodec *codec;
1824 
1825  if (!name) {
1826  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1827  return;
1828  }
1829 
1830  codec = encoder ? avcodec_find_encoder_by_name(name) :
1832 
1833  if (codec)
1834  print_codec(codec);
1835  else if ((desc = avcodec_descriptor_get_by_name(name))) {
1836  void *iter = NULL;
1837  int printed = 0;
1838 
1839  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
1840  printed = 1;
1841  print_codec(codec);
1842  }
1843 
1844  if (!printed) {
1845  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1846  "but no %s for it are available. FFmpeg might need to be "
1847  "recompiled with additional external libraries.\n",
1848  name, encoder ? "encoders" : "decoders");
1849  }
1850  } else {
1851  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1852  name);
1853  }
1854 }
1855 
1856 static void show_help_demuxer(const char *name)
1857 {
1858  const AVInputFormat *fmt = av_find_input_format(name);
1859 
1860  if (!fmt) {
1861  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1862  return;
1863  }
1864 
1865  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1866 
1867  if (fmt->extensions)
1868  printf(" Common extensions: %s.\n", fmt->extensions);
1869 
1870  if (fmt->priv_class)
1872 }
1873 
1874 static void show_help_protocol(const char *name)
1875 {
1876  const AVClass *proto_class;
1877 
1878  if (!name) {
1879  av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
1880  return;
1881  }
1882 
1883  proto_class = avio_protocol_get_class(name);
1884  if (!proto_class) {
1885  av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
1886  return;
1887  }
1888 
1890 }
1891 
1892 static void show_help_muxer(const char *name)
1893 {
1894  const AVCodecDescriptor *desc;
1895  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1896 
1897  if (!fmt) {
1898  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1899  return;
1900  }
1901 
1902  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1903 
1904  if (fmt->extensions)
1905  printf(" Common extensions: %s.\n", fmt->extensions);
1906  if (fmt->mime_type)
1907  printf(" Mime type: %s.\n", fmt->mime_type);
1908  if (fmt->video_codec != AV_CODEC_ID_NONE &&
1910  printf(" Default video codec: %s.\n", desc->name);
1911  }
1912  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1914  printf(" Default audio codec: %s.\n", desc->name);
1915  }
1916  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1918  printf(" Default subtitle codec: %s.\n", desc->name);
1919  }
1920 
1921  if (fmt->priv_class)
1923 }
1924 
1925 #if CONFIG_AVFILTER
1926 static void show_help_filter(const char *name)
1927 {
1928 #if CONFIG_AVFILTER
1929  const AVFilter *f = avfilter_get_by_name(name);
1930  int i, count;
1931 
1932  if (!name) {
1933  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1934  return;
1935  } else if (!f) {
1936  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1937  return;
1938  }
1939 
1940  printf("Filter %s\n", f->name);
1941  if (f->description)
1942  printf(" %s\n", f->description);
1943 
1944  if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
1945  printf(" slice threading supported\n");
1946 
1947  printf(" Inputs:\n");
1948  count = avfilter_filter_pad_count(f, 0);
1949  for (i = 0; i < count; i++) {
1950  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1952  }
1953  if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
1954  printf(" dynamic (depending on the options)\n");
1955  else if (!count)
1956  printf(" none (source filter)\n");
1957 
1958  printf(" Outputs:\n");
1959  count = avfilter_filter_pad_count(f, 1);
1960  for (i = 0; i < count; i++) {
1961  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1963  }
1964  if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
1965  printf(" dynamic (depending on the options)\n");
1966  else if (!count)
1967  printf(" none (sink filter)\n");
1968 
1969  if (f->priv_class)
1972  if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
1973  printf("This filter has support for timeline through the 'enable' option.\n");
1974 #else
1975  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1976  "can not to satisfy request\n");
1977 #endif
1978 }
1979 #endif
1980 
1981 static void show_help_bsf(const char *name)
1982 {
1984 
1985  if (!name) {
1986  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
1987  return;
1988  } else if (!bsf) {
1989  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
1990  return;
1991  }
1992 
1993  printf("Bit stream filter %s\n", bsf->name);
1994  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
1996  if (bsf->priv_class)
1998 }
1999 
2000 int show_help(void *optctx, const char *opt, const char *arg)
2001 {
2002  char *topic, *par;
2004 
2005  topic = av_strdup(arg ? arg : "");
2006  if (!topic)
2007  return AVERROR(ENOMEM);
2008  par = strchr(topic, '=');
2009  if (par)
2010  *par++ = 0;
2011 
2012  if (!*topic) {
2013  show_help_default(topic, par);
2014  } else if (!strcmp(topic, "decoder")) {
2015  show_help_codec(par, 0);
2016  } else if (!strcmp(topic, "encoder")) {
2017  show_help_codec(par, 1);
2018  } else if (!strcmp(topic, "demuxer")) {
2019  show_help_demuxer(par);
2020  } else if (!strcmp(topic, "muxer")) {
2021  show_help_muxer(par);
2022  } else if (!strcmp(topic, "protocol")) {
2023  show_help_protocol(par);
2024 #if CONFIG_AVFILTER
2025  } else if (!strcmp(topic, "filter")) {
2026  show_help_filter(par);
2027 #endif
2028  } else if (!strcmp(topic, "bsf")) {
2029  show_help_bsf(par);
2030  } else {
2031  show_help_default(topic, par);
2032  }
2033 
2034  av_freep(&topic);
2035  return 0;
2036 }
2037 
2038 int read_yesno(void)
2039 {
2040  int c = getchar();
2041  int yesno = (av_toupper(c) == 'Y');
2042 
2043  while (c != '\n' && c != EOF)
2044  c = getchar();
2045 
2046  return yesno;
2047 }
2048 
2049 FILE *get_preset_file(char *filename, size_t filename_size,
2050  const char *preset_name, int is_path,
2051  const char *codec_name)
2052 {
2053  FILE *f = NULL;
2054  int i;
2055  const char *base[3] = { getenv("FFMPEG_DATADIR"),
2056  getenv("HOME"),
2057  FFMPEG_DATADIR, };
2058 
2059  if (is_path) {
2060  av_strlcpy(filename, preset_name, filename_size);
2061  f = fopen(filename, "r");
2062  } else {
2063 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
2064  char datadir[MAX_PATH], *ls;
2065  base[2] = NULL;
2066 
2067  if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
2068  {
2069  for (ls = datadir; ls < datadir + strlen(datadir); ls++)
2070  if (*ls == '\\') *ls = '/';
2071 
2072  if (ls = strrchr(datadir, '/'))
2073  {
2074  *ls = 0;
2075  strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
2076  base[2] = datadir;
2077  }
2078  }
2079 #endif
2080  for (i = 0; i < 3 && !f; i++) {
2081  if (!base[i])
2082  continue;
2083  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
2084  i != 1 ? "" : "/.ffmpeg", preset_name);
2085  f = fopen(filename, "r");
2086  if (!f && codec_name) {
2087  snprintf(filename, filename_size,
2088  "%s%s/%s-%s.ffpreset",
2089  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
2090  preset_name);
2091  f = fopen(filename, "r");
2092  }
2093  }
2094  }
2095 
2096  return f;
2097 }
2098 
2099 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
2100 {
2101  int ret = avformat_match_stream_specifier(s, st, spec);
2102  if (ret < 0)
2103  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
2104  return ret;
2105 }
2106 
2108  AVFormatContext *s, AVStream *st, const AVCodec *codec)
2109 {
2110  AVDictionary *ret = NULL;
2111  AVDictionaryEntry *t = NULL;
2112  int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
2114  char prefix = 0;
2115  const AVClass *cc = avcodec_get_class();
2116 
2117  if (!codec)
2118  codec = s->oformat ? avcodec_find_encoder(codec_id)
2120 
2121  switch (st->codecpar->codec_type) {
2122  case AVMEDIA_TYPE_VIDEO:
2123  prefix = 'v';
2125  break;
2126  case AVMEDIA_TYPE_AUDIO:
2127  prefix = 'a';
2129  break;
2130  case AVMEDIA_TYPE_SUBTITLE:
2131  prefix = 's';
2133  break;
2134  }
2135 
2136  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
2137  const AVClass *priv_class;
2138  char *p = strchr(t->key, ':');
2139 
2140  /* check stream specification in opt name */
2141  if (p)
2142  switch (check_stream_specifier(s, st, p + 1)) {
2143  case 1: *p = 0; break;
2144  case 0: continue;
2145  default: exit_program(1);
2146  }
2147 
2148  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
2149  !codec ||
2150  ((priv_class = codec->priv_class) &&
2151  av_opt_find(&priv_class, t->key, NULL, flags,
2153  av_dict_set(&ret, t->key, t->value, 0);
2154  else if (t->key[0] == prefix &&
2155  av_opt_find(&cc, t->key + 1, NULL, flags,
2157  av_dict_set(&ret, t->key + 1, t->value, 0);
2158 
2159  if (p)
2160  *p = ':';
2161  }
2162  return ret;
2163 }
2164 
2167 {
2168  int i;
2169  AVDictionary **opts;
2170 
2171  if (!s->nb_streams)
2172  return NULL;
2173  opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
2174  if (!opts) {
2176  "Could not alloc memory for stream options.\n");
2177  return NULL;
2178  }
2179  for (i = 0; i < s->nb_streams; i++)
2180  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
2181  s, s->streams[i], NULL);
2182  return opts;
2183 }
2184 
2185 void *grow_array(void *array, int elem_size, int *size, int new_size)
2186 {
2187  if (new_size >= INT_MAX / elem_size) {
2188  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
2189  exit_program(1);
2190  }
2191  if (*size < new_size) {
2192  uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
2193  if (!tmp) {
2194  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
2195  exit_program(1);
2196  }
2197  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
2198  *size = new_size;
2199  return tmp;
2200  }
2201  return array;
2202 }
2203 
2204 double get_rotation(int32_t *displaymatrix)
2205 {
2206  double theta = 0;
2207  if (displaymatrix)
2208  theta = -round(av_display_rotation_get((int32_t*) displaymatrix));
2209 
2210  theta -= 360*floor(theta/360 + 0.9/360);
2211 
2212  if (fabs(theta - 90*round(theta/90)) > 2)
2213  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
2214  "If you want to help, upload a sample "
2215  "of this file to https://streams.videolan.org/upload/ "
2216  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
2217 
2218  return theta;
2219 }
2220 
2221 #if CONFIG_AVDEVICE
2222 static int print_device_sources(const AVInputFormat *fmt, AVDictionary *opts)
2223 {
2224  int ret, i;
2225  AVDeviceInfoList *device_list = NULL;
2226 
2227  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
2228  return AVERROR(EINVAL);
2229 
2230  printf("Auto-detected sources for %s:\n", fmt->name);
2231  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
2232  printf("Cannot list sources: %s\n", av_err2str(ret));
2233  goto fail;
2234  }
2235 
2236  for (i = 0; i < device_list->nb_devices; i++) {
2237  printf("%c %s [%s]\n", device_list->default_device == i ? '*' : ' ',
2238  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2239  }
2240 
2241  fail:
2242  avdevice_free_list_devices(&device_list);
2243  return ret;
2244 }
2245 
2246 static int print_device_sinks(const AVOutputFormat *fmt, AVDictionary *opts)
2247 {
2248  int ret, i;
2249  AVDeviceInfoList *device_list = NULL;
2250 
2251  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
2252  return AVERROR(EINVAL);
2253 
2254  printf("Auto-detected sinks for %s:\n", fmt->name);
2255  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
2256  printf("Cannot list sinks: %s\n", av_err2str(ret));
2257  goto fail;
2258  }
2259 
2260  for (i = 0; i < device_list->nb_devices; i++) {
2261  printf("%c %s [%s]\n", device_list->default_device == i ? '*' : ' ',
2262  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2263  }
2264 
2265  fail:
2266  avdevice_free_list_devices(&device_list);
2267  return ret;
2268 }
2269 
2270 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
2271 {
2272  int ret;
2273  if (arg) {
2274  char *opts_str = NULL;
2275  av_assert0(dev && opts);
2276  *dev = av_strdup(arg);
2277  if (!*dev)
2278  return AVERROR(ENOMEM);
2279  if ((opts_str = strchr(*dev, ','))) {
2280  *(opts_str++) = '\0';
2281  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
2282  av_freep(dev);
2283  return ret;
2284  }
2285  }
2286  } else
2287  printf("\nDevice name is not provided.\n"
2288  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
2289  return 0;
2290 }
2291 
2292 int show_sources(void *optctx, const char *opt, const char *arg)
2293 {
2294  const AVInputFormat *fmt = NULL;
2295  char *dev = NULL;
2296  AVDictionary *opts = NULL;
2297  int ret = 0;
2298  int error_level = av_log_get_level();
2299 
2301 
2302  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2303  goto fail;
2304 
2305  do {
2306  fmt = av_input_audio_device_next(fmt);
2307  if (fmt) {
2308  if (!strcmp(fmt->name, "lavfi"))
2309  continue; //it's pointless to probe lavfi
2310  if (dev && !av_match_name(dev, fmt->name))
2311  continue;
2312  print_device_sources(fmt, opts);
2313  }
2314  } while (fmt);
2315  do {
2316  fmt = av_input_video_device_next(fmt);
2317  if (fmt) {
2318  if (dev && !av_match_name(dev, fmt->name))
2319  continue;
2320  print_device_sources(fmt, opts);
2321  }
2322  } while (fmt);
2323  fail:
2324  av_dict_free(&opts);
2325  av_free(dev);
2326  av_log_set_level(error_level);
2327  return ret;
2328 }
2329 
2330 int show_sinks(void *optctx, const char *opt, const char *arg)
2331 {
2332  const AVOutputFormat *fmt = NULL;
2333  char *dev = NULL;
2334  AVDictionary *opts = NULL;
2335  int ret = 0;
2336  int error_level = av_log_get_level();
2337 
2339 
2340  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2341  goto fail;
2342 
2343  do {
2344  fmt = av_output_audio_device_next(fmt);
2345  if (fmt) {
2346  if (dev && !av_match_name(dev, fmt->name))
2347  continue;
2348  print_device_sinks(fmt, opts);
2349  }
2350  } while (fmt);
2351  do {
2352  fmt = av_output_video_device_next(fmt);
2353  if (fmt) {
2354  if (dev && !av_match_name(dev, fmt->name))
2355  continue;
2356  print_device_sinks(fmt, opts);
2357  }
2358  } while (fmt);
2359  fail:
2360  av_dict_free(&opts);
2361  av_free(dev);
2362  av_log_set_level(error_level);
2363  return ret;
2364 }
2365 
2366 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
OPT_FLOAT
#define OPT_FLOAT
Definition: cmdutils.h:173
GET_ARG
#define GET_ARG(arg)
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:176
AVCodec
AVCodec.
Definition: codec.h:197
av_force_cpu_flags
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:68
print_codecs_for_id
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: cmdutils.c:1539
OptionGroup::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:315
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:3282
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:204
avfilter_filter_pad_count
unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
Get the number of elements in an AVFilter's inputs or outputs array.
Definition: avfilter.c:595
INFINITY
#define INFINITY
Definition: mathematics.h:67
sws_isSupportedInput
#define sws_isSupportedInput(x)
AVOutputFormat::extensions
const char * extensions
comma-separated filename extensions
Definition: avformat.h:504
AVOutputFormat::name
const char * name
Definition: avformat.h:496
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
avio_protocol_get_class
const AVClass * avio_protocol_get_class(const char *name)
Get AVClass by names of available protocols.
Definition: protocols.c:109
opt.h
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:280
GET_SAMPLE_RATE_NAME
#define GET_SAMPLE_RATE_NAME(rate)
Definition: cmdutils.h:636
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_IS_INPUT_DEVICE
#define AV_IS_INPUT_DEVICE(category)
Definition: log.h:49
avfilter_pad_get_name
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:973
OptionDef::off
size_t off
Definition: cmdutils.h:188
AVCodec::long_name
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:209
libm.h
report_file
static FILE * report_file
Definition: cmdutils.c:73
show_formats
int show_formats(void *optctx, const char *opt, const char *arg)
Print a listing containing all the formats supported by the program (including devices).
Definition: cmdutils.c:1357
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:234
AV_CODEC_PROP_LOSSY
#define AV_CODEC_PROP_LOSSY
Codec supports lossy compression.
Definition: codec_desc.h:78
opt_report
int opt_report(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1055
av_get_sample_fmt_string
char * av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt)
Generate a string corresponding to the sample format with sample_fmt, or a header if sample_fmt is ne...
Definition: samplefmt.c:93
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:68
show_layouts
int show_layouts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the standard channel layouts supported by the program.
Definition: cmdutils.c:1782
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
av_cpu_force_count
void av_cpu_force_count(int count)
Overrides cpu count detection and forces the specified count.
Definition: cpu.c:239
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:162
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
init_parse_context
static void init_parse_context(OptionParseContext *octx, const OptionGroupDef *groups, int nb_groups)
Definition: cmdutils.c:683
SHOW_DEFAULT
@ SHOW_DEFAULT
Definition: cmdutils.c:78
log_callback_report
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
Definition: cmdutils.c:96
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
va_copy.h
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:157
AV_LOG_PANIC
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:167
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:458
sws_dict
AVDictionary * sws_dict
Definition: cmdutils.c:69
show_help_codec
static void show_help_codec(const char *name, int encoder)
Definition: cmdutils.c:1820
get_media_type_char
static char get_media_type_char(enum AVMediaType type)
Definition: cmdutils.c:1485
AVBitStreamFilter::name
const char * name
Definition: bsf.h:91
opt_cpucount
int opt_cpucount(void *optctx, const char *opt, const char *arg)
Override the cpucount.
Definition: cmdutils.c:846
codecs
static struct codec_string codecs[]
show_version
int show_version(void *optctx, const char *opt, const char *arg)
Print the version of the program to stdout.
Definition: cmdutils.c:1196
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:188
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:109
av_unused
#define av_unused
Definition: attributes.h:131
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:467
GET_PIX_FMT_NAME
#define GET_PIX_FMT_NAME(pix_fmt)
Definition: cmdutils.h:627
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:912
AV_CODEC_CAP_TRUNCATED
#define AV_CODEC_CAP_TRUNCATED
Definition: codec.h:53
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
pixdesc.h
print_codec
static void print_codec(const AVCodec *c)
Definition: cmdutils.c:1390
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:216
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:183
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
AVOption
AVOption.
Definition: opt.h:247
HAS_ARG
#define HAS_ARG
Definition: cmdutils.h:166
OptionGroupList::groups
OptionGroup * groups
Definition: cmdutils.h:334
b
#define b
Definition: input.c:40
OptionDef::dst_ptr
void * dst_ptr
Definition: cmdutils.h:186
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:335
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2547
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:71
avio_enum_protocols
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: protocols.c:94
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:214
FLAGS
#define FLAGS
Definition: cmdutils.c:535
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:141
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
OptionGroup::swr_opts
AVDictionary * swr_opts
Definition: cmdutils.h:324
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:198
AVOption::flags
int flags
Definition: opt.h:276
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2492
SHOW_COPYRIGHT
#define SHOW_COPYRIGHT
Definition: cmdutils.c:1102
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
av_bsf_iterate
const AVBitStreamFilter * av_bsf_iterate(void **opaque)
Iterate over all registered bitstream filters.
Definition: bitstream_filters.c:67
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:96
hide_banner
int hide_banner
Definition: cmdutils.c:75
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:293
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:508
av_input_audio_device_next
const AVInputFormat * av_input_audio_device_next(const AVInputFormat *d)
Audio input devices iterator.
Definition: alldevices.c:123
OptionDef
Definition: cmdutils.h:163
AVUNERROR
#define AVUNERROR(e)
Definition: error.h:46
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:78
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:638
avdevice_list_output_sinks
int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:133
exit_program
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:128
av_max_alloc
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:73
parse_number_or_die
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:136
rgb
Definition: rpzaenc.c:59
print_error
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:1087
OptionGroupList
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:331
bsf.h
fail
#define fail()
Definition: checkasm.h:127
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
show_decoders
int show_decoders(void *optctx, const char *opt, const char *arg)
Print a listing containing all the decoders supported by the program.
Definition: cmdutils.c:1647
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
SHOW_CONFIG
#define SHOW_CONFIG
Definition: cmdutils.c:1101
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:546
av_parse_cpu_caps
int av_parse_cpu_caps(unsigned *flags, const char *s)
Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
Definition: cpu.c:106
OptionParseContext
Definition: cmdutils.h:338
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
Option
An option extracted from the commandline.
Definition: cmdutils.h:293
val
static double val(void *priv, double ch)
Definition: aeval.c:76
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:98
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
OptionGroup::nb_opts
int nb_opts
Definition: cmdutils.h:319
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
show_muxdemuxers
show_muxdemuxers
Definition: cmdutils.c:77
OPT_STRING
#define OPT_STRING
Definition: cmdutils.h:169
OptionGroupList::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:332
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:110
OptionDef::help
const char * help
Definition: cmdutils.h:190
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
show_help_bsf
static void show_help_bsf(const char *name)
Definition: cmdutils.c:1981
OptionGroupDef
Definition: cmdutils.h:299
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:466
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:2099
SHOW_VERSION
#define SHOW_VERSION
Definition: cmdutils.c:1100
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:206
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
print_buildconf
static void print_buildconf(int flags, int level)
Definition: cmdutils.c:1159
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:100
AVInputFormat
Definition: avformat.h:626
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:652
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:321
avdevice_list_input_sources
int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:122
expand_filename_template
static void expand_filename_template(AVBPrint *bp, const char *template, struct tm *tm)
Definition: cmdutils.c:949
check_options
static void check_options(const OptionDef *po)
Definition: cmdutils.c:488
media_type_string
#define media_type_string
Definition: cmdutils.h:622
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
postprocess.h
class
#define class
Definition: math.h:25
av_log_format_line
void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix)
Format a line of log the same way as the default callback.
Definition: log.c:328
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
OPT_INT
#define OPT_INT
Definition: cmdutils.h:172
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:257
OptionDef::argname
const char * argname
Definition: cmdutils.h:191
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:728
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:277
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:222
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:631
g
const char * g
Definition: vf_curves.c:117
AVDictionaryEntry::key
char * key
Definition: dict.h:80
Option::key
const char * key
Definition: cmdutils.h:295
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:150
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:506
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:249
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
dump_argument
static void dump_argument(const char *a)
Definition: cmdutils.c:464
report_file_level
static int report_file_level
Definition: cmdutils.c:74
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:92
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
parse_options
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:374
AV_OPT_FLAG_BSF_PARAM
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:291
key
const char * key
Definition: hwcontext_opencl.c:168
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:279
compare_codec_desc
static int compare_codec_desc(const void *a, const void *b)
Definition: cmdutils.c:1509
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:1661
arg
const char * arg
Definition: jacosubdec.c:67
OPT_SPEC
#define OPT_SPEC
Definition: cmdutils.h:180
finish_group
static void finish_group(OptionParseContext *octx, int group_idx, const char *arg)
Definition: cmdutils.c:643
AV_IS_OUTPUT_DEVICE
#define AV_IS_OUTPUT_DEVICE(category)
Definition: log.h:54
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
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
show_buildconf
int show_buildconf(void *optctx, const char *opt, const char *arg)
Print the build configuration of the program to stdout.
Definition: cmdutils.c:1205
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:557
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:112
opts
AVDictionary * opts
Definition: movenc.c:50
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:322
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:992
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:174
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:339
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:945
Option::opt
const OptionDef * opt
Definition: cmdutils.h:294
prepare_app_arguments
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
Definition: cmdutils.c:280
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
swr_get_class
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:145
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
next_codec_for_id
static const AVCodec * next_codec_for_id(enum AVCodecID id, void **iter, int encoder)
Definition: cmdutils.c:1497
AVOutputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:502
show_formats_devices
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
Definition: cmdutils.c:1294
GET_CODEC_NAME
#define GET_CODEC_NAME(id)
Definition: cmdutils.h:630
warned_cfg
static int warned_cfg
Definition: cmdutils.c:1097
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:445
parseutils.h
INDENT
#define INDENT
Definition: cmdutils.c:1099
sws_alloc_context
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1106
show_muxers
int show_muxers(void *optctx, const char *opt, const char *arg)
Print a listing containing all the muxers supported by the program (including devices).
Definition: cmdutils.c:1362
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:109
OPT_INT64
#define OPT_INT64
Definition: cmdutils.h:175
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:129
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:587
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:524
write_option
static int write_option(void *optctx, const OptionDef *po, const char *opt, const char *arg)
Definition: cmdutils.c:286
av_get_standard_channel_layout
int av_get_standard_channel_layout(unsigned index, uint64_t *layout, const char **name)
Get the value and name of a standard channel layout.
Definition: channel_layout.c:285
OptionGroup::opts
Option * opts
Definition: cmdutils.h:318
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
OptionGroup
Definition: cmdutils.h:314
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
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:567
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:917
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:116
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
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:438
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:81
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:71
options
const OptionDef options[]
eval.h
show_help_demuxer
static void show_help_demuxer(const char *name)
Definition: cmdutils.c:1856
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_SAMPLE_FMT_NB
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:74
show_help
int show_help(void *optctx, const char *opt, const char *arg)
Generic -h handler common to all fftools.
Definition: cmdutils.c:2000
AVMediaType
AVMediaType
Definition: avutil.h:199
av_log_set_callback
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:455
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: utils.c:1492
AVClass::category
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:114
cpu.h
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:121
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:2049
PRINT_CODEC_SUPPORTED
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name)
Definition: cmdutils.c:1377
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
av_output_video_device_next
const AVOutputFormat * av_output_video_device_next(const AVOutputFormat *d)
Video output devices iterator.
Definition: alldevices.c:138
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:83
size
int size
Definition: twinvq_data.h:10344
print_codecs
static void print_codecs(int encoder)
Definition: cmdutils.c:1608
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:124
setup_find_stream_info_opts
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2165
GET_SAMPLE_FMT_NAME
#define GET_SAMPLE_FMT_NAME(sample_fmt)
Definition: cmdutils.h:633
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:557
printf
printf("static const uint8_t my_array[100] = {\n")
show_protocols
int show_protocols(void *optctx, const char *opt, const char *arg)
Print a listing containing all the protocols supported by the program.
Definition: cmdutils.c:1671
av_log_get_flags
int av_log_get_flags(void)
Definition: log.c:450
avdevice.h
avdevice_free_list_devices
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:144
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:559
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
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
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
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
line
Definition: graph2dot.c:48
attributes.h
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2559
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
show_devices
int show_devices(void *optctx, const char *opt, const char *arg)
Print a listing containing all the devices supported by the program.
Definition: cmdutils.c:1372
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:34
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:459
show_pix_fmts
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the pixel formats supported by the program.
Definition: cmdutils.c:1749
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:503
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
show_sample_fmts
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the sample formats supported by the program.
Definition: cmdutils.c:1811
avcodec_descriptor_next
const AVCodecDescriptor * avcodec_descriptor_next(const AVCodecDescriptor *prev)
Iterate over all codec descriptors known to libavcodec.
Definition: codec_desc.c:3520
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1185
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:76
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
program_exit
static void(* program_exit)(int ret)
Definition: cmdutils.c:121
register_exit
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:123
GET_CH_LAYOUT_DESC
#define GET_CH_LAYOUT_DESC(ch_layout)
Definition: cmdutils.h:644
AV_CODEC_PROP_LOSSLESS
#define AV_CODEC_PROP_LOSSLESS
Codec supports lossless compression.
Definition: codec_desc.h:82
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:440
bprint.h
i
int i
Definition: input.c:406
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:495
print_all_libs_info
static void print_all_libs_info(int flags, int level)
Definition: cmdutils.c:1133
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
OPT_TIME
#define OPT_TIME
Definition: cmdutils.h:181
swr_opts
AVDictionary * swr_opts
Definition: cmdutils.c:70
display.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
filter_codec_opts
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2107
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:278
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SHOW_MUXERS
@ SHOW_MUXERS
Definition: cmdutils.c:80
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:261
get_codecs_sorted
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: cmdutils.c:1518
OPT_OUTPUT
#define OPT_OUTPUT
Definition: cmdutils.h:184
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
opt_timelimit
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:1074
OPT_OFFSET
#define OPT_OFFSET
Definition: cmdutils.h:179
opt_max_alloc
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1060
OptionParseContext::groups
OptionGroupList * groups
Definition: cmdutils.h:341
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:869
parse_optgroup
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:405
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:497
AVFilter
Filter definition.
Definition: avfilter.h:149
version.h
OptionGroup::sws_dict
AVDictionary * sws_dict
Definition: cmdutils.h:323
SpecifierOpt
Definition: cmdutils.h:151
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:845
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
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:2038
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
av_strtod
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
av_opt_eval_int
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
OptionGroup::arg
const char * arg
Definition: cmdutils.h:316
AVDeviceInfoList
List of devices.
Definition: avdevice.h:465
uninit_parse_context
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:703
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:91
OPT_PERFILE
#define OPT_PERFILE
Definition: cmdutils.h:178
av_opt_get_key_value
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
Definition: opt.c:1537
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:93
dict.h
av_get_channel_description
const char * av_get_channel_description(uint64_t channel)
Get the description of a given channel.
Definition: channel_layout.c:260
AV_LOG_SKIP_REPEATED
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
Definition: log.h:370
add_opt
static void add_opt(OptionParseContext *octx, const OptionDef *opt, const char *key, const char *val)
Definition: cmdutils.c:671
show_codecs
int show_codecs(void *optctx, const char *opt, const char *arg)
Print a listing containing all the codecs supported by the program.
Definition: cmdutils.c:1552
init_report
static int init_report(const char *env)
Definition: cmdutils.c:977
avfilter_pad_get_type
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:978
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:540
parse_option
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:341
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Equivalent of av_mallocz_array().
Definition: mem.c:269
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:468
channel_layout.h
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:1720
opt_cpuflags
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
Override the cpuflags.
Definition: cmdutils.c:834
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2329
AVBitStreamFilter
Definition: bsf.h:90
SHOW_DEMUXERS
@ SHOW_DEMUXERS
Definition: cmdutils.c:79
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
av_match_name
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:353
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
swscale
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[], int dstSliceY, int dstSliceH)
Definition: swscale.c:238
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:507
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
Option::val
const char * val
Definition: cmdutils.h:296
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:624
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:860
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:116
print_program_info
static void print_program_info(int flags, int level)
Definition: cmdutils.c:1145
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:121
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:536
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:277
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_log_default_callback
void av_log_default_callback(void *ptr, int level, const char *fmt, va_list vl)
Default logging callback.
Definition: log.c:346
av_guess_format
const AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
av_output_audio_device_next
const AVOutputFormat * av_output_audio_device_next(const AVOutputFormat *d)
Audio output devices iterator.
Definition: alldevices.c:133
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:95
AV_OPT_FLAG_SUBTITLE_PARAM
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:281
show_colors
int show_colors(void *optctx, const char *opt, const char *arg)
Print a listing containing all the color names and values recognized by the program.
Definition: cmdutils.c:1735
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc_bsf.c:148
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:164
av_get_known_color_name
const char * av_get_known_color_name(int color_idx, const uint8_t **rgbp)
Get the name of a color from the internal table of hard-coded named colors.
Definition: parseutils.c:434
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
OptionDef::name
const char * name
Definition: cmdutils.h:164
show_filters
int show_filters(void *optctx, const char *opt, const char *arg)
Print a listing containing all the filters supported by the program.
Definition: cmdutils.c:1686
show_encoders
int show_encoders(void *optctx, const char *opt, const char *arg)
Print a listing containing all the encoders supported by the program.
Definition: cmdutils.c:1653
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:79
opt_loglevel
int opt_loglevel(void *optctx, const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: cmdutils.c:872
show_help_protocol
static void show_help_protocol(const char *name)
Definition: cmdutils.c:1874
OptionGroupDef::sep
const char * sep
Option to be used as group separator.
Definition: cmdutils.h:306
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
AVFILTER_FLAG_SUPPORT_TIMELINE
#define AVFILTER_FLAG_SUPPORT_TIMELINE
Handy mask to test whether the filter supports or no the timeline feature (internally or generically)...
Definition: avfilter.h:143
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
cmdutils.h
OPT_BOOL
#define OPT_BOOL
Definition: cmdutils.h:167
d
d
Definition: ffmpeg_filter.c:156
int32_t
int32_t
Definition: audioconvert.c:56
convert_header.str
string str
Definition: convert_header.py:20
parse_time_or_die
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds.
Definition: cmdutils.c:157
grow_array
void * grow_array(void *array, int elem_size, int *size, int new_size)
Realloc array to hold new_size elements of elem_size.
Definition: cmdutils.c:2185
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
rgb
static const SheerTable rgb[2]
Definition: sheervideodata.h:32
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
OptionParseContext::nb_groups
int nb_groups
Definition: cmdutils.h:342
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:139
find_option
static const OptionDef * find_option(const OptionDef *po, const char *name)
Definition: cmdutils.c:211
AVCodecHWConfig
Definition: codec.h:455
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3514
AVDictionaryEntry::value
char * value
Definition: dict.h:81
av_input_video_device_next
const AVInputFormat * av_input_video_device_next(const AVInputFormat *d)
Video input devices iterator.
Definition: alldevices.c:128
get_rotation
double get_rotation(int32_t *displaymatrix)
Definition: cmdutils.c:2204
avstring.h
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:169
show_bsfs
int show_bsfs(void *optctx, const char *opt, const char *arg)
Print a listing containing all the bit stream filters supported by the program.
Definition: cmdutils.c:1659
show_license
int show_license(void *optctx, const char *opt, const char *arg)
Print the license of the program to stdout.
Definition: cmdutils.c:1213
PRINT_LIB_INFO
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)
Definition: cmdutils.c:1104
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3529
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
SwsContext
Definition: swscale_internal.h:298
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:1346
show_help_muxer
static void show_help_muxer(const char *name)
Definition: cmdutils.c:1892
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
snprintf
#define snprintf
Definition: snprintf.h:34
OptionParseContext::cur_group
OptionGroup cur_group
Definition: cmdutils.h:345
AV_LOG_PRINT_LEVEL
#define AV_LOG_PRINT_LEVEL
Include the log severity in messages originating from codecs.
Definition: log.h:378
is_device
static int is_device(const AVClass *avclass)
Definition: cmdutils.c:1287
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:139
show_demuxers
int show_demuxers(void *optctx, const char *opt, const char *arg)
Print a listing containing all the demuxer supported by the program (including devices).
Definition: cmdutils.c:1367
swscale.h
match_group_separator
static int match_group_separator(const OptionGroupDef *groups, int nb_groups, const char *opt)
Definition: cmdutils.c:623
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:656
OptionDef::func_arg
int(* func_arg)(void *, const char *, const char *)
Definition: cmdutils.h:187
opt_find
static const AVOption * opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Definition: cmdutils.c:526
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
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:34
avcodec_find_encoder_by_name
const AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:940
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:110
min
float min
Definition: vorbis_enc_data.h:429
OptionDef::flags
int flags
Definition: cmdutils.h:165
OPT_DOUBLE
#define OPT_DOUBLE
Definition: cmdutils.h:182