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 option(s) found in the "
852  "command: may be ignored.\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  int prog_loglevel, envlevel = 0;
984  time_t now;
985  struct tm *tm;
986  AVBPrint filename;
987 
988  if (report_file) /* already opened */
989  return 0;
990  time(&now);
991  tm = localtime(&now);
992 
993  while (env && *env) {
994  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
995  if (count)
997  "Failed to parse FFREPORT environment variable: %s\n",
998  av_err2str(ret));
999  break;
1000  }
1001  if (*env)
1002  env++;
1003  count++;
1004  if (!strcmp(key, "file")) {
1005  av_free(filename_template);
1006  filename_template = val;
1007  val = NULL;
1008  } else if (!strcmp(key, "level")) {
1009  char *tail;
1010  report_file_level = strtol(val, &tail, 10);
1011  if (*tail) {
1012  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1013  exit_program(1);
1014  }
1015  envlevel = 1;
1016  } else {
1017  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1018  }
1019  av_free(val);
1020  av_free(key);
1021  }
1022 
1024  expand_filename_template(&filename,
1025  av_x_if_null(filename_template, "%p-%t.log"), tm);
1026  av_free(filename_template);
1027  if (!av_bprint_is_complete(&filename)) {
1028  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1029  return AVERROR(ENOMEM);
1030  }
1031 
1032  prog_loglevel = av_log_get_level();
1033  if (!envlevel)
1034  report_file_level = FFMAX(report_file_level, prog_loglevel);
1035 
1036  report_file = fopen(filename.str, "w");
1037  if (!report_file) {
1038  int ret = AVERROR(errno);
1039  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1040  filename.str, strerror(errno));
1041  return ret;
1042  }
1045  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1046  "Report written to \"%s\"\n"
1047  "Log level: %d\n",
1048  program_name,
1049  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1050  tm->tm_hour, tm->tm_min, tm->tm_sec,
1051  filename.str, report_file_level);
1052  av_bprint_finalize(&filename, NULL);
1053  return 0;
1054 }
1055 
1056 int opt_report(void *optctx, const char *opt, const char *arg)
1057 {
1058  return init_report(NULL);
1059 }
1060 
1061 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1062 {
1063  char *tail;
1064  size_t max;
1065 
1066  max = strtol(arg, &tail, 10);
1067  if (*tail) {
1068  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1069  exit_program(1);
1070  }
1071  av_max_alloc(max);
1072  return 0;
1073 }
1074 
1075 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1076 {
1077 #if HAVE_SETRLIMIT
1078  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1079  struct rlimit rl = { lim, lim + 1 };
1080  if (setrlimit(RLIMIT_CPU, &rl))
1081  perror("setrlimit");
1082 #else
1083  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1084 #endif
1085  return 0;
1086 }
1087 
1088 void print_error(const char *filename, int err)
1089 {
1090  char errbuf[128];
1091  const char *errbuf_ptr = errbuf;
1092 
1093  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
1094  errbuf_ptr = strerror(AVUNERROR(err));
1095  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
1096 }
1097 
1098 static int warned_cfg = 0;
1099 
1100 #define INDENT 1
1101 #define SHOW_VERSION 2
1102 #define SHOW_CONFIG 4
1103 #define SHOW_COPYRIGHT 8
1104 
1105 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
1106  if (CONFIG_##LIBNAME) { \
1107  const char *indent = flags & INDENT? " " : ""; \
1108  if (flags & SHOW_VERSION) { \
1109  unsigned int version = libname##_version(); \
1110  av_log(NULL, level, \
1111  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
1112  indent, #libname, \
1113  LIB##LIBNAME##_VERSION_MAJOR, \
1114  LIB##LIBNAME##_VERSION_MINOR, \
1115  LIB##LIBNAME##_VERSION_MICRO, \
1116  AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
1117  AV_VERSION_MICRO(version)); \
1118  } \
1119  if (flags & SHOW_CONFIG) { \
1120  const char *cfg = libname##_configuration(); \
1121  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
1122  if (!warned_cfg) { \
1123  av_log(NULL, level, \
1124  "%sWARNING: library configuration mismatch\n", \
1125  indent); \
1126  warned_cfg = 1; \
1127  } \
1128  av_log(NULL, level, "%s%-11s configuration: %s\n", \
1129  indent, #libname, cfg); \
1130  } \
1131  } \
1132  } \
1133 
1134 static void print_all_libs_info(int flags, int level)
1135 {
1136  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
1137  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
1138  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
1139  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
1140  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
1141  PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
1142  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
1143  PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
1144  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
1145 }
1146 
1147 static void print_program_info(int flags, int level)
1148 {
1149  const char *indent = flags & INDENT? " " : "";
1150 
1151  av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
1152  if (flags & SHOW_COPYRIGHT)
1153  av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
1154  program_birth_year, CONFIG_THIS_YEAR);
1155  av_log(NULL, level, "\n");
1156  av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
1157 
1158  av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
1159 }
1160 
1161 static void print_buildconf(int flags, int level)
1162 {
1163  const char *indent = flags & INDENT ? " " : "";
1164  char str[] = { FFMPEG_CONFIGURATION };
1165  char *conflist, *remove_tilde, *splitconf;
1166 
1167  // Change all the ' --' strings to '~--' so that
1168  // they can be identified as tokens.
1169  while ((conflist = strstr(str, " --")) != NULL) {
1170  strncpy(conflist, "~--", 3);
1171  }
1172 
1173  // Compensate for the weirdness this would cause
1174  // when passing 'pkg-config --static'.
1175  while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
1176  strncpy(remove_tilde, "pkg-config ", 11);
1177  }
1178 
1179  splitconf = strtok(str, "~");
1180  av_log(NULL, level, "\n%sconfiguration:\n", indent);
1181  while (splitconf != NULL) {
1182  av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
1183  splitconf = strtok(NULL, "~");
1184  }
1185 }
1186 
1187 void show_banner(int argc, char **argv, const OptionDef *options)
1188 {
1189  int idx = locate_option(argc, argv, options, "version");
1190  if (hide_banner || idx)
1191  return;
1192 
1196 }
1197 
1198 int show_version(void *optctx, const char *opt, const char *arg)
1199 {
1203 
1204  return 0;
1205 }
1206 
1207 int show_buildconf(void *optctx, const char *opt, const char *arg)
1208 {
1211 
1212  return 0;
1213 }
1214 
1215 int show_license(void *optctx, const char *opt, const char *arg)
1216 {
1217 #if CONFIG_NONFREE
1218  printf(
1219  "This version of %s has nonfree parts compiled in.\n"
1220  "Therefore it is not legally redistributable.\n",
1221  program_name );
1222 #elif CONFIG_GPLV3
1223  printf(
1224  "%s is free software; you can redistribute it and/or modify\n"
1225  "it under the terms of the GNU General Public License as published by\n"
1226  "the Free Software Foundation; either version 3 of the License, or\n"
1227  "(at your option) any later version.\n"
1228  "\n"
1229  "%s is distributed in the hope that it will be useful,\n"
1230  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1231  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1232  "GNU General Public License for more details.\n"
1233  "\n"
1234  "You should have received a copy of the GNU General Public License\n"
1235  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1237 #elif CONFIG_GPL
1238  printf(
1239  "%s is free software; you can redistribute it and/or modify\n"
1240  "it under the terms of the GNU General Public License as published by\n"
1241  "the Free Software Foundation; either version 2 of the License, or\n"
1242  "(at your option) any later version.\n"
1243  "\n"
1244  "%s is distributed in the hope that it will be useful,\n"
1245  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1246  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1247  "GNU General Public License for more details.\n"
1248  "\n"
1249  "You should have received a copy of the GNU General Public License\n"
1250  "along with %s; if not, write to the Free Software\n"
1251  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1253 #elif CONFIG_LGPLV3
1254  printf(
1255  "%s is free software; you can redistribute it and/or modify\n"
1256  "it under the terms of the GNU Lesser General Public License as published by\n"
1257  "the Free Software Foundation; either version 3 of the License, or\n"
1258  "(at your option) any later version.\n"
1259  "\n"
1260  "%s is distributed in the hope that it will be useful,\n"
1261  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1262  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1263  "GNU Lesser General Public License for more details.\n"
1264  "\n"
1265  "You should have received a copy of the GNU Lesser General Public License\n"
1266  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1268 #else
1269  printf(
1270  "%s is free software; you can redistribute it and/or\n"
1271  "modify it under the terms of the GNU Lesser General Public\n"
1272  "License as published by the Free Software Foundation; either\n"
1273  "version 2.1 of the License, or (at your option) any later version.\n"
1274  "\n"
1275  "%s is distributed in the hope that it will be useful,\n"
1276  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1277  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
1278  "Lesser General Public License for more details.\n"
1279  "\n"
1280  "You should have received a copy of the GNU Lesser General Public\n"
1281  "License along with %s; if not, write to the Free Software\n"
1282  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1284 #endif
1285 
1286  return 0;
1287 }
1288 
1289 static int is_device(const AVClass *avclass)
1290 {
1291  if (!avclass)
1292  return 0;
1293  return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
1294 }
1295 
1296 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
1297 {
1298  void *ifmt_opaque = NULL;
1299  const AVInputFormat *ifmt = NULL;
1300  void *ofmt_opaque = NULL;
1301  const AVOutputFormat *ofmt = NULL;
1302  const char *last_name;
1303  int is_dev;
1304 
1305  printf("%s\n"
1306  " D. = Demuxing supported\n"
1307  " .E = Muxing supported\n"
1308  " --\n", device_only ? "Devices:" : "File formats:");
1309  last_name = "000";
1310  for (;;) {
1311  int decode = 0;
1312  int encode = 0;
1313  const char *name = NULL;
1314  const char *long_name = NULL;
1315 
1316  if (muxdemuxers !=SHOW_DEMUXERS) {
1317  ofmt_opaque = NULL;
1318  while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
1319  is_dev = is_device(ofmt->priv_class);
1320  if (!is_dev && device_only)
1321  continue;
1322  if ((!name || strcmp(ofmt->name, name) < 0) &&
1323  strcmp(ofmt->name, last_name) > 0) {
1324  name = ofmt->name;
1325  long_name = ofmt->long_name;
1326  encode = 1;
1327  }
1328  }
1329  }
1330  if (muxdemuxers != SHOW_MUXERS) {
1331  ifmt_opaque = NULL;
1332  while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
1333  is_dev = is_device(ifmt->priv_class);
1334  if (!is_dev && device_only)
1335  continue;
1336  if ((!name || strcmp(ifmt->name, name) < 0) &&
1337  strcmp(ifmt->name, last_name) > 0) {
1338  name = ifmt->name;
1339  long_name = ifmt->long_name;
1340  encode = 0;
1341  }
1342  if (name && strcmp(ifmt->name, name) == 0)
1343  decode = 1;
1344  }
1345  }
1346  if (!name)
1347  break;
1348  last_name = name;
1349 
1350  printf(" %s%s %-15s %s\n",
1351  decode ? "D" : " ",
1352  encode ? "E" : " ",
1353  name,
1354  long_name ? long_name:" ");
1355  }
1356  return 0;
1357 }
1358 
1359 int show_formats(void *optctx, const char *opt, const char *arg)
1360 {
1361  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
1362 }
1363 
1364 int show_muxers(void *optctx, const char *opt, const char *arg)
1365 {
1366  return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
1367 }
1368 
1369 int show_demuxers(void *optctx, const char *opt, const char *arg)
1370 {
1371  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
1372 }
1373 
1374 int show_devices(void *optctx, const char *opt, const char *arg)
1375 {
1376  return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
1377 }
1378 
1379 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
1380  if (codec->field) { \
1381  const type *p = codec->field; \
1382  \
1383  printf(" Supported " list_name ":"); \
1384  while (*p != term) { \
1385  get_name(*p); \
1386  printf(" %s", name); \
1387  p++; \
1388  } \
1389  printf("\n"); \
1390  } \
1391 
1392 static void print_codec(const AVCodec *c)
1393 {
1394  int encoder = av_codec_is_encoder(c);
1395 
1396  printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
1397  c->long_name ? c->long_name : "");
1398 
1399  printf(" General capabilities: ");
1401  printf("horizband ");
1402  if (c->capabilities & AV_CODEC_CAP_DR1)
1403  printf("dr1 ");
1405  printf("trunc ");
1407  printf("delay ");
1409  printf("small ");
1411  printf("subframes ");
1413  printf("exp ");
1415  printf("chconf ");
1417  printf("paramchange ");
1419  printf("variable ");
1423  printf("threads ");
1425  printf("avoidprobe ");
1427  printf("intraonly ");
1429  printf("lossless ");
1431  printf("hardware ");
1433  printf("hybrid ");
1434  if (!c->capabilities)
1435  printf("none");
1436  printf("\n");
1437 
1438  if (c->type == AVMEDIA_TYPE_VIDEO ||
1439  c->type == AVMEDIA_TYPE_AUDIO) {
1440  printf(" Threading capabilities: ");
1445  AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
1446  case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
1447  case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
1448  case AV_CODEC_CAP_AUTO_THREADS : printf("auto"); break;
1449  default: printf("none"); break;
1450  }
1451  printf("\n");
1452  }
1453 
1454  if (avcodec_get_hw_config(c, 0)) {
1455  printf(" Supported hardware devices: ");
1456  for (int i = 0;; i++) {
1457  const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
1458  if (!config)
1459  break;
1460  printf("%s ", av_hwdevice_get_type_name(config->device_type));
1461  }
1462  printf("\n");
1463  }
1464 
1465  if (c->supported_framerates) {
1466  const AVRational *fps = c->supported_framerates;
1467 
1468  printf(" Supported framerates:");
1469  while (fps->num) {
1470  printf(" %d/%d", fps->num, fps->den);
1471  fps++;
1472  }
1473  printf("\n");
1474  }
1475  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
1477  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
1479  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1481  PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1482  0, GET_CH_LAYOUT_DESC);
1483 
1484  if (c->priv_class) {
1488  }
1489 }
1490 
1492 {
1493  switch (type) {
1494  case AVMEDIA_TYPE_VIDEO: return 'V';
1495  case AVMEDIA_TYPE_AUDIO: return 'A';
1496  case AVMEDIA_TYPE_DATA: return 'D';
1497  case AVMEDIA_TYPE_SUBTITLE: return 'S';
1498  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
1499  default: return '?';
1500  }
1501 }
1502 
1503 static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
1504  int encoder)
1505 {
1506  while ((prev = av_codec_next(prev))) {
1507  if (prev->id == id &&
1508  (encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
1509  return prev;
1510  }
1511  return NULL;
1512 }
1513 
1514 static int compare_codec_desc(const void *a, const void *b)
1515 {
1516  const AVCodecDescriptor * const *da = a;
1517  const AVCodecDescriptor * const *db = b;
1518 
1519  return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
1520  strcmp((*da)->name, (*db)->name);
1521 }
1522 
1523 static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
1524 {
1525  const AVCodecDescriptor *desc = NULL;
1526  const AVCodecDescriptor **codecs;
1527  unsigned nb_codecs = 0, i = 0;
1528 
1529  while ((desc = avcodec_descriptor_next(desc)))
1530  nb_codecs++;
1531  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
1532  av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
1533  exit_program(1);
1534  }
1535  desc = NULL;
1536  while ((desc = avcodec_descriptor_next(desc)))
1537  codecs[i++] = desc;
1538  av_assert0(i == nb_codecs);
1539  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
1540  *rcodecs = codecs;
1541  return nb_codecs;
1542 }
1543 
1544 static void print_codecs_for_id(enum AVCodecID id, int encoder)
1545 {
1546  const AVCodec *codec = NULL;
1547 
1548  printf(" (%s: ", encoder ? "encoders" : "decoders");
1549 
1550  while ((codec = next_codec_for_id(id, codec, encoder)))
1551  printf("%s ", codec->name);
1552 
1553  printf(")");
1554 }
1555 
1556 int show_codecs(void *optctx, const char *opt, const char *arg)
1557 {
1558  const AVCodecDescriptor **codecs;
1559  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1560 
1561  printf("Codecs:\n"
1562  " D..... = Decoding supported\n"
1563  " .E.... = Encoding supported\n"
1564  " ..V... = Video codec\n"
1565  " ..A... = Audio codec\n"
1566  " ..S... = Subtitle codec\n"
1567  " ...I.. = Intra frame-only codec\n"
1568  " ....L. = Lossy compression\n"
1569  " .....S = Lossless compression\n"
1570  " -------\n");
1571  for (i = 0; i < nb_codecs; i++) {
1572  const AVCodecDescriptor *desc = codecs[i];
1573  const AVCodec *codec = NULL;
1574 
1575  if (strstr(desc->name, "_deprecated"))
1576  continue;
1577 
1578  printf(" ");
1579  printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1580  printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1581 
1582  printf("%c", get_media_type_char(desc->type));
1583  printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1584  printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
1585  printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
1586 
1587  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1588 
1589  /* print decoders/encoders when there's more than one or their
1590  * names are different from codec name */
1591  while ((codec = next_codec_for_id(desc->id, codec, 0))) {
1592  if (strcmp(codec->name, desc->name)) {
1593  print_codecs_for_id(desc->id, 0);
1594  break;
1595  }
1596  }
1597  codec = NULL;
1598  while ((codec = next_codec_for_id(desc->id, codec, 1))) {
1599  if (strcmp(codec->name, desc->name)) {
1600  print_codecs_for_id(desc->id, 1);
1601  break;
1602  }
1603  }
1604 
1605  printf("\n");
1606  }
1607  av_free(codecs);
1608  return 0;
1609 }
1610 
1611 static void print_codecs(int encoder)
1612 {
1613  const AVCodecDescriptor **codecs;
1614  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1615 
1616  printf("%s:\n"
1617  " V..... = Video\n"
1618  " A..... = Audio\n"
1619  " S..... = Subtitle\n"
1620  " .F.... = Frame-level multithreading\n"
1621  " ..S... = Slice-level multithreading\n"
1622  " ...X.. = Codec is experimental\n"
1623  " ....B. = Supports draw_horiz_band\n"
1624  " .....D = Supports direct rendering method 1\n"
1625  " ------\n",
1626  encoder ? "Encoders" : "Decoders");
1627  for (i = 0; i < nb_codecs; i++) {
1628  const AVCodecDescriptor *desc = codecs[i];
1629  const AVCodec *codec = NULL;
1630 
1631  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1632  printf(" %c", get_media_type_char(desc->type));
1633  printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1634  printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1635  printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
1636  printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
1637  printf((codec->capabilities & AV_CODEC_CAP_DR1) ? "D" : ".");
1638 
1639  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1640  if (strcmp(codec->name, desc->name))
1641  printf(" (codec %s)", desc->name);
1642 
1643  printf("\n");
1644  }
1645  }
1646  av_free(codecs);
1647 }
1648 
1649 int show_decoders(void *optctx, const char *opt, const char *arg)
1650 {
1651  print_codecs(0);
1652  return 0;
1653 }
1654 
1655 int show_encoders(void *optctx, const char *opt, const char *arg)
1656 {
1657  print_codecs(1);
1658  return 0;
1659 }
1660 
1661 int show_bsfs(void *optctx, const char *opt, const char *arg)
1662 {
1663  const AVBitStreamFilter *bsf = NULL;
1664  void *opaque = NULL;
1665 
1666  printf("Bitstream filters:\n");
1667  while ((bsf = av_bsf_iterate(&opaque)))
1668  printf("%s\n", bsf->name);
1669  printf("\n");
1670  return 0;
1671 }
1672 
1673 int show_protocols(void *optctx, const char *opt, const char *arg)
1674 {
1675  void *opaque = NULL;
1676  const char *name;
1677 
1678  printf("Supported file protocols:\n"
1679  "Input:\n");
1680  while ((name = avio_enum_protocols(&opaque, 0)))
1681  printf(" %s\n", name);
1682  printf("Output:\n");
1683  while ((name = avio_enum_protocols(&opaque, 1)))
1684  printf(" %s\n", name);
1685  return 0;
1686 }
1687 
1688 int show_filters(void *optctx, const char *opt, const char *arg)
1689 {
1690 #if CONFIG_AVFILTER
1691  const AVFilter *filter = NULL;
1692  char descr[64], *descr_cur;
1693  void *opaque = NULL;
1694  int i, j;
1695  const AVFilterPad *pad;
1696 
1697  printf("Filters:\n"
1698  " T.. = Timeline support\n"
1699  " .S. = Slice threading\n"
1700  " ..C = Command support\n"
1701  " A = Audio input/output\n"
1702  " V = Video input/output\n"
1703  " N = Dynamic number and/or type of input/output\n"
1704  " | = Source or sink filter\n");
1705  while ((filter = av_filter_iterate(&opaque))) {
1706  descr_cur = descr;
1707  for (i = 0; i < 2; i++) {
1708  if (i) {
1709  *(descr_cur++) = '-';
1710  *(descr_cur++) = '>';
1711  }
1712  pad = i ? filter->outputs : filter->inputs;
1713  for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
1714  if (descr_cur >= descr + sizeof(descr) - 4)
1715  break;
1716  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
1717  }
1718  if (!j)
1719  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1720  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1721  }
1722  *descr_cur = 0;
1723  printf(" %c%c%c %-17s %-10s %s\n",
1724  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1725  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
1726  filter->process_command ? 'C' : '.',
1727  filter->name, descr, filter->description);
1728  }
1729 #else
1730  printf("No filters available: libavfilter disabled\n");
1731 #endif
1732  return 0;
1733 }
1734 
1735 int show_colors(void *optctx, const char *opt, const char *arg)
1736 {
1737  const char *name;
1738  const uint8_t *rgb;
1739  int i;
1740 
1741  printf("%-32s #RRGGBB\n", "name");
1742 
1743  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1744  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1745 
1746  return 0;
1747 }
1748 
1749 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1750 {
1751  const AVPixFmtDescriptor *pix_desc = NULL;
1752 
1753  printf("Pixel formats:\n"
1754  "I.... = Supported Input format for conversion\n"
1755  ".O... = Supported Output format for conversion\n"
1756  "..H.. = Hardware accelerated format\n"
1757  "...P. = Paletted format\n"
1758  "....B = Bitstream format\n"
1759  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1760  "-----\n");
1761 
1762 #if !CONFIG_SWSCALE
1763 # define sws_isSupportedInput(x) 0
1764 # define sws_isSupportedOutput(x) 0
1765 #endif
1766 
1767  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1769  printf("%c%c%c%c%c %-16s %d %2d\n",
1770  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
1771  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
1772  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
1773  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
1774  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1775  pix_desc->name,
1776  pix_desc->nb_components,
1777  av_get_bits_per_pixel(pix_desc));
1778  }
1779  return 0;
1780 }
1781 
1782 int show_layouts(void *optctx, const char *opt, const char *arg)
1783 {
1784  int i = 0;
1785  uint64_t layout, j;
1786  const char *name, *descr;
1787 
1788  printf("Individual channels:\n"
1789  "NAME DESCRIPTION\n");
1790  for (i = 0; i < 63; i++) {
1791  name = av_get_channel_name((uint64_t)1 << i);
1792  if (!name)
1793  continue;
1794  descr = av_get_channel_description((uint64_t)1 << i);
1795  printf("%-14s %s\n", name, descr);
1796  }
1797  printf("\nStandard channel layouts:\n"
1798  "NAME DECOMPOSITION\n");
1799  for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1800  if (name) {
1801  printf("%-14s ", name);
1802  for (j = 1; j; j <<= 1)
1803  if ((layout & j))
1804  printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1805  printf("\n");
1806  }
1807  }
1808  return 0;
1809 }
1810 
1811 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1812 {
1813  int i;
1814  char fmt_str[128];
1815  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1816  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1817  return 0;
1818 }
1819 
1820 static void show_help_codec(const char *name, int encoder)
1821 {
1822  const AVCodecDescriptor *desc;
1823  const AVCodec *codec;
1824 
1825  if (!name) {
1826  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1827  return;
1828  }
1829 
1830  codec = encoder ? avcodec_find_encoder_by_name(name) :
1832 
1833  if (codec)
1834  print_codec(codec);
1835  else if ((desc = avcodec_descriptor_get_by_name(name))) {
1836  int printed = 0;
1837 
1838  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1839  printed = 1;
1840  print_codec(codec);
1841  }
1842 
1843  if (!printed) {
1844  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1845  "but no %s for it are available. FFmpeg might need to be "
1846  "recompiled with additional external libraries.\n",
1847  name, encoder ? "encoders" : "decoders");
1848  }
1849  } else {
1850  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1851  name);
1852  }
1853 }
1854 
1855 static void show_help_demuxer(const char *name)
1856 {
1857  const AVInputFormat *fmt = av_find_input_format(name);
1858 
1859  if (!fmt) {
1860  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1861  return;
1862  }
1863 
1864  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1865 
1866  if (fmt->extensions)
1867  printf(" Common extensions: %s.\n", fmt->extensions);
1868 
1869  if (fmt->priv_class)
1871 }
1872 
1873 static void show_help_muxer(const char *name)
1874 {
1875  const AVCodecDescriptor *desc;
1876  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1877 
1878  if (!fmt) {
1879  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1880  return;
1881  }
1882 
1883  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1884 
1885  if (fmt->extensions)
1886  printf(" Common extensions: %s.\n", fmt->extensions);
1887  if (fmt->mime_type)
1888  printf(" Mime type: %s.\n", fmt->mime_type);
1889  if (fmt->video_codec != AV_CODEC_ID_NONE &&
1890  (desc = avcodec_descriptor_get(fmt->video_codec))) {
1891  printf(" Default video codec: %s.\n", desc->name);
1892  }
1893  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1894  (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1895  printf(" Default audio codec: %s.\n", desc->name);
1896  }
1897  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1898  (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1899  printf(" Default subtitle codec: %s.\n", desc->name);
1900  }
1901 
1902  if (fmt->priv_class)
1904 }
1905 
1906 #if CONFIG_AVFILTER
1907 static void show_help_filter(const char *name)
1908 {
1909 #if CONFIG_AVFILTER
1910  const AVFilter *f = avfilter_get_by_name(name);
1911  int i, count;
1912 
1913  if (!name) {
1914  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1915  return;
1916  } else if (!f) {
1917  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1918  return;
1919  }
1920 
1921  printf("Filter %s\n", f->name);
1922  if (f->description)
1923  printf(" %s\n", f->description);
1924 
1926  printf(" slice threading supported\n");
1927 
1928  printf(" Inputs:\n");
1929  count = avfilter_pad_count(f->inputs);
1930  for (i = 0; i < count; i++) {
1931  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1933  }
1935  printf(" dynamic (depending on the options)\n");
1936  else if (!count)
1937  printf(" none (source filter)\n");
1938 
1939  printf(" Outputs:\n");
1940  count = avfilter_pad_count(f->outputs);
1941  for (i = 0; i < count; i++) {
1942  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1944  }
1946  printf(" dynamic (depending on the options)\n");
1947  else if (!count)
1948  printf(" none (sink filter)\n");
1949 
1950  if (f->priv_class)
1954  printf("This filter has support for timeline through the 'enable' option.\n");
1955 #else
1956  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1957  "can not to satisfy request\n");
1958 #endif
1959 }
1960 #endif
1961 
1962 static void show_help_bsf(const char *name)
1963 {
1964  const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
1965 
1966  if (!name) {
1967  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
1968  return;
1969  } else if (!bsf) {
1970  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
1971  return;
1972  }
1973 
1974  printf("Bit stream filter %s\n", bsf->name);
1975  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
1977  if (bsf->priv_class)
1979 }
1980 
1981 int show_help(void *optctx, const char *opt, const char *arg)
1982 {
1983  char *topic, *par;
1985 
1986  topic = av_strdup(arg ? arg : "");
1987  if (!topic)
1988  return AVERROR(ENOMEM);
1989  par = strchr(topic, '=');
1990  if (par)
1991  *par++ = 0;
1992 
1993  if (!*topic) {
1994  show_help_default(topic, par);
1995  } else if (!strcmp(topic, "decoder")) {
1996  show_help_codec(par, 0);
1997  } else if (!strcmp(topic, "encoder")) {
1998  show_help_codec(par, 1);
1999  } else if (!strcmp(topic, "demuxer")) {
2000  show_help_demuxer(par);
2001  } else if (!strcmp(topic, "muxer")) {
2002  show_help_muxer(par);
2003 #if CONFIG_AVFILTER
2004  } else if (!strcmp(topic, "filter")) {
2005  show_help_filter(par);
2006 #endif
2007  } else if (!strcmp(topic, "bsf")) {
2008  show_help_bsf(par);
2009  } else {
2010  show_help_default(topic, par);
2011  }
2012 
2013  av_freep(&topic);
2014  return 0;
2015 }
2016 
2017 int read_yesno(void)
2018 {
2019  int c = getchar();
2020  int yesno = (av_toupper(c) == 'Y');
2021 
2022  while (c != '\n' && c != EOF)
2023  c = getchar();
2024 
2025  return yesno;
2026 }
2027 
2028 FILE *get_preset_file(char *filename, size_t filename_size,
2029  const char *preset_name, int is_path,
2030  const char *codec_name)
2031 {
2032  FILE *f = NULL;
2033  int i;
2034  const char *base[3] = { getenv("FFMPEG_DATADIR"),
2035  getenv("HOME"),
2036  FFMPEG_DATADIR, };
2037 
2038  if (is_path) {
2039  av_strlcpy(filename, preset_name, filename_size);
2040  f = fopen(filename, "r");
2041  } else {
2042 #ifdef _WIN32
2043  char datadir[MAX_PATH], *ls;
2044  base[2] = NULL;
2045 
2046  if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
2047  {
2048  for (ls = datadir; ls < datadir + strlen(datadir); ls++)
2049  if (*ls == '\\') *ls = '/';
2050 
2051  if (ls = strrchr(datadir, '/'))
2052  {
2053  *ls = 0;
2054  strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
2055  base[2] = datadir;
2056  }
2057  }
2058 #endif
2059  for (i = 0; i < 3 && !f; i++) {
2060  if (!base[i])
2061  continue;
2062  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
2063  i != 1 ? "" : "/.ffmpeg", preset_name);
2064  f = fopen(filename, "r");
2065  if (!f && codec_name) {
2066  snprintf(filename, filename_size,
2067  "%s%s/%s-%s.ffpreset",
2068  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
2069  preset_name);
2070  f = fopen(filename, "r");
2071  }
2072  }
2073  }
2074 
2075  return f;
2076 }
2077 
2078 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
2079 {
2080  int ret = avformat_match_stream_specifier(s, st, spec);
2081  if (ret < 0)
2082  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
2083  return ret;
2084 }
2085 
2087  AVFormatContext *s, AVStream *st, AVCodec *codec)
2088 {
2089  AVDictionary *ret = NULL;
2090  AVDictionaryEntry *t = NULL;
2093  char prefix = 0;
2094  const AVClass *cc = avcodec_get_class();
2095 
2096  if (!codec)
2097  codec = s->oformat ? avcodec_find_encoder(codec_id)
2098  : avcodec_find_decoder(codec_id);
2099 
2100  switch (st->codecpar->codec_type) {
2101  case AVMEDIA_TYPE_VIDEO:
2102  prefix = 'v';
2103  flags |= AV_OPT_FLAG_VIDEO_PARAM;
2104  break;
2105  case AVMEDIA_TYPE_AUDIO:
2106  prefix = 'a';
2107  flags |= AV_OPT_FLAG_AUDIO_PARAM;
2108  break;
2109  case AVMEDIA_TYPE_SUBTITLE:
2110  prefix = 's';
2111  flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
2112  break;
2113  }
2114 
2115  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
2116  char *p = strchr(t->key, ':');
2117 
2118  /* check stream specification in opt name */
2119  if (p)
2120  switch (check_stream_specifier(s, st, p + 1)) {
2121  case 1: *p = 0; break;
2122  case 0: continue;
2123  default: exit_program(1);
2124  }
2125 
2126  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
2127  !codec ||
2128  (codec->priv_class &&
2129  av_opt_find(&codec->priv_class, t->key, NULL, flags,
2131  av_dict_set(&ret, t->key, t->value, 0);
2132  else if (t->key[0] == prefix &&
2133  av_opt_find(&cc, t->key + 1, NULL, flags,
2135  av_dict_set(&ret, t->key + 1, t->value, 0);
2136 
2137  if (p)
2138  *p = ':';
2139  }
2140  return ret;
2141 }
2142 
2144  AVDictionary *codec_opts)
2145 {
2146  int i;
2147  AVDictionary **opts;
2148 
2149  if (!s->nb_streams)
2150  return NULL;
2151  opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
2152  if (!opts) {
2154  "Could not alloc memory for stream options.\n");
2155  return NULL;
2156  }
2157  for (i = 0; i < s->nb_streams; i++)
2158  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
2159  s, s->streams[i], NULL);
2160  return opts;
2161 }
2162 
2163 void *grow_array(void *array, int elem_size, int *size, int new_size)
2164 {
2165  if (new_size >= INT_MAX / elem_size) {
2166  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
2167  exit_program(1);
2168  }
2169  if (*size < new_size) {
2170  uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
2171  if (!tmp) {
2172  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
2173  exit_program(1);
2174  }
2175  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
2176  *size = new_size;
2177  return tmp;
2178  }
2179  return array;
2180 }
2181 
2183 {
2184  uint8_t* displaymatrix = av_stream_get_side_data(st,
2186  double theta = 0;
2187  if (displaymatrix)
2188  theta = -av_display_rotation_get((int32_t*) displaymatrix);
2189 
2190  theta -= 360*floor(theta/360 + 0.9/360);
2191 
2192  if (fabs(theta - 90*round(theta/90)) > 2)
2193  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
2194  "If you want to help, upload a sample "
2195  "of this file to ftp://upload.ffmpeg.org/incoming/ "
2196  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
2197 
2198  return theta;
2199 }
2200 
2201 #if CONFIG_AVDEVICE
2202 static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
2203 {
2204  int ret, i;
2205  AVDeviceInfoList *device_list = NULL;
2206 
2207  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
2208  return AVERROR(EINVAL);
2209 
2210  printf("Auto-detected sources for %s:\n", fmt->name);
2211  if (!fmt->get_device_list) {
2212  ret = AVERROR(ENOSYS);
2213  printf("Cannot list sources. Not implemented.\n");
2214  goto fail;
2215  }
2216 
2217  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
2218  printf("Cannot list sources.\n");
2219  goto fail;
2220  }
2221 
2222  for (i = 0; i < device_list->nb_devices; i++) {
2223  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2224  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2225  }
2226 
2227  fail:
2228  avdevice_free_list_devices(&device_list);
2229  return ret;
2230 }
2231 
2232 static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
2233 {
2234  int ret, i;
2235  AVDeviceInfoList *device_list = NULL;
2236 
2237  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
2238  return AVERROR(EINVAL);
2239 
2240  printf("Auto-detected sinks for %s:\n", fmt->name);
2241  if (!fmt->get_device_list) {
2242  ret = AVERROR(ENOSYS);
2243  printf("Cannot list sinks. Not implemented.\n");
2244  goto fail;
2245  }
2246 
2247  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
2248  printf("Cannot list sinks.\n");
2249  goto fail;
2250  }
2251 
2252  for (i = 0; i < device_list->nb_devices; i++) {
2253  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2254  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2255  }
2256 
2257  fail:
2258  avdevice_free_list_devices(&device_list);
2259  return ret;
2260 }
2261 
2262 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
2263 {
2264  int ret;
2265  if (arg) {
2266  char *opts_str = NULL;
2267  av_assert0(dev && opts);
2268  *dev = av_strdup(arg);
2269  if (!*dev)
2270  return AVERROR(ENOMEM);
2271  if ((opts_str = strchr(*dev, ','))) {
2272  *(opts_str++) = '\0';
2273  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
2274  av_freep(dev);
2275  return ret;
2276  }
2277  }
2278  } else
2279  printf("\nDevice name is not provided.\n"
2280  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
2281  return 0;
2282 }
2283 
2284 int show_sources(void *optctx, const char *opt, const char *arg)
2285 {
2286  AVInputFormat *fmt = NULL;
2287  char *dev = NULL;
2288  AVDictionary *opts = NULL;
2289  int ret = 0;
2290  int error_level = av_log_get_level();
2291 
2293 
2294  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2295  goto fail;
2296 
2297  do {
2298  fmt = av_input_audio_device_next(fmt);
2299  if (fmt) {
2300  if (!strcmp(fmt->name, "lavfi"))
2301  continue; //it's pointless to probe lavfi
2302  if (dev && !av_match_name(dev, fmt->name))
2303  continue;
2304  print_device_sources(fmt, opts);
2305  }
2306  } while (fmt);
2307  do {
2308  fmt = av_input_video_device_next(fmt);
2309  if (fmt) {
2310  if (dev && !av_match_name(dev, fmt->name))
2311  continue;
2312  print_device_sources(fmt, opts);
2313  }
2314  } while (fmt);
2315  fail:
2316  av_dict_free(&opts);
2317  av_free(dev);
2318  av_log_set_level(error_level);
2319  return ret;
2320 }
2321 
2322 int show_sinks(void *optctx, const char *opt, const char *arg)
2323 {
2324  AVOutputFormat *fmt = NULL;
2325  char *dev = NULL;
2326  AVDictionary *opts = NULL;
2327  int ret = 0;
2328  int error_level = av_log_get_level();
2329 
2331 
2332  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2333  goto fail;
2334 
2335  do {
2336  fmt = av_output_audio_device_next(fmt);
2337  if (fmt) {
2338  if (dev && !av_match_name(dev, fmt->name))
2339  continue;
2340  print_device_sinks(fmt, opts);
2341  }
2342  } while (fmt);
2343  do {
2344  fmt = av_output_video_device_next(fmt);
2345  if (fmt) {
2346  if (dev && !av_match_name(dev, fmt->name))
2347  continue;
2348  print_device_sinks(fmt, opts);
2349  }
2350  } while (fmt);
2351  fail:
2352  av_dict_free(&opts);
2353  av_free(dev);
2354  av_log_set_level(error_level);
2355  return ret;
2356 }
2357 
2358 #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:753
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:5842
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:1649
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:891
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:1215
#define AV_CODEC_PROP_LOSSY
Codec supports lossy compression.
Definition: avcodec.h:759
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:280
double get_rotation(AVStream *st)
Definition: cmdutils.c:2182
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:844
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:1689
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: avcodec.h:1081
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:2078
#define INDENT
Definition: cmdutils.c:1100
enum AVCodecID codec_id
Definition: qsv.c:77
#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:1052
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:3968
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:266
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1187
static int is_device(const AVClass *avclass)
Definition: cmdutils.c:1289
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:1673
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:1369
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:1032
enum AVMediaType type
Definition: avcodec.h:3505
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:1036
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:1374
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:1359
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:1052
#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:3492
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the pixel formats supported by the program.
Definition: cmdutils.c:1749
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2086
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:1070
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:3282
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:1296
#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:1009
static int warned_cfg
Definition: cmdutils.c:1098
#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:1556
Public dictionary API.
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:139
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:3260
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: cmdutils.c:1523
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:763
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1061
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:1255
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:5310
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:1364
int show_buildconf(void *optctx, const char *opt, const char *arg)
Print the build configuration of the program to stdout.
Definition: cmdutils.c:1207
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5490
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:5824
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:1134
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:170
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
#define max(a, b)
Definition: cuda_runtime.h:33
external API header
ptrdiff_t size
Definition: opengl_enc.c:100
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c: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:1611
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:2143
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:507
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:919
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:1981
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:3506
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:292
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:95
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the sample formats supported by the program.
Definition: cmdutils.c:1811
#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:3511
#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:3964
const char * arg
Definition: jacosubdec.c:66
#define SHOW_COPYRIGHT
Definition: cmdutils.c:1103
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:1873
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:1379
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:3499
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:348
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:731
const char * val
Definition: cmdutils.h:293
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
int show_filters(void *optctx, const char *opt, const char *arg)
Print a listing containing all the filters supported by the program.
Definition: cmdutils.c:1688
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:122
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1040
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:1056
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3276
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 props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:735
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:498
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:1631
#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
int opt_report(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1056
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:978
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:1735
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:1014
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:557
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:1661
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: cmdutils.c:1544
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:3176
#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:1075
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:524
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3291
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:1491
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1044
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:3504
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:1503
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:3512
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:1316
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:1784
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:896
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:1088
Replacements for frequently missing libm functions.
#define SHOW_VERSION
Definition: cmdutils.c:1101
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:2028
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:1105
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:1027
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:487
#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:2163
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:727
#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:1047
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:1392
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:719
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:985
#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:924
#define flags(name, subs,...)
Definition: cbs_av1.c:561
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3518
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:721
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:1088
#define OPT_INT
Definition: cmdutils.h:167
const OptionDef options[]
Definition: ffmpeg_opt.c:3374
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:1962
OptionGroupList * groups
Definition: cmdutils.h:339
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: avcodec.h:1048
#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:1074
OptionGroup global_opts
Definition: cmdutils.h:337
static void print_buildconf(int flags, int level)
Definition: cmdutils.c:1161
#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:566
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:720
#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:1102
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:1507
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:1066
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:1782
#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:2017
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:1855
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:3482
int show_version(void *optctx, const char *opt, const char *arg)
Print the version of the program to stdout.
Definition: cmdutils.c:1198
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:1147
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:984
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:1820
#define av_unused
Definition: attributes.h:125
static int compare_codec_desc(const void *a, const void *b)
Definition: cmdutils.c:1514
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:1655
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