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"
38 #include "libswscale/swscale.h"
41 #include "libavutil/attributes.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #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 "cmdutils.h"
58 #if HAVE_SYS_RESOURCE_H
59 #include <sys/time.h>
60 #include <sys/resource.h>
61 #endif
62 #ifdef _WIN32
63 #include <windows.h>
64 #endif
65 
66 static int init_report(const char *env);
67 
71 
72 static FILE *report_file;
74 int hide_banner = 0;
75 
80 };
81 
82 void init_opts(void)
83 {
84  av_dict_set(&sws_dict, "flags", "bicubic", 0);
85 }
86 
87 void uninit_opts(void)
88 {
89  av_dict_free(&swr_opts);
90  av_dict_free(&sws_dict);
91  av_dict_free(&format_opts);
92  av_dict_free(&codec_opts);
93  av_dict_free(&resample_opts);
94 }
95 
96 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
97 {
98  vfprintf(stdout, fmt, vl);
99 }
100 
101 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
102 {
103  va_list vl2;
104  char line[1024];
105  static int print_prefix = 1;
106 
107  va_copy(vl2, vl);
108  av_log_default_callback(ptr, level, fmt, vl);
109  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
110  va_end(vl2);
111  if (report_file_level >= level) {
112  fputs(line, report_file);
113  fflush(report_file);
114  }
115 }
116 
117 void init_dynload(void)
118 {
119 #if HAVE_SETDLLDIRECTORY && defined(_WIN32)
120  /* Calling SetDllDirectory with the empty string (but not NULL) removes the
121  * current working directory from the DLL search path as a security pre-caution. */
122  SetDllDirectory("");
123 #endif
124 }
125 
126 static void (*program_exit)(int ret);
127 
128 void register_exit(void (*cb)(int ret))
129 {
130  program_exit = cb;
131 }
132 
133 void exit_program(int ret)
134 {
135  if (program_exit)
136  program_exit(ret);
137 
138  exit(ret);
139 }
140 
141 double parse_number_or_die(const char *context, const char *numstr, int type,
142  double min, double max)
143 {
144  char *tail;
145  const char *error;
146  double d = av_strtod(numstr, &tail);
147  if (*tail)
148  error = "Expected number for %s but found: %s\n";
149  else if (d < min || d > max)
150  error = "The value for %s was %s which is not within %f - %f\n";
151  else if (type == OPT_INT64 && (int64_t)d != d)
152  error = "Expected int64 for %s but found %s\n";
153  else if (type == OPT_INT && (int)d != d)
154  error = "Expected int for %s but found %s\n";
155  else
156  return d;
157  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
158  exit_program(1);
159  return 0;
160 }
161 
162 int64_t parse_time_or_die(const char *context, const char *timestr,
163  int is_duration)
164 {
165  int64_t us;
166  if (av_parse_time(&us, timestr, is_duration) < 0) {
167  av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
168  is_duration ? "duration" : "date", context, timestr);
169  exit_program(1);
170  }
171  return us;
172 }
173 
174 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
175  int rej_flags, int alt_flags)
176 {
177  const OptionDef *po;
178  int first;
179 
180  first = 1;
181  for (po = options; po->name; po++) {
182  char buf[128];
183 
184  if (((po->flags & req_flags) != req_flags) ||
185  (alt_flags && !(po->flags & alt_flags)) ||
186  (po->flags & rej_flags))
187  continue;
188 
189  if (first) {
190  printf("%s\n", msg);
191  first = 0;
192  }
193  av_strlcpy(buf, po->name, sizeof(buf));
194  if (po->argname) {
195  av_strlcat(buf, " ", sizeof(buf));
196  av_strlcat(buf, po->argname, sizeof(buf));
197  }
198  printf("-%-17s %s\n", buf, po->help);
199  }
200  printf("\n");
201 }
202 
203 void show_help_children(const AVClass *class, int flags)
204 {
205  void *iter = NULL;
206  const AVClass *child;
207  if (class->option) {
208  av_opt_show2(&class, NULL, flags, 0);
209  printf("\n");
210  }
211 
212  while (child = av_opt_child_class_iterate(class, &iter))
213  show_help_children(child, flags);
214 }
215 
216 static const OptionDef *find_option(const OptionDef *po, const char *name)
217 {
218  const char *p = strchr(name, ':');
219  int len = p ? p - name : strlen(name);
220 
221  while (po->name) {
222  if (!strncmp(name, po->name, len) && strlen(po->name) == len)
223  break;
224  po++;
225  }
226  return po;
227 }
228 
229 /* _WIN32 means using the windows libc - cygwin doesn't define that
230  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
231  * it doesn't provide the actual command line via GetCommandLineW(). */
232 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
233 #include <shellapi.h>
234 /* Will be leaked on exit */
235 static char** win32_argv_utf8 = NULL;
236 static int win32_argc = 0;
237 
238 /**
239  * Prepare command line arguments for executable.
240  * For Windows - perform wide-char to UTF-8 conversion.
241  * Input arguments should be main() function arguments.
242  * @param argc_ptr Arguments number (including executable)
243  * @param argv_ptr Arguments list.
244  */
245 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
246 {
247  char *argstr_flat;
248  wchar_t **argv_w;
249  int i, buffsize = 0, offset = 0;
250 
251  if (win32_argv_utf8) {
252  *argc_ptr = win32_argc;
253  *argv_ptr = win32_argv_utf8;
254  return;
255  }
256 
257  win32_argc = 0;
258  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
259  if (win32_argc <= 0 || !argv_w)
260  return;
261 
262  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
263  for (i = 0; i < win32_argc; i++)
264  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
265  NULL, 0, NULL, NULL);
266 
267  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
268  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
269  if (!win32_argv_utf8) {
270  LocalFree(argv_w);
271  return;
272  }
273 
274  for (i = 0; i < win32_argc; i++) {
275  win32_argv_utf8[i] = &argstr_flat[offset];
276  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
277  &argstr_flat[offset],
278  buffsize - offset, NULL, NULL);
279  }
280  win32_argv_utf8[i] = NULL;
281  LocalFree(argv_w);
282 
283  *argc_ptr = win32_argc;
284  *argv_ptr = win32_argv_utf8;
285 }
286 #else
287 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
288 {
289  /* nothing to do */
290 }
291 #endif /* HAVE_COMMANDLINETOARGVW */
292 
293 static int write_option(void *optctx, const OptionDef *po, const char *opt,
294  const char *arg)
295 {
296  /* new-style options contain an offset into optctx, old-style address of
297  * a global var*/
298  void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
299  (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
300  int *dstcount;
301 
302  if (po->flags & OPT_SPEC) {
303  SpecifierOpt **so = dst;
304  char *p = strchr(opt, ':');
305  char *str;
306 
307  dstcount = (int *)(so + 1);
308  *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
309  str = av_strdup(p ? p + 1 : "");
310  if (!str)
311  return AVERROR(ENOMEM);
312  (*so)[*dstcount - 1].specifier = str;
313  dst = &(*so)[*dstcount - 1].u;
314  }
315 
316  if (po->flags & OPT_STRING) {
317  char *str;
318  str = av_strdup(arg);
319  av_freep(dst);
320  if (!str)
321  return AVERROR(ENOMEM);
322  *(char **)dst = str;
323  } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
324  *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
325  } else if (po->flags & OPT_INT64) {
326  *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
327  } else if (po->flags & OPT_TIME) {
328  *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
329  } else if (po->flags & OPT_FLOAT) {
330  *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
331  } else if (po->flags & OPT_DOUBLE) {
332  *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
333  } else if (po->u.func_arg) {
334  int ret = po->u.func_arg(optctx, opt, arg);
335  if (ret < 0) {
337  "Failed to set value '%s' for option '%s': %s\n",
338  arg, opt, av_err2str(ret));
339  return ret;
340  }
341  }
342  if (po->flags & OPT_EXIT)
343  exit_program(0);
344 
345  return 0;
346 }
347 
348 int parse_option(void *optctx, const char *opt, const char *arg,
349  const OptionDef *options)
350 {
351  const OptionDef *po;
352  int ret;
353 
354  po = find_option(options, opt);
355  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
356  /* handle 'no' bool option */
357  po = find_option(options, opt + 2);
358  if ((po->name && (po->flags & OPT_BOOL)))
359  arg = "0";
360  } else if (po->flags & OPT_BOOL)
361  arg = "1";
362 
363  if (!po->name)
364  po = find_option(options, "default");
365  if (!po->name) {
366  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
367  return AVERROR(EINVAL);
368  }
369  if (po->flags & HAS_ARG && !arg) {
370  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
371  return AVERROR(EINVAL);
372  }
373 
374  ret = write_option(optctx, po, opt, arg);
375  if (ret < 0)
376  return ret;
377 
378  return !!(po->flags & HAS_ARG);
379 }
380 
381 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
382  void (*parse_arg_function)(void *, const char*))
383 {
384  const char *opt;
385  int optindex, handleoptions = 1, ret;
386 
387  /* perform system-dependent conversions for arguments list */
388  prepare_app_arguments(&argc, &argv);
389 
390  /* parse options */
391  optindex = 1;
392  while (optindex < argc) {
393  opt = argv[optindex++];
394 
395  if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
396  if (opt[1] == '-' && opt[2] == '\0') {
397  handleoptions = 0;
398  continue;
399  }
400  opt++;
401 
402  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
403  exit_program(1);
404  optindex += ret;
405  } else {
406  if (parse_arg_function)
407  parse_arg_function(optctx, opt);
408  }
409  }
410 }
411 
412 int parse_optgroup(void *optctx, OptionGroup *g)
413 {
414  int i, ret;
415 
416  av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
417  g->group_def->name, g->arg);
418 
419  for (i = 0; i < g->nb_opts; i++) {
420  Option *o = &g->opts[i];
421 
422  if (g->group_def->flags &&
423  !(g->group_def->flags & o->opt->flags)) {
424  av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
425  "%s %s -- you are trying to apply an input option to an "
426  "output file or vice versa. Move this option before the "
427  "file it belongs to.\n", o->key, o->opt->help,
428  g->group_def->name, g->arg);
429  return AVERROR(EINVAL);
430  }
431 
432  av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
433  o->key, o->opt->help, o->val);
434 
435  ret = write_option(optctx, o->opt, o->key, o->val);
436  if (ret < 0)
437  return ret;
438  }
439 
440  av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
441 
442  return 0;
443 }
444 
445 int locate_option(int argc, char **argv, const OptionDef *options,
446  const char *optname)
447 {
448  const OptionDef *po;
449  int i;
450 
451  for (i = 1; i < argc; i++) {
452  const char *cur_opt = argv[i];
453 
454  if (*cur_opt++ != '-')
455  continue;
456 
457  po = find_option(options, cur_opt);
458  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
459  po = find_option(options, cur_opt + 2);
460 
461  if ((!po->name && !strcmp(cur_opt, optname)) ||
462  (po->name && !strcmp(optname, po->name)))
463  return i;
464 
465  if (!po->name || po->flags & HAS_ARG)
466  i++;
467  }
468  return 0;
469 }
470 
471 static void dump_argument(const char *a)
472 {
473  const unsigned char *p;
474 
475  for (p = a; *p; p++)
476  if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
477  *p == '_' || (*p >= 'a' && *p <= 'z')))
478  break;
479  if (!*p) {
480  fputs(a, report_file);
481  return;
482  }
483  fputc('"', report_file);
484  for (p = a; *p; p++) {
485  if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
486  fprintf(report_file, "\\%c", *p);
487  else if (*p < ' ' || *p > '~')
488  fprintf(report_file, "\\x%02x", *p);
489  else
490  fputc(*p, report_file);
491  }
492  fputc('"', report_file);
493 }
494 
495 static void check_options(const OptionDef *po)
496 {
497  while (po->name) {
498  if (po->flags & OPT_PERFILE)
500  po++;
501  }
502 }
503 
504 void parse_loglevel(int argc, char **argv, const OptionDef *options)
505 {
506  int idx = locate_option(argc, argv, options, "loglevel");
507  const char *env;
508 
509  check_options(options);
510 
511  if (!idx)
512  idx = locate_option(argc, argv, options, "v");
513  if (idx && argv[idx + 1])
514  opt_loglevel(NULL, "loglevel", argv[idx + 1]);
515  idx = locate_option(argc, argv, options, "report");
516  if ((env = getenv("FFREPORT")) || idx) {
517  init_report(env);
518  if (report_file) {
519  int i;
520  fprintf(report_file, "Command line:\n");
521  for (i = 0; i < argc; i++) {
522  dump_argument(argv[i]);
523  fputc(i < argc - 1 ? ' ' : '\n', report_file);
524  }
525  fflush(report_file);
526  }
527  }
528  idx = locate_option(argc, argv, options, "hide_banner");
529  if (idx)
530  hide_banner = 1;
531 }
532 
533 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
534  int opt_flags, int search_flags)
535 {
536  const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
537  if(o && !o->flags)
538  return NULL;
539  return o;
540 }
541 
542 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
543 int opt_default(void *optctx, const char *opt, const char *arg)
544 {
545  const AVOption *o;
546  int consumed = 0;
547  char opt_stripped[128];
548  const char *p;
549  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
550 #if CONFIG_AVRESAMPLE
551  const AVClass *rc = avresample_get_class();
552 #endif
553 #if CONFIG_SWSCALE
554  const AVClass *sc = sws_get_class();
555 #endif
556 #if CONFIG_SWRESAMPLE
557  const AVClass *swr_class = swr_get_class();
558 #endif
559 
560  if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
562 
563  if (!(p = strchr(opt, ':')))
564  p = opt + strlen(opt);
565  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
566 
567  if ((o = opt_find(&cc, opt_stripped, NULL, 0,
569  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
570  (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
571  av_dict_set(&codec_opts, opt, arg, FLAGS);
572  consumed = 1;
573  }
574  if ((o = opt_find(&fc, opt, NULL, 0,
576  av_dict_set(&format_opts, opt, arg, FLAGS);
577  if (consumed)
578  av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
579  consumed = 1;
580  }
581 #if CONFIG_SWSCALE
582  if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
584  struct SwsContext *sws = sws_alloc_context();
585  int ret = av_opt_set(sws, opt, arg, 0);
586  sws_freeContext(sws);
587  if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
588  !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
589  !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
590  av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
591  return AVERROR(EINVAL);
592  }
593  if (ret < 0) {
594  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
595  return ret;
596  }
597 
598  av_dict_set(&sws_dict, opt, arg, FLAGS);
599 
600  consumed = 1;
601  }
602 #else
603  if (!consumed && !strcmp(opt, "sws_flags")) {
604  av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
605  consumed = 1;
606  }
607 #endif
608 #if CONFIG_SWRESAMPLE
609  if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
611  struct SwrContext *swr = swr_alloc();
612  int ret = av_opt_set(swr, opt, arg, 0);
613  swr_free(&swr);
614  if (ret < 0) {
615  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
616  return ret;
617  }
618  av_dict_set(&swr_opts, opt, arg, FLAGS);
619  consumed = 1;
620  }
621 #endif
622 #if CONFIG_AVRESAMPLE
623  if ((o=opt_find(&rc, opt, NULL, 0,
625  av_dict_set(&resample_opts, opt, arg, FLAGS);
626  consumed = 1;
627  }
628 #endif
629 
630  if (consumed)
631  return 0;
633 }
634 
635 /*
636  * Check whether given option is a group separator.
637  *
638  * @return index of the group definition that matched or -1 if none
639  */
640 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
641  const char *opt)
642 {
643  int i;
644 
645  for (i = 0; i < nb_groups; i++) {
646  const OptionGroupDef *p = &groups[i];
647  if (p->sep && !strcmp(p->sep, opt))
648  return i;
649  }
650 
651  return -1;
652 }
653 
654 /*
655  * Finish parsing an option group.
656  *
657  * @param group_idx which group definition should this group belong to
658  * @param arg argument of the group delimiting option
659  */
660 static void finish_group(OptionParseContext *octx, int group_idx,
661  const char *arg)
662 {
663  OptionGroupList *l = &octx->groups[group_idx];
664  OptionGroup *g;
665 
666  GROW_ARRAY(l->groups, l->nb_groups);
667  g = &l->groups[l->nb_groups - 1];
668 
669  *g = octx->cur_group;
670  g->arg = arg;
671  g->group_def = l->group_def;
672  g->sws_dict = sws_dict;
673  g->swr_opts = swr_opts;
674  g->codec_opts = codec_opts;
677 
678  codec_opts = NULL;
679  format_opts = NULL;
680  resample_opts = NULL;
681  sws_dict = NULL;
682  swr_opts = NULL;
683  init_opts();
684 
685  memset(&octx->cur_group, 0, sizeof(octx->cur_group));
686 }
687 
688 /*
689  * Add an option instance to currently parsed group.
690  */
691 static void add_opt(OptionParseContext *octx, const OptionDef *opt,
692  const char *key, const char *val)
693 {
694  int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
695  OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
696 
697  GROW_ARRAY(g->opts, g->nb_opts);
698  g->opts[g->nb_opts - 1].opt = opt;
699  g->opts[g->nb_opts - 1].key = key;
700  g->opts[g->nb_opts - 1].val = val;
701 }
702 
704  const OptionGroupDef *groups, int nb_groups)
705 {
706  static const OptionGroupDef global_group = { "global" };
707  int i;
708 
709  memset(octx, 0, sizeof(*octx));
710 
711  octx->nb_groups = nb_groups;
712  octx->groups = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
713  if (!octx->groups)
714  exit_program(1);
715 
716  for (i = 0; i < octx->nb_groups; i++)
717  octx->groups[i].group_def = &groups[i];
718 
719  octx->global_opts.group_def = &global_group;
720  octx->global_opts.arg = "";
721 
722  init_opts();
723 }
724 
726 {
727  int i, j;
728 
729  for (i = 0; i < octx->nb_groups; i++) {
730  OptionGroupList *l = &octx->groups[i];
731 
732  for (j = 0; j < l->nb_groups; j++) {
733  av_freep(&l->groups[j].opts);
737 
738  av_dict_free(&l->groups[j].sws_dict);
739  av_dict_free(&l->groups[j].swr_opts);
740  }
741  av_freep(&l->groups);
742  }
743  av_freep(&octx->groups);
744 
745  av_freep(&octx->cur_group.opts);
746  av_freep(&octx->global_opts.opts);
747 
748  uninit_opts();
749 }
750 
751 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
752  const OptionDef *options,
753  const OptionGroupDef *groups, int nb_groups)
754 {
755  int optindex = 1;
756  int dashdash = -2;
757 
758  /* perform system-dependent conversions for arguments list */
759  prepare_app_arguments(&argc, &argv);
760 
761  init_parse_context(octx, groups, nb_groups);
762  av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
763 
764  while (optindex < argc) {
765  const char *opt = argv[optindex++], *arg;
766  const OptionDef *po;
767  int ret;
768 
769  av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
770 
771  if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
772  dashdash = optindex;
773  continue;
774  }
775  /* unnamed group separators, e.g. output filename */
776  if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
777  finish_group(octx, 0, opt);
778  av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
779  continue;
780  }
781  opt++;
782 
783 #define GET_ARG(arg) \
784 do { \
785  arg = argv[optindex++]; \
786  if (!arg) { \
787  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
788  return AVERROR(EINVAL); \
789  } \
790 } while (0)
791 
792  /* named group separators, e.g. -i */
793  if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
794  GET_ARG(arg);
795  finish_group(octx, ret, arg);
796  av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
797  groups[ret].name, arg);
798  continue;
799  }
800 
801  /* normal options */
802  po = find_option(options, opt);
803  if (po->name) {
804  if (po->flags & OPT_EXIT) {
805  /* optional argument, e.g. -h */
806  arg = argv[optindex++];
807  } else if (po->flags & HAS_ARG) {
808  GET_ARG(arg);
809  } else {
810  arg = "1";
811  }
812 
813  add_opt(octx, po, opt, arg);
814  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
815  "argument '%s'.\n", po->name, po->help, arg);
816  continue;
817  }
818 
819  /* AVOptions */
820  if (argv[optindex]) {
821  ret = opt_default(NULL, opt, argv[optindex]);
822  if (ret >= 0) {
823  av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
824  "argument '%s'.\n", opt, argv[optindex]);
825  optindex++;
826  continue;
827  } else if (ret != AVERROR_OPTION_NOT_FOUND) {
828  av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
829  "with argument '%s'.\n", opt, argv[optindex]);
830  return ret;
831  }
832  }
833 
834  /* boolean -nofoo options */
835  if (opt[0] == 'n' && opt[1] == 'o' &&
836  (po = find_option(options, opt + 2)) &&
837  po->name && po->flags & OPT_BOOL) {
838  add_opt(octx, po, opt, "0");
839  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
840  "argument 0.\n", po->name, po->help);
841  continue;
842  }
843 
844  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
846  }
847 
848  if (octx->cur_group.nb_opts || codec_opts || format_opts || resample_opts)
849  av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
850  "command: may be ignored.\n");
851 
852  av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
853 
854  return 0;
855 }
856 
857 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
858 {
859  int ret;
860  unsigned flags = av_get_cpu_flags();
861 
862  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
863  return ret;
864 
865  av_force_cpu_flags(flags);
866  return 0;
867 }
868 
869 int opt_loglevel(void *optctx, const char *opt, const char *arg)
870 {
871  const struct { const char *name; int level; } log_levels[] = {
872  { "quiet" , AV_LOG_QUIET },
873  { "panic" , AV_LOG_PANIC },
874  { "fatal" , AV_LOG_FATAL },
875  { "error" , AV_LOG_ERROR },
876  { "warning", AV_LOG_WARNING },
877  { "info" , AV_LOG_INFO },
878  { "verbose", AV_LOG_VERBOSE },
879  { "debug" , AV_LOG_DEBUG },
880  { "trace" , AV_LOG_TRACE },
881  };
882  const char *token;
883  char *tail;
884  int flags = av_log_get_flags();
885  int level = av_log_get_level();
886  int cmd, i = 0;
887 
888  av_assert0(arg);
889  while (*arg) {
890  token = arg;
891  if (*token == '+' || *token == '-') {
892  cmd = *token++;
893  } else {
894  cmd = 0;
895  }
896  if (!i && !cmd) {
897  flags = 0; /* missing relative prefix, build absolute value */
898  }
899  if (!strncmp(token, "repeat", 6)) {
900  if (cmd == '-') {
901  flags |= AV_LOG_SKIP_REPEATED;
902  } else {
903  flags &= ~AV_LOG_SKIP_REPEATED;
904  }
905  arg = token + 6;
906  } else if (!strncmp(token, "level", 5)) {
907  if (cmd == '-') {
908  flags &= ~AV_LOG_PRINT_LEVEL;
909  } else {
910  flags |= AV_LOG_PRINT_LEVEL;
911  }
912  arg = token + 5;
913  } else {
914  break;
915  }
916  i++;
917  }
918  if (!*arg) {
919  goto end;
920  } else if (*arg == '+') {
921  arg++;
922  } else if (!i) {
923  flags = av_log_get_flags(); /* level value without prefix, reset flags */
924  }
925 
926  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
927  if (!strcmp(log_levels[i].name, arg)) {
928  level = log_levels[i].level;
929  goto end;
930  }
931  }
932 
933  level = strtol(arg, &tail, 10);
934  if (*tail) {
935  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
936  "Possible levels are numbers or:\n", arg);
937  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
938  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
939  exit_program(1);
940  }
941 
942 end:
943  av_log_set_flags(flags);
944  av_log_set_level(level);
945  return 0;
946 }
947 
948 static void expand_filename_template(AVBPrint *bp, const char *template,
949  struct tm *tm)
950 {
951  int c;
952 
953  while ((c = *(template++))) {
954  if (c == '%') {
955  if (!(c = *(template++)))
956  break;
957  switch (c) {
958  case 'p':
959  av_bprintf(bp, "%s", program_name);
960  break;
961  case 't':
962  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
963  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
964  tm->tm_hour, tm->tm_min, tm->tm_sec);
965  break;
966  case '%':
967  av_bprint_chars(bp, c, 1);
968  break;
969  }
970  } else {
971  av_bprint_chars(bp, c, 1);
972  }
973  }
974 }
975 
976 static int init_report(const char *env)
977 {
978  char *filename_template = NULL;
979  char *key, *val;
980  int ret, count = 0;
981  int prog_loglevel, envlevel = 0;
982  time_t now;
983  struct tm *tm;
984  AVBPrint filename;
985 
986  if (report_file) /* already opened */
987  return 0;
988  time(&now);
989  tm = localtime(&now);
990 
991  while (env && *env) {
992  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
993  if (count)
995  "Failed to parse FFREPORT environment variable: %s\n",
996  av_err2str(ret));
997  break;
998  }
999  if (*env)
1000  env++;
1001  count++;
1002  if (!strcmp(key, "file")) {
1003  av_free(filename_template);
1004  filename_template = val;
1005  val = NULL;
1006  } else if (!strcmp(key, "level")) {
1007  char *tail;
1008  report_file_level = strtol(val, &tail, 10);
1009  if (*tail) {
1010  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1011  exit_program(1);
1012  }
1013  envlevel = 1;
1014  } else {
1015  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1016  }
1017  av_free(val);
1018  av_free(key);
1019  }
1020 
1022  expand_filename_template(&filename,
1023  av_x_if_null(filename_template, "%p-%t.log"), tm);
1024  av_free(filename_template);
1025  if (!av_bprint_is_complete(&filename)) {
1026  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1027  return AVERROR(ENOMEM);
1028  }
1029 
1030  prog_loglevel = av_log_get_level();
1031  if (!envlevel)
1032  report_file_level = FFMAX(report_file_level, prog_loglevel);
1033 
1034  report_file = fopen(filename.str, "w");
1035  if (!report_file) {
1036  int ret = AVERROR(errno);
1037  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1038  filename.str, strerror(errno));
1039  return ret;
1040  }
1043  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1044  "Report written to \"%s\"\n"
1045  "Log level: %d\n",
1046  program_name,
1047  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1048  tm->tm_hour, tm->tm_min, tm->tm_sec,
1049  filename.str, report_file_level);
1050  av_bprint_finalize(&filename, NULL);
1051  return 0;
1052 }
1053 
1054 int opt_report(void *optctx, const char *opt, const char *arg)
1055 {
1056  return init_report(NULL);
1057 }
1058 
1059 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1060 {
1061  char *tail;
1062  size_t max;
1063 
1064  max = strtol(arg, &tail, 10);
1065  if (*tail) {
1066  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1067  exit_program(1);
1068  }
1069  av_max_alloc(max);
1070  return 0;
1071 }
1072 
1073 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1074 {
1075 #if HAVE_SETRLIMIT
1076  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1077  struct rlimit rl = { lim, lim + 1 };
1078  if (setrlimit(RLIMIT_CPU, &rl))
1079  perror("setrlimit");
1080 #else
1081  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1082 #endif
1083  return 0;
1084 }
1085 
1086 void print_error(const char *filename, int err)
1087 {
1088  char errbuf[128];
1089  const char *errbuf_ptr = errbuf;
1090 
1091  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
1092  errbuf_ptr = strerror(AVUNERROR(err));
1093  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
1094 }
1095 
1096 static int warned_cfg = 0;
1097 
1098 #define INDENT 1
1099 #define SHOW_VERSION 2
1100 #define SHOW_CONFIG 4
1101 #define SHOW_COPYRIGHT 8
1102 
1103 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
1104  if (CONFIG_##LIBNAME) { \
1105  const char *indent = flags & INDENT? " " : ""; \
1106  if (flags & SHOW_VERSION) { \
1107  unsigned int version = libname##_version(); \
1108  av_log(NULL, level, \
1109  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
1110  indent, #libname, \
1111  LIB##LIBNAME##_VERSION_MAJOR, \
1112  LIB##LIBNAME##_VERSION_MINOR, \
1113  LIB##LIBNAME##_VERSION_MICRO, \
1114  AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
1115  AV_VERSION_MICRO(version)); \
1116  } \
1117  if (flags & SHOW_CONFIG) { \
1118  const char *cfg = libname##_configuration(); \
1119  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
1120  if (!warned_cfg) { \
1121  av_log(NULL, level, \
1122  "%sWARNING: library configuration mismatch\n", \
1123  indent); \
1124  warned_cfg = 1; \
1125  } \
1126  av_log(NULL, level, "%s%-11s configuration: %s\n", \
1127  indent, #libname, cfg); \
1128  } \
1129  } \
1130  } \
1131 
1132 static void print_all_libs_info(int flags, int level)
1133 {
1134  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
1135  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
1136  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
1137  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
1138  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
1139  PRINT_LIB_INFO(avresample, AVRESAMPLE, 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  strncpy(conflist, "~--", 3);
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  strncpy(remove_tilde, "pkg-config ", 11);
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(" %s%s %-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: ");
1399  printf("horizband ");
1400  if (c->capabilities & AV_CODEC_CAP_DR1)
1401  printf("dr1 ");
1403  printf("trunc ");
1405  printf("delay ");
1407  printf("small ");
1409  printf("subframes ");
1411  printf("exp ");
1413  printf("chconf ");
1415  printf("paramchange ");
1417  printf("variable ");
1421  printf("threads ");
1423  printf("avoidprobe ");
1425  printf("hardware ");
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: ");
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_AUTO_THREADS : printf("auto"); 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++) {
1451  const AVCodecHWConfig *config = avcodec_get_hw_config(c, 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) {
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  if (i) {
1707  *(descr_cur++) = '-';
1708  *(descr_cur++) = '>';
1709  }
1710  pad = i ? filter->outputs : filter->inputs;
1711  for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
1712  if (descr_cur >= descr + sizeof(descr) - 4)
1713  break;
1714  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
1715  }
1716  if (!j)
1717  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1718  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1719  }
1720  *descr_cur = 0;
1721  printf(" %c%c%c %-17s %-10s %s\n",
1722  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1723  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
1724  filter->process_command ? 'C' : '.',
1725  filter->name, descr, filter->description);
1726  }
1727 #else
1728  printf("No filters available: libavfilter disabled\n");
1729 #endif
1730  return 0;
1731 }
1732 
1733 int show_colors(void *optctx, const char *opt, const char *arg)
1734 {
1735  const char *name;
1736  const uint8_t *rgb;
1737  int i;
1738 
1739  printf("%-32s #RRGGBB\n", "name");
1740 
1741  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1742  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1743 
1744  return 0;
1745 }
1746 
1747 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1748 {
1749  const AVPixFmtDescriptor *pix_desc = NULL;
1750 
1751  printf("Pixel formats:\n"
1752  "I.... = Supported Input format for conversion\n"
1753  ".O... = Supported Output format for conversion\n"
1754  "..H.. = Hardware accelerated format\n"
1755  "...P. = Paletted format\n"
1756  "....B = Bitstream format\n"
1757  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1758  "-----\n");
1759 
1760 #if !CONFIG_SWSCALE
1761 # define sws_isSupportedInput(x) 0
1762 # define sws_isSupportedOutput(x) 0
1763 #endif
1764 
1765  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1767  printf("%c%c%c%c%c %-16s %d %2d\n",
1768  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
1769  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
1770  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
1771  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
1772  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1773  pix_desc->name,
1774  pix_desc->nb_components,
1775  av_get_bits_per_pixel(pix_desc));
1776  }
1777  return 0;
1778 }
1779 
1780 int show_layouts(void *optctx, const char *opt, const char *arg)
1781 {
1782  int i = 0;
1783  uint64_t layout, j;
1784  const char *name, *descr;
1785 
1786  printf("Individual channels:\n"
1787  "NAME DESCRIPTION\n");
1788  for (i = 0; i < 63; i++) {
1789  name = av_get_channel_name((uint64_t)1 << i);
1790  if (!name)
1791  continue;
1792  descr = av_get_channel_description((uint64_t)1 << i);
1793  printf("%-14s %s\n", name, descr);
1794  }
1795  printf("\nStandard channel layouts:\n"
1796  "NAME DECOMPOSITION\n");
1797  for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1798  if (name) {
1799  printf("%-14s ", name);
1800  for (j = 1; j; j <<= 1)
1801  if ((layout & j))
1802  printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1803  printf("\n");
1804  }
1805  }
1806  return 0;
1807 }
1808 
1809 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1810 {
1811  int i;
1812  char fmt_str[128];
1813  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1814  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1815  return 0;
1816 }
1817 
1818 static void show_help_codec(const char *name, int encoder)
1819 {
1820  const AVCodecDescriptor *desc;
1821  const AVCodec *codec;
1822 
1823  if (!name) {
1824  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1825  return;
1826  }
1827 
1828  codec = encoder ? avcodec_find_encoder_by_name(name) :
1830 
1831  if (codec)
1832  print_codec(codec);
1833  else if ((desc = avcodec_descriptor_get_by_name(name))) {
1834  void *iter = NULL;
1835  int printed = 0;
1836 
1837  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
1838  printed = 1;
1839  print_codec(codec);
1840  }
1841 
1842  if (!printed) {
1843  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1844  "but no %s for it are available. FFmpeg might need to be "
1845  "recompiled with additional external libraries.\n",
1846  name, encoder ? "encoders" : "decoders");
1847  }
1848  } else {
1849  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1850  name);
1851  }
1852 }
1853 
1854 static void show_help_demuxer(const char *name)
1855 {
1856  const AVInputFormat *fmt = av_find_input_format(name);
1857 
1858  if (!fmt) {
1859  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1860  return;
1861  }
1862 
1863  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1864 
1865  if (fmt->extensions)
1866  printf(" Common extensions: %s.\n", fmt->extensions);
1867 
1868  if (fmt->priv_class)
1870 }
1871 
1872 static void show_help_protocol(const char *name)
1873 {
1874  const AVClass *proto_class;
1875 
1876  if (!name) {
1877  av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
1878  return;
1879  }
1880 
1881  proto_class = avio_protocol_get_class(name);
1882  if (!proto_class) {
1883  av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
1884  return;
1885  }
1886 
1888 }
1889 
1890 static void show_help_muxer(const char *name)
1891 {
1892  const AVCodecDescriptor *desc;
1893  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1894 
1895  if (!fmt) {
1896  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1897  return;
1898  }
1899 
1900  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1901 
1902  if (fmt->extensions)
1903  printf(" Common extensions: %s.\n", fmt->extensions);
1904  if (fmt->mime_type)
1905  printf(" Mime type: %s.\n", fmt->mime_type);
1906  if (fmt->video_codec != AV_CODEC_ID_NONE &&
1907  (desc = avcodec_descriptor_get(fmt->video_codec))) {
1908  printf(" Default video codec: %s.\n", desc->name);
1909  }
1910  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1911  (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1912  printf(" Default audio codec: %s.\n", desc->name);
1913  }
1914  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1915  (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1916  printf(" Default subtitle codec: %s.\n", desc->name);
1917  }
1918 
1919  if (fmt->priv_class)
1921 }
1922 
1923 #if CONFIG_AVFILTER
1924 static void show_help_filter(const char *name)
1925 {
1926 #if CONFIG_AVFILTER
1927  const AVFilter *f = avfilter_get_by_name(name);
1928  int i, count;
1929 
1930  if (!name) {
1931  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1932  return;
1933  } else if (!f) {
1934  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1935  return;
1936  }
1937 
1938  printf("Filter %s\n", f->name);
1939  if (f->description)
1940  printf(" %s\n", f->description);
1941 
1943  printf(" slice threading supported\n");
1944 
1945  printf(" Inputs:\n");
1946  count = avfilter_pad_count(f->inputs);
1947  for (i = 0; i < count; i++) {
1948  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1950  }
1952  printf(" dynamic (depending on the options)\n");
1953  else if (!count)
1954  printf(" none (source filter)\n");
1955 
1956  printf(" Outputs:\n");
1957  count = avfilter_pad_count(f->outputs);
1958  for (i = 0; i < count; i++) {
1959  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1961  }
1963  printf(" dynamic (depending on the options)\n");
1964  else if (!count)
1965  printf(" none (sink filter)\n");
1966 
1967  if (f->priv_class)
1971  printf("This filter has support for timeline through the 'enable' option.\n");
1972 #else
1973  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1974  "can not to satisfy request\n");
1975 #endif
1976 }
1977 #endif
1978 
1979 static void show_help_bsf(const char *name)
1980 {
1981  const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
1982 
1983  if (!name) {
1984  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
1985  return;
1986  } else if (!bsf) {
1987  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
1988  return;
1989  }
1990 
1991  printf("Bit stream filter %s\n", bsf->name);
1992  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
1994  if (bsf->priv_class)
1996 }
1997 
1998 int show_help(void *optctx, const char *opt, const char *arg)
1999 {
2000  char *topic, *par;
2002 
2003  topic = av_strdup(arg ? arg : "");
2004  if (!topic)
2005  return AVERROR(ENOMEM);
2006  par = strchr(topic, '=');
2007  if (par)
2008  *par++ = 0;
2009 
2010  if (!*topic) {
2011  show_help_default(topic, par);
2012  } else if (!strcmp(topic, "decoder")) {
2013  show_help_codec(par, 0);
2014  } else if (!strcmp(topic, "encoder")) {
2015  show_help_codec(par, 1);
2016  } else if (!strcmp(topic, "demuxer")) {
2017  show_help_demuxer(par);
2018  } else if (!strcmp(topic, "muxer")) {
2019  show_help_muxer(par);
2020  } else if (!strcmp(topic, "protocol")) {
2021  show_help_protocol(par);
2022 #if CONFIG_AVFILTER
2023  } else if (!strcmp(topic, "filter")) {
2024  show_help_filter(par);
2025 #endif
2026  } else if (!strcmp(topic, "bsf")) {
2027  show_help_bsf(par);
2028  } else {
2029  show_help_default(topic, par);
2030  }
2031 
2032  av_freep(&topic);
2033  return 0;
2034 }
2035 
2036 int read_yesno(void)
2037 {
2038  int c = getchar();
2039  int yesno = (av_toupper(c) == 'Y');
2040 
2041  while (c != '\n' && c != EOF)
2042  c = getchar();
2043 
2044  return yesno;
2045 }
2046 
2047 FILE *get_preset_file(char *filename, size_t filename_size,
2048  const char *preset_name, int is_path,
2049  const char *codec_name)
2050 {
2051  FILE *f = NULL;
2052  int i;
2053  const char *base[3] = { getenv("FFMPEG_DATADIR"),
2054  getenv("HOME"),
2055  FFMPEG_DATADIR, };
2056 
2057  if (is_path) {
2058  av_strlcpy(filename, preset_name, filename_size);
2059  f = fopen(filename, "r");
2060  } else {
2061 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
2062  char datadir[MAX_PATH], *ls;
2063  base[2] = NULL;
2064 
2065  if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
2066  {
2067  for (ls = datadir; ls < datadir + strlen(datadir); ls++)
2068  if (*ls == '\\') *ls = '/';
2069 
2070  if (ls = strrchr(datadir, '/'))
2071  {
2072  *ls = 0;
2073  strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
2074  base[2] = datadir;
2075  }
2076  }
2077 #endif
2078  for (i = 0; i < 3 && !f; i++) {
2079  if (!base[i])
2080  continue;
2081  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
2082  i != 1 ? "" : "/.ffmpeg", preset_name);
2083  f = fopen(filename, "r");
2084  if (!f && codec_name) {
2085  snprintf(filename, filename_size,
2086  "%s%s/%s-%s.ffpreset",
2087  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
2088  preset_name);
2089  f = fopen(filename, "r");
2090  }
2091  }
2092  }
2093 
2094  return f;
2095 }
2096 
2097 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
2098 {
2099  int ret = avformat_match_stream_specifier(s, st, spec);
2100  if (ret < 0)
2101  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
2102  return ret;
2103 }
2104 
2106  AVFormatContext *s, AVStream *st, AVCodec *codec)
2107 {
2108  AVDictionary *ret = NULL;
2109  AVDictionaryEntry *t = NULL;
2112  char prefix = 0;
2113  const AVClass *cc = avcodec_get_class();
2114 
2115  if (!codec)
2116  codec = s->oformat ? avcodec_find_encoder(codec_id)
2117  : avcodec_find_decoder(codec_id);
2118 
2119  switch (st->codecpar->codec_type) {
2120  case AVMEDIA_TYPE_VIDEO:
2121  prefix = 'v';
2122  flags |= AV_OPT_FLAG_VIDEO_PARAM;
2123  break;
2124  case AVMEDIA_TYPE_AUDIO:
2125  prefix = 'a';
2126  flags |= AV_OPT_FLAG_AUDIO_PARAM;
2127  break;
2128  case AVMEDIA_TYPE_SUBTITLE:
2129  prefix = 's';
2130  flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
2131  break;
2132  }
2133 
2134  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
2135  char *p = strchr(t->key, ':');
2136 
2137  /* check stream specification in opt name */
2138  if (p)
2139  switch (check_stream_specifier(s, st, p + 1)) {
2140  case 1: *p = 0; break;
2141  case 0: continue;
2142  default: exit_program(1);
2143  }
2144 
2145  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
2146  !codec ||
2147  (codec->priv_class &&
2148  av_opt_find(&codec->priv_class, t->key, NULL, flags,
2150  av_dict_set(&ret, t->key, t->value, 0);
2151  else if (t->key[0] == prefix &&
2152  av_opt_find(&cc, t->key + 1, NULL, flags,
2154  av_dict_set(&ret, t->key + 1, t->value, 0);
2155 
2156  if (p)
2157  *p = ':';
2158  }
2159  return ret;
2160 }
2161 
2163  AVDictionary *codec_opts)
2164 {
2165  int i;
2166  AVDictionary **opts;
2167 
2168  if (!s->nb_streams)
2169  return NULL;
2170  opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
2171  if (!opts) {
2173  "Could not alloc memory for stream options.\n");
2174  return NULL;
2175  }
2176  for (i = 0; i < s->nb_streams; i++)
2177  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
2178  s, s->streams[i], NULL);
2179  return opts;
2180 }
2181 
2182 void *grow_array(void *array, int elem_size, int *size, int new_size)
2183 {
2184  if (new_size >= INT_MAX / elem_size) {
2185  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
2186  exit_program(1);
2187  }
2188  if (*size < new_size) {
2189  uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
2190  if (!tmp) {
2191  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
2192  exit_program(1);
2193  }
2194  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
2195  *size = new_size;
2196  return tmp;
2197  }
2198  return array;
2199 }
2200 
2202 {
2203  uint8_t* displaymatrix = av_stream_get_side_data(st,
2205  double theta = 0;
2206  if (displaymatrix)
2207  theta = -av_display_rotation_get((int32_t*) displaymatrix);
2208 
2209  theta -= 360*floor(theta/360 + 0.9/360);
2210 
2211  if (fabs(theta - 90*round(theta/90)) > 2)
2212  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
2213  "If you want to help, upload a sample "
2214  "of this file to https://streams.videolan.org/upload/ "
2215  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
2216 
2217  return theta;
2218 }
2219 
2220 #if CONFIG_AVDEVICE
2221 static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
2222 {
2223  int ret, i;
2224  AVDeviceInfoList *device_list = NULL;
2225 
2226  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
2227  return AVERROR(EINVAL);
2228 
2229  printf("Auto-detected sources for %s:\n", fmt->name);
2230  if (!fmt->get_device_list) {
2231  ret = AVERROR(ENOSYS);
2232  printf("Cannot list sources. Not implemented.\n");
2233  goto fail;
2234  }
2235 
2236  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
2237  printf("Cannot list sources.\n");
2238  goto fail;
2239  }
2240 
2241  for (i = 0; i < device_list->nb_devices; i++) {
2242  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2243  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2244  }
2245 
2246  fail:
2247  avdevice_free_list_devices(&device_list);
2248  return ret;
2249 }
2250 
2251 static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
2252 {
2253  int ret, i;
2254  AVDeviceInfoList *device_list = NULL;
2255 
2256  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
2257  return AVERROR(EINVAL);
2258 
2259  printf("Auto-detected sinks for %s:\n", fmt->name);
2260  if (!fmt->get_device_list) {
2261  ret = AVERROR(ENOSYS);
2262  printf("Cannot list sinks. Not implemented.\n");
2263  goto fail;
2264  }
2265 
2266  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
2267  printf("Cannot list sinks.\n");
2268  goto fail;
2269  }
2270 
2271  for (i = 0; i < device_list->nb_devices; i++) {
2272  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2273  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2274  }
2275 
2276  fail:
2277  avdevice_free_list_devices(&device_list);
2278  return ret;
2279 }
2280 
2281 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
2282 {
2283  int ret;
2284  if (arg) {
2285  char *opts_str = NULL;
2286  av_assert0(dev && opts);
2287  *dev = av_strdup(arg);
2288  if (!*dev)
2289  return AVERROR(ENOMEM);
2290  if ((opts_str = strchr(*dev, ','))) {
2291  *(opts_str++) = '\0';
2292  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
2293  av_freep(dev);
2294  return ret;
2295  }
2296  }
2297  } else
2298  printf("\nDevice name is not provided.\n"
2299  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
2300  return 0;
2301 }
2302 
2303 int show_sources(void *optctx, const char *opt, const char *arg)
2304 {
2305  AVInputFormat *fmt = NULL;
2306  char *dev = NULL;
2307  AVDictionary *opts = NULL;
2308  int ret = 0;
2309  int error_level = av_log_get_level();
2310 
2312 
2313  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2314  goto fail;
2315 
2316  do {
2317  fmt = av_input_audio_device_next(fmt);
2318  if (fmt) {
2319  if (!strcmp(fmt->name, "lavfi"))
2320  continue; //it's pointless to probe lavfi
2321  if (dev && !av_match_name(dev, fmt->name))
2322  continue;
2323  print_device_sources(fmt, opts);
2324  }
2325  } while (fmt);
2326  do {
2327  fmt = av_input_video_device_next(fmt);
2328  if (fmt) {
2329  if (dev && !av_match_name(dev, fmt->name))
2330  continue;
2331  print_device_sources(fmt, opts);
2332  }
2333  } while (fmt);
2334  fail:
2335  av_dict_free(&opts);
2336  av_free(dev);
2337  av_log_set_level(error_level);
2338  return ret;
2339 }
2340 
2341 int show_sinks(void *optctx, const char *opt, const char *arg)
2342 {
2343  AVOutputFormat *fmt = NULL;
2344  char *dev = NULL;
2345  AVDictionary *opts = NULL;
2346  int ret = 0;
2347  int error_level = av_log_get_level();
2348 
2350 
2351  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2352  goto fail;
2353 
2354  do {
2355  fmt = av_output_audio_device_next(fmt);
2356  if (fmt) {
2357  if (dev && !av_match_name(dev, fmt->name))
2358  continue;
2359  print_device_sinks(fmt, opts);
2360  }
2361  } while (fmt);
2362  do {
2363  fmt = av_output_video_device_next(fmt);
2364  if (fmt) {
2365  if (dev && !av_match_name(dev, fmt->name))
2366  continue;
2367  print_device_sinks(fmt, opts);
2368  }
2369  } while (fmt);
2370  fail:
2371  av_dict_free(&opts);
2372  av_free(dev);
2373  av_log_set_level(error_level);
2374  return ret;
2375 }
2376 
2377 #endif
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:117
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:412
#define NULL
Definition: coverity.c:32
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
AVDictionary * resample_opts
Definition: cmdutils.h:320
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: bsf.h:117
AVOutputFormat * av_output_audio_device_next(AVOutputFormat *d)
Audio output devices iterator.
Definition: avdevice.c:115
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:74
static enum AVPixelFormat pix_fmt
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
AVDictionary * swr_opts
Definition: cmdutils.h:322
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
const char * name
< group name
Definition: cmdutils.h:298
static void finish_group(OptionParseContext *octx, int group_idx, const char *arg)
Definition: cmdutils.c:660
#define FLAGS
Definition: cmdutils.c:542
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:73
static void show_help_protocol(const char *name)
Definition: cmdutils.c:1872
AVOption.
Definition: opt.h:248
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:96
int show_license(void *optctx, const char *opt, const char *arg)
Print the license of the program to stdout.
Definition: cmdutils.c:1213
#define AV_CODEC_PROP_LOSSY
Codec supports lossy compression.
Definition: codec_desc.h:78
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:282
double get_rotation(AVStream *st)
Definition: cmdutils.c:2201
char * device_description
human friendly name
Definition: avdevice.h:454
const char * desc
Definition: libsvtav1.c:79
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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
Main libavfilter public API header.
const char * g
Definition: vf_curves.c:115
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
void av_log_set_level(int level)
Set the log level.
Definition: log.c:440
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:751
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:2525
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:150
int opt_loglevel(void *optctx, const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: cmdutils.c:869
enum AVCodecID video_codec
default video codec
Definition: avformat.h:511
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2097
#define INDENT
Definition: cmdutils.c:1098
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:106
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1050
char * device_name
device name, format depends on device
Definition: avdevice.h:453
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:101
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:276
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1185
static int is_device(const AVClass *avclass)
Definition: cmdutils.c:1287
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:36
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
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
const char * arg
Definition: cmdutils.h:313
const char * sep
Option to be used as group separator.
Definition: cmdutils.h:303
#define GET_CH_LAYOUT_DESC(ch_layout)
Definition: cmdutils.h:642
GLint GLenum type
Definition: opengl_enc.c:104
static const AVOption * opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Definition: cmdutils.c:533
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:98
enum AVMediaType type
Definition: codec.h:203
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
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
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
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
static void error(const char *err)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: codec.h:118
#define OPT_DOUBLE
Definition: cmdutils.h:180
static void check_options(const OptionDef *po)
Definition: cmdutils.c:495
#define OPT_FLOAT
Definition: cmdutils.h:168
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:844
AVCodec.
Definition: codec.h:190
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:1747
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2105
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
Macro definitions for various function/variable attributes.
static struct codec_string codecs[]
uint8_t base
Definition: vp3data.h:202
static void(* program_exit)(int ret)
Definition: cmdutils.c:126
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:725
int av_get_standard_channel_layout(unsigned index, uint64_t *layout, const char **name)
Get the value and name of a standard channel layout.
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:959
int(* get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: avformat.h:599
Format I/O context.
Definition: avformat.h:1351
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:310
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
Definition: cmdutils.c:1294
#define AV_LOG_QUIET
Print no output.
Definition: log.h:176
#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:75
static int warned_cfg
Definition: cmdutils.c:1096
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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
Public dictionary API.
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
static void dump_argument(const char *a)
Definition: cmdutils.c:471
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:128
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:96
uint8_t
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:149
Opaque data information usually continuous.
Definition: avutil.h:203
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:543
#define OPT_OUTPUT
Definition: cmdutils.h:182
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:250
AVOptions.
#define HAS_ARG
Definition: cmdutils.h:161
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:181
#define va_copy(dst, src)
Definition: va_copy.h:31
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3278
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: cmdutils.c:1518
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
#define f(width, name)
Definition: cbs_vp9.c:255
#define AV_CODEC_PROP_LOSSLESS
Codec supports lossless compression.
Definition: codec_desc.h:82
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1059
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
#define media_type_string
Definition: cmdutils.h:620
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
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
int nb_opts
Definition: cmdutils.h:316
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:5250
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define OPT_OFFSET
Definition: cmdutils.h:175
static void init_parse_context(OptionParseContext *octx, const OptionGroupDef *groups, int nb_groups)
Definition: cmdutils.c:703
#define AV_IS_INPUT_DEVICE(category)
Definition: log.h:50
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
int show_buildconf(void *optctx, const char *opt, const char *arg)
Print the build configuration of the program to stdout.
Definition: cmdutils.c:1205
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5429
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:82
int hide_banner
Definition: cmdutils.c:74
int(* get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: avformat.h:775
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:188
AVOutputFormat * av_output_video_device_next(AVOutputFormat *d)
Video output devices iterator.
Definition: avdevice.c:121
const char * name
Definition: bsf.h:99
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:675
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
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:381
#define OPT_SPEC
Definition: cmdutils.h:176
static void print_all_libs_info(int flags, int level)
Definition: cmdutils.c:1132
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
static const AVCodec * next_codec_for_id(enum AVCodecID id, void **iter, int encoder)
Definition: cmdutils.c:1497
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:234
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the &#39;-loglevel&#39; option in the command line args and apply it.
Definition: cmdutils.c:504
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:112
#define max(a, b)
Definition: cuda_runtime.h:33
external API header
ptrdiff_t size
Definition: opengl_enc.c:100
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:174
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
static void print_codecs(int encoder)
Definition: cmdutils.c:1608
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:445
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
const char * name
Definition: pixdesc.h:82
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2162
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:529
AVDictionary * format_opts
Definition: cmdutils.c:70
int show_help(void *optctx, const char *opt, const char *arg)
Generic -h handler common to all fftools.
Definition: cmdutils.c:1998
A filter pad used for either input or output.
Definition: internal.h:54
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
Main libavdevice API header.
int flags
Option flags that must be set on each option that is applied to this group.
Definition: cmdutils.h:308
libswresample public header
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:550
enum AVCodecID id
Definition: codec.h:204
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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
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
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:294
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:506
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: protocols.c:112
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:1809
#define sws_isSupportedOutput(x)
The libswresample context.
Display matrix.
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
int capabilities
Codec capabilities.
Definition: codec.h:209
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
const char * arg
Definition: jacosubdec.c:66
#define SHOW_COPYRIGHT
Definition: cmdutils.c:1101
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
const char * name
Definition: cmdutils.h:159
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:926
static void show_help_muxer(const char *name)
Definition: cmdutils.c:1890
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:348
Definition: graph2dot.c:48
#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:384
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
simple assert() macros that are a bit more flexible than ISO C assert().
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name)
Definition: cmdutils.c:1377
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:352
static av_always_inline av_const double round(double x)
Definition: libm.h:444
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:133
Libavutil version macros.
int flags
Definition: cmdutils.h:160
const char * long_name
A more descriptive name for this codec.
Definition: codec_desc.h:50
const char * val
Definition: cmdutils.h:293
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
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
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
#define fail()
Definition: checkasm.h:123
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
void av_log_default_callback(void *ptr, int level, const char *fmt, va_list vl)
Default logging callback.
Definition: log.c:346
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:196
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:122
AVDictionary * sws_dict
Definition: cmdutils.c:68
static const OptionDef * find_option(const OptionDef *po, const char *name)
Definition: cmdutils.c:216
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
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:521
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:110
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1660
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:92
#define AV_IS_OUTPUT_DEVICE(category)
Definition: log.h:55
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
int avdevice_list_input_sources(AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:228
AVDictionary * opts
Definition: movenc.c:50
OptionGroup * groups
Definition: cmdutils.h:332
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2592
int opt_report(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1054
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
size_t off
Definition: cmdutils.h:186
#define b
Definition: input.c:41
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:1733
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:954
int flags
miscellaneous flags such as SWR_FLAG_RESAMPLE
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
Definition: cmdutils.c:101
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:80
external API header
#define FFMIN(a, b)
Definition: common.h:96
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:455
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
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
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: cmdutils.c:1539
static int init_report(const char *env)
Definition: cmdutils.c:976
const char * name
Definition: avformat.h:500
#define GET_PIX_FMT_NAME(pix_fmt)
Definition: cmdutils.h:625
int32_t
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
int avdevice_list_output_sinks(AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:239
const OptionGroupDef * group_def
Definition: cmdutils.h:330
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:329
#define OPT_EXIT
Definition: cmdutils.h:171
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2332
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:3194
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:292
AVDictionary * resample_opts
Definition: cmdutils.c:70
#define OPT_INT64
Definition: cmdutils.h:170
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
#define sws_isSupportedInput(x)
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
Opaque data information usually sparse.
Definition: avutil.h:205
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:144
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:1073
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:528
void * dst_ptr
Definition: cmdutils.h:184
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:546
#define GET_SAMPLE_FMT_NAME(sample_fmt)
Definition: cmdutils.h:631
#define FF_ARRAY_ELEMS(a)
int flags
Definition: opt.h:277
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:133
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1370
const AVFilterPad * inputs
List of inputs, terminated by a zeroed element.
Definition: avfilter.h:165
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:657
attribute_deprecated const AVClass * avresample_get_class(void)
Definition: options.c:110
Stream structure.
Definition: avformat.h:876
static char get_media_type_char(enum AVMediaType type)
Definition: cmdutils.c:1485
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
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
#define GET_SAMPLE_RATE_NAME(rate)
Definition: cmdutils.h:634
external API header
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:202
const AVClass * priv_class
A class for the private data, used to declare filter private AVOptions.
Definition: avfilter.h:183
const AVCodecDescriptor * avcodec_descriptor_next(const AVCodecDescriptor *prev)
Iterate over all codec descriptors known to libavcodec.
Definition: codec_desc.c:3435
int(* func_arg)(void *, const char *, const char *)
Definition: cmdutils.h:185
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
AVInputFormat * av_input_video_device_next(AVInputFormat *d)
Video input devices iterator.
Definition: avdevice.c:109
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
const AVRational * supported_framerates
array of supported framerates, or NULL if any, array is terminated by {0,0}
Definition: codec.h:210
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int(* process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.h:307
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1345
const char * help
Definition: cmdutils.h:188
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:281
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1821
show_muxdemuxers
Definition: cmdutils.c:76
int av_log_get_flags(void)
Definition: log.c:450
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
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
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:157
Replacements for frequently missing libm functions.
#define SHOW_VERSION
Definition: cmdutils.c:1099
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:2047
const OptionGroupDef * group_def
Definition: cmdutils.h:312
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)
Definition: cmdutils.c:1103
Describe the class of an AVClass context structure.
Definition: log.h:67
AVInputFormat * av_input_audio_device_next(AVInputFormat *d)
Audio input devices iterator.
Definition: avdevice.c:103
Filter definition.
Definition: avfilter.h:145
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:92
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: codec.h:93
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:512
ff_const59 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
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FF_ENABLE_DEPRECATION_WARNINGS const AVClass * av_opt_child_class_iterate(const AVClass *parent, void **iter)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:1730
static void expand_filename_template(AVBPrint *bp, const char *template, struct tm *tm)
Definition: cmdutils.c:948
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:510
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds...
Definition: cmdutils.c:162
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:2182
const char * argname
Definition: cmdutils.h:189
#define OPT_STRING
Definition: cmdutils.h:164
AVMediaType
Definition: avutil.h:199
const char * name
Filter name.
Definition: avfilter.h:149
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
#define snprintf
Definition: snprintf.h:34
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:1045
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:95
const AVBitStreamFilter * av_bsf_iterate(void **opaque)
Iterate over all registered bitstream filters.
static void print_codec(const AVCodec *c)
Definition: cmdutils.c:1390
misc parsing utilities
int default_device
index of default device or -1 if no default
Definition: avdevice.h:463
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:136
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1088
List of devices.
Definition: avdevice.h:460
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:931
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
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:141
#define AV_CODEC_CAP_TRUNCATED
Definition: codec.h:51
#define OPT_TIME
Definition: cmdutils.h:179
#define flags(name, subs,...)
Definition: cbs_av1.c:560
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
uint8_t level
Definition: svq3.c:205
static int match_group_separator(const OptionGroupDef *groups, int nb_groups, const char *opt)
Definition: cmdutils.c:640
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale.c:237
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
enum AVMediaType type
Definition: codec_desc.h:40
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:671
#define OPT_BOOL
Definition: cmdutils.h:162
An option extracted from the commandline.
Definition: cmdutils.h:290
static FILE * report_file
Definition: cmdutils.c:72
Main libavformat public API header.
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:1086
#define OPT_INT
Definition: cmdutils.h:167
const OptionDef options[]
Definition: ffmpeg_opt.c:3393
AVDictionary * codec_opts
Definition: cmdutils.c:70
AVDictionary * format_opts
Definition: cmdutils.h:319
#define class
Definition: math.h:25
static void show_help_bsf(const char *name)
Definition: cmdutils.c:1979
OptionGroupList * groups
Definition: cmdutils.h:339
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:114
#define AVFILTER_FLAG_SUPPORT_TIMELINE
Handy mask to test whether the filter supports or no the timeline feature (internally or generically)...
Definition: avfilter.h:139
static enum AVCodecID codec_ids[]
OptionGroup global_opts
Definition: cmdutils.h:337
static void print_buildconf(int flags, int level)
Definition: cmdutils.c:1159
#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 poi...
Definition: opt.h:569
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
const AVClass * avio_protocol_get_class(const char *name)
Get AVClass by names of available protocols.
Definition: protocols.c:127
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents...
Definition: cmdutils.c:87
const char * key
Definition: cmdutils.h:292
#define AVUNERROR(e)
Definition: error.h:44
enum AVCodecID id
Definition: codec_desc.h:39
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:622
const OptionDef * opt
Definition: cmdutils.h:291
#define av_free(p)
const char * description
A description of the filter.
Definition: avfilter.h:156
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
char * value
Definition: dict.h:87
static int report_file_level
Definition: cmdutils.c:73
#define SHOW_CONFIG
Definition: cmdutils.c:1100
int len
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:1536
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:510
printf("static const uint8_t my_array[100] = {\n")
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
Definition: cmdutils.c:287
static int write_option(void *optctx, const OptionDef *po, const char *opt, const char *arg)
Definition: cmdutils.c:293
void av_log_set_flags(int arg)
Definition: log.c:445
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:132
AVDictionary * swr_opts
Definition: cmdutils.c:69
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3429
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:203
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:1780
#define GET_ARG(arg)
OptionGroup cur_group
Definition: cmdutils.h:343
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
Definition: avfilter.c:560
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
Override the cpuflags.
Definition: cmdutils.c:857
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:836
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
AVDictionary * codec_opts
Definition: cmdutils.h:318
Option * opts
Definition: cmdutils.h:315
#define AV_LOG_PRINT_LEVEL
Include the log severity in messages originating from codecs.
Definition: log.h:392
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0...
Definition: cmdutils.c:2036
const AVFilterPad * outputs
List of outputs, terminated by a zeroed element.
Definition: avfilter.h:173
union OptionDef::@1 u
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static void show_help_demuxer(const char *name)
Definition: cmdutils.c:1854
const char * av_get_channel_description(uint64_t channel)
Get the description of a given channel.
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:188
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: codec.h:442
int show_version(void *optctx, const char *opt, const char *arg)
Print the version of the program to stdout.
Definition: cmdutils.c:1196
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:67
#define GET_CODEC_NAME(id)
Definition: cmdutils.h:628
#define OPT_PERFILE
Definition: cmdutils.h:173
AVDictionary * sws_dict
Definition: cmdutils.h:321
#define OPT_INPUT
Definition: cmdutils.h:181
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
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 local context
#define INFINITY
Definition: mathematics.h:67
const char * extensions
comma-separated filename extensions
Definition: avformat.h:508
const char * mime_type
Definition: avformat.h:507
int nb_devices
number of autodetected devices
Definition: avdevice.h:462
float min
static void print_program_info(int flags, int level)
Definition: cmdutils.c:1145
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
Definition: rpzaenc.c:58
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3444
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
int i
Definition: input.c:407
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:109
static void show_help_codec(const char *name, int encoder)
Definition: cmdutils.c:1818
#define av_unused
Definition: attributes.h:131
static int compare_codec_desc(const void *a, const void *b)
Definition: cmdutils.c:1509
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
simple arithmetic expression evaluator
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2580
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
const char * name
Definition: opengl_enc.c:102
static void add_opt(OptionParseContext *octx, const OptionDef *opt, const char *key, const char *val)
Definition: cmdutils.c:691
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140
static uint8_t tmp[11]
Definition: aes_ctr.c:26