FFmpeg: cmdutils.c Source File

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

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