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