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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 <stdlib.h>
24 #include <errno.h>
25 #include <math.h>
26 
27 /* Include only the enabled headers since some compilers (namely, Sun
28  Studio) will not omit unused inline functions and create undefined
29  references to libraries that are not being built. */
30 
31 #include "config.h"
32 #include "libavformat/avformat.h"
33 #include "libavfilter/avfilter.h"
34 #include "libavdevice/avdevice.h"
35 #include "libswscale/swscale.h"
36 #if CONFIG_POSTPROC
38 #endif
39 #include "libavutil/avstring.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
46 #include "cmdutils.h"
47 #include "version.h"
48 #if CONFIG_NETWORK
49 #include "libavformat/network.h"
50 #endif
51 #if HAVE_SYS_RESOURCE_H
52 #include <sys/resource.h>
53 #endif
54 
57 
58 static const int this_year = 2014;
59 
60 void init_opts(void)
61 {
62 #if CONFIG_SWSCALE
63  sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
64  NULL, NULL, NULL);
65 #endif
66 }
67 
68 void uninit_opts(void)
69 {
70 #if CONFIG_SWSCALE
71  sws_freeContext(sws_opts);
72  sws_opts = NULL;
73 #endif
74  av_dict_free(&format_opts);
75  av_dict_free(&codec_opts);
76 }
77 
78 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
79 {
80  vfprintf(stdout, fmt, vl);
81 }
82 
83 double parse_number_or_die(const char *context, const char *numstr, int type,
84  double min, double max)
85 {
86  char *tail;
87  const char *error;
88  double d = av_strtod(numstr, &tail);
89  if (*tail)
90  error = "Expected number for %s but found: %s\n";
91  else if (d < min || d > max)
92  error = "The value for %s was %s which is not within %f - %f\n";
93  else if (type == OPT_INT64 && (int64_t)d != d)
94  error = "Expected int64 for %s but found %s\n";
95  else if (type == OPT_INT && (int)d != d)
96  error = "Expected int for %s but found %s\n";
97  else
98  return d;
99  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
100  exit_program(1);
101  return 0;
102 }
103 
104 int64_t parse_time_or_die(const char *context, const char *timestr,
105  int is_duration)
106 {
107  int64_t us;
108  if (av_parse_time(&us, timestr, is_duration) < 0) {
109  av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
110  is_duration ? "duration" : "date", context, timestr);
111  exit_program(1);
112  }
113  return us;
114 }
115 
116 void show_help_options(const OptionDef *options, const char *msg, int mask,
117  int value)
118 {
119  const OptionDef *po;
120  int first;
121 
122  first = 1;
123  for (po = options; po->name != NULL; po++) {
124  char buf[64];
125  if ((po->flags & mask) == value) {
126  if (first) {
127  printf("%s", msg);
128  first = 0;
129  }
130  av_strlcpy(buf, po->name, sizeof(buf));
131  if (po->flags & HAS_ARG) {
132  av_strlcat(buf, " ", sizeof(buf));
133  av_strlcat(buf, po->argname, sizeof(buf));
134  }
135  printf("-%-17s %s\n", buf, po->help);
136  }
137  }
138 }
139 
140 void show_help_children(const AVClass *class, int flags)
141 {
142  const AVClass *child = NULL;
143  av_opt_show2(&class, NULL, flags, 0);
144  printf("\n");
145 
146  while (child = av_opt_child_class_next(class, child))
147  show_help_children(child, flags);
148 }
149 
150 static const OptionDef *find_option(const OptionDef *po, const char *name)
151 {
152  const char *p = strchr(name, ':');
153  int len = p ? p - name : strlen(name);
154 
155  while (po->name != NULL) {
156  if (!strncmp(name, po->name, len) && strlen(po->name) == len)
157  break;
158  po++;
159  }
160  return po;
161 }
162 
163 #if defined(_WIN32) && !defined(__MINGW32CE__)
164 #include <windows.h>
165 /* Will be leaked on exit */
166 static char** win32_argv_utf8 = NULL;
167 static int win32_argc = 0;
168 
176 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
177 {
178  char *argstr_flat;
179  wchar_t **argv_w;
180  int i, buffsize = 0, offset = 0;
181 
182  if (win32_argv_utf8) {
183  *argc_ptr = win32_argc;
184  *argv_ptr = win32_argv_utf8;
185  return;
186  }
187 
188  win32_argc = 0;
189  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
190  if (win32_argc <= 0 || !argv_w)
191  return;
192 
193  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
194  for (i = 0; i < win32_argc; i++)
195  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
196  NULL, 0, NULL, NULL);
197 
198  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
199  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
200  if (win32_argv_utf8 == NULL) {
201  LocalFree(argv_w);
202  return;
203  }
204 
205  for (i = 0; i < win32_argc; i++) {
206  win32_argv_utf8[i] = &argstr_flat[offset];
207  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
208  &argstr_flat[offset],
209  buffsize - offset, NULL, NULL);
210  }
211  win32_argv_utf8[i] = NULL;
212  LocalFree(argv_w);
213 
214  *argc_ptr = win32_argc;
215  *argv_ptr = win32_argv_utf8;
216 }
217 #else
218 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
219 {
220  /* nothing to do */
221 }
222 #endif /* WIN32 && !__MINGW32CE__ */
223 
224 int parse_option(void *optctx, const char *opt, const char *arg,
225  const OptionDef *options)
226 {
227  const OptionDef *po;
228  int bool_val = 1;
229  int *dstcount;
230  void *dst;
231 
232  po = find_option(options, opt);
233  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
234  /* handle 'no' bool option */
235  po = find_option(options, opt + 2);
236  if (!(po->name && (po->flags & OPT_BOOL)))
237  goto unknown_opt;
238  bool_val = 0;
239  }
240  if (!po->name)
241  po = find_option(options, "default");
242  if (!po->name) {
243 unknown_opt:
244  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
245  return AVERROR(EINVAL);
246  }
247  if (po->flags & HAS_ARG && !arg) {
248  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
249  return AVERROR(EINVAL);
250  }
251 
252  /* new-style options contain an offset into optctx, old-style address of
253  * a global var*/
254  dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
255  : po->u.dst_ptr;
256 
257  if (po->flags & OPT_SPEC) {
258  SpecifierOpt **so = dst;
259  char *p = strchr(opt, ':');
260 
261  dstcount = (int *)(so + 1);
262  *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
263  (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
264  dst = &(*so)[*dstcount - 1].u;
265  }
266 
267  if (po->flags & OPT_STRING) {
268  char *str;
269  str = av_strdup(arg);
270  *(char **)dst = str;
271  } else if (po->flags & OPT_BOOL) {
272  *(int *)dst = bool_val;
273  } else if (po->flags & OPT_INT) {
274  *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
275  } else if (po->flags & OPT_INT64) {
276  *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
277  } else if (po->flags & OPT_TIME) {
278  *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
279  } else if (po->flags & OPT_FLOAT) {
280  *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
281  } else if (po->flags & OPT_DOUBLE) {
282  *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
283  } else if (po->u.func_arg) {
284  int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
285  : po->u.func_arg(opt, arg);
286  if (ret < 0) {
288  "Failed to set value '%s' for option '%s'\n", arg, opt);
289  return ret;
290  }
291  }
292  if (po->flags & OPT_EXIT)
293  exit_program(0);
294  return !!(po->flags & HAS_ARG);
295 }
296 
297 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
298  void (*parse_arg_function)(void *, const char*))
299 {
300  const char *opt;
301  int optindex, handleoptions = 1, ret;
302 
303  /* perform system-dependent conversions for arguments list */
304  prepare_app_arguments(&argc, &argv);
305 
306  /* parse options */
307  optindex = 1;
308  while (optindex < argc) {
309  opt = argv[optindex++];
310 
311  if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
312  if (opt[1] == '-' && opt[2] == '\0') {
313  handleoptions = 0;
314  continue;
315  }
316  opt++;
317 
318  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
319  exit_program(1);
320  optindex += ret;
321  } else {
322  if (parse_arg_function)
323  parse_arg_function(optctx, opt);
324  }
325  }
326 }
327 
328 /*
329  * Return index of option opt in argv or 0 if not found.
330  */
331 static int locate_option(int argc, char **argv, const OptionDef *options,
332  const char *optname)
333 {
334  const OptionDef *po;
335  int i;
336 
337  for (i = 1; i < argc; i++) {
338  const char *cur_opt = argv[i];
339 
340  if (*cur_opt++ != '-')
341  continue;
342 
343  po = find_option(options, cur_opt);
344  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
345  po = find_option(options, cur_opt + 2);
346 
347  if ((!po->name && !strcmp(cur_opt, optname)) ||
348  (po->name && !strcmp(optname, po->name)))
349  return i;
350 
351  if (!po || po->flags & HAS_ARG)
352  i++;
353  }
354  return 0;
355 }
356 
357 void parse_loglevel(int argc, char **argv, const OptionDef *options)
358 {
359  int idx = locate_option(argc, argv, options, "loglevel");
360  if (!idx)
361  idx = locate_option(argc, argv, options, "v");
362  if (idx && argv[idx + 1])
363  opt_loglevel("loglevel", argv[idx + 1]);
364 }
365 
366 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
367 int opt_default(const char *opt, const char *arg)
368 {
369  const AVOption *o;
370  char opt_stripped[128];
371  const char *p;
372  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
373 #if CONFIG_SWSCALE
374  const AVClass *sc = sws_get_class();
375 #endif
376 
377  if (!(p = strchr(opt, ':')))
378  p = opt + strlen(opt);
379  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
380 
381  if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
383  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
384  (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
385  av_dict_set(&codec_opts, opt, arg, FLAGS);
386  else if ((o = av_opt_find(&fc, opt, NULL, 0,
388  av_dict_set(&format_opts, opt, arg, FLAGS);
389 #if CONFIG_SWSCALE
390  else if ((o = av_opt_find(&sc, opt, NULL, 0,
392  // XXX we only support sws_flags, not arbitrary sws options
393  int ret = av_opt_set(sws_opts, opt, arg, 0);
394  if (ret < 0) {
395  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
396  return ret;
397  }
398  }
399 #endif
400 
401  if (o)
402  return 0;
403  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
405 }
406 
407 int opt_loglevel(const char *opt, const char *arg)
408 {
409  const struct { const char *name; int level; } log_levels[] = {
410  { "quiet" , AV_LOG_QUIET },
411  { "panic" , AV_LOG_PANIC },
412  { "fatal" , AV_LOG_FATAL },
413  { "error" , AV_LOG_ERROR },
414  { "warning", AV_LOG_WARNING },
415  { "info" , AV_LOG_INFO },
416  { "verbose", AV_LOG_VERBOSE },
417  { "debug" , AV_LOG_DEBUG },
418  };
419  char *tail;
420  int level;
421  int i;
422 
423  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
424  if (!strcmp(log_levels[i].name, arg)) {
425  av_log_set_level(log_levels[i].level);
426  return 0;
427  }
428  }
429 
430  level = strtol(arg, &tail, 10);
431  if (*tail) {
432  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
433  "Possible levels are numbers or:\n", arg);
434  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
435  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
436  exit_program(1);
437  }
438  av_log_set_level(level);
439  return 0;
440 }
441 
442 int opt_timelimit(const char *opt, const char *arg)
443 {
444 #if HAVE_SETRLIMIT
445  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
446  struct rlimit rl = { lim, lim + 1 };
447  if (setrlimit(RLIMIT_CPU, &rl))
448  perror("setrlimit");
449 #else
450  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
451 #endif
452  return 0;
453 }
454 
455 void print_error(const char *filename, int err)
456 {
457  char errbuf[128];
458  const char *errbuf_ptr = errbuf;
459 
460  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
461  errbuf_ptr = strerror(AVUNERROR(err));
462  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
463 }
464 
465 // Debian/Ubuntu: see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=619530
466 // https://launchpad.net/bugs/765357
467 static int warned_cfg = 1;
468 
469 #define INDENT 1
470 #define SHOW_VERSION 2
471 #define SHOW_CONFIG 4
472 
473 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
474  if (CONFIG_##LIBNAME) { \
475  const char *indent = flags & INDENT? " " : ""; \
476  if (flags & SHOW_VERSION) { \
477  unsigned int version = libname##_version(); \
478  av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
479  indent, #libname, \
480  LIB##LIBNAME##_VERSION_MAJOR, \
481  LIB##LIBNAME##_VERSION_MINOR, \
482  LIB##LIBNAME##_VERSION_MICRO, \
483  version >> 16, version >> 8 & 0xff, version & 0xff); \
484  } \
485  if (flags & SHOW_CONFIG) { \
486  const char *cfg = libname##_configuration(); \
487  if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
488  if (!warned_cfg) { \
489  av_log(NULL, level, \
490  "%sWARNING: library configuration mismatch\n", \
491  indent); \
492  warned_cfg = 1; \
493  } \
494  av_log(NULL, level, "%s%-11s configuration: %s\n", \
495  indent, #libname, cfg); \
496  } \
497  } \
498  } \
499 
500 static void print_all_libs_info(int flags, int level)
501 {
502  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
503  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
504  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
505  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
506  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
507  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
508 #if CONFIG_POSTPROC
509  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
510 #endif
511 }
512 
513 void show_banner(void)
514 {
516  "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
518  av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
519  __DATE__, __TIME__, CC_TYPE, CC_VERSION);
520  av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
523 }
524 
525 void show_version(void) {
527  printf("%s " LIBAV_VERSION "\n", program_name);
529 }
530 
531 void show_license(void)
532 {
533  printf(
534 #if CONFIG_NONFREE
535  "This version of %s has nonfree parts compiled in.\n"
536  "Therefore it is not legally redistributable.\n",
538 #elif CONFIG_GPLV3
539  "%s is free software; you can redistribute it and/or modify\n"
540  "it under the terms of the GNU General Public License as published by\n"
541  "the Free Software Foundation; either version 3 of the License, or\n"
542  "(at your option) any later version.\n"
543  "\n"
544  "%s is distributed in the hope that it will be useful,\n"
545  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
546  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
547  "GNU General Public License for more details.\n"
548  "\n"
549  "You should have received a copy of the GNU General Public License\n"
550  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
552 #elif CONFIG_GPL
553  "%s is free software; you can redistribute it and/or modify\n"
554  "it under the terms of the GNU General Public License as published by\n"
555  "the Free Software Foundation; either version 2 of the License, or\n"
556  "(at your option) any later version.\n"
557  "\n"
558  "%s is distributed in the hope that it will be useful,\n"
559  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
560  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
561  "GNU General Public License for more details.\n"
562  "\n"
563  "You should have received a copy of the GNU General Public License\n"
564  "along with %s; if not, write to the Free Software\n"
565  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
567 #elif CONFIG_LGPLV3
568  "%s is free software; you can redistribute it and/or modify\n"
569  "it under the terms of the GNU Lesser General Public License as published by\n"
570  "the Free Software Foundation; either version 3 of the License, or\n"
571  "(at your option) any later version.\n"
572  "\n"
573  "%s is distributed in the hope that it will be useful,\n"
574  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
575  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
576  "GNU Lesser General Public License for more details.\n"
577  "\n"
578  "You should have received a copy of the GNU Lesser General Public License\n"
579  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
581 #else
582  "%s is free software; you can redistribute it and/or\n"
583  "modify it under the terms of the GNU Lesser General Public\n"
584  "License as published by the Free Software Foundation; either\n"
585  "version 2.1 of the License, or (at your option) any later version.\n"
586  "\n"
587  "%s is distributed in the hope that it will be useful,\n"
588  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
589  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
590  "Lesser General Public License for more details.\n"
591  "\n"
592  "You should have received a copy of the GNU Lesser General Public\n"
593  "License along with %s; if not, write to the Free Software\n"
594  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
596 #endif
597  );
598 }
599 
600 void show_formats(void)
601 {
602  AVInputFormat *ifmt = NULL;
603  AVOutputFormat *ofmt = NULL;
604  const char *last_name;
605 
606  printf("File formats:\n"
607  " D. = Demuxing supported\n"
608  " .E = Muxing supported\n"
609  " --\n");
610  last_name = "000";
611  for (;;) {
612  int decode = 0;
613  int encode = 0;
614  const char *name = NULL;
615  const char *long_name = NULL;
616 
617  while ((ofmt = av_oformat_next(ofmt))) {
618  if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
619  strcmp(ofmt->name, last_name) > 0) {
620  name = ofmt->name;
621  long_name = ofmt->long_name;
622  encode = 1;
623  }
624  }
625  while ((ifmt = av_iformat_next(ifmt))) {
626  if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
627  strcmp(ifmt->name, last_name) > 0) {
628  name = ifmt->name;
629  long_name = ifmt->long_name;
630  encode = 0;
631  }
632  if (name && strcmp(ifmt->name, name) == 0)
633  decode = 1;
634  }
635  if (name == NULL)
636  break;
637  last_name = name;
638 
639  printf(" %s%s %-15s %s\n",
640  decode ? "D" : " ",
641  encode ? "E" : " ",
642  name,
643  long_name ? long_name:" ");
644  }
645 }
646 
647 void show_codecs(void)
648 {
649  AVCodec *p = NULL, *p2;
650  const char *last_name;
651  printf("Codecs:\n"
652  " D..... = Decoding supported\n"
653  " .E.... = Encoding supported\n"
654  " ..V... = Video codec\n"
655  " ..A... = Audio codec\n"
656  " ..S... = Subtitle codec\n"
657  " ...S.. = Supports draw_horiz_band\n"
658  " ....D. = Supports direct rendering method 1\n"
659  " .....T = Supports weird frame truncation\n"
660  " ------\n");
661  last_name= "000";
662  for (;;) {
663  int decode = 0;
664  int encode = 0;
665  int cap = 0;
666  const char *type_str;
667 
668  p2 = NULL;
669  while ((p = av_codec_next(p))) {
670  if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
671  strcmp(p->name, last_name) > 0) {
672  p2 = p;
673  decode = encode = cap = 0;
674  }
675  if (p2 && strcmp(p->name, p2->name) == 0) {
676  if (p->decode)
677  decode = 1;
678  if (p->encode)
679  encode = 1;
680  cap |= p->capabilities;
681  }
682  }
683  if (p2 == NULL)
684  break;
685  last_name = p2->name;
686 
687  switch (p2->type) {
688  case AVMEDIA_TYPE_VIDEO:
689  type_str = "V";
690  break;
691  case AVMEDIA_TYPE_AUDIO:
692  type_str = "A";
693  break;
695  type_str = "S";
696  break;
697  default:
698  type_str = "?";
699  break;
700  }
701  printf(" %s%s%s%s%s%s %-15s %s",
702  decode ? "D" : (/* p2->decoder ? "d" : */ " "),
703  encode ? "E" : " ",
704  type_str,
705  cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
706  cap & CODEC_CAP_DR1 ? "D" : " ",
707  cap & CODEC_CAP_TRUNCATED ? "T" : " ",
708  p2->name,
709  p2->long_name ? p2->long_name : "");
710 #if 0
711  if (p2->decoder && decode == 0)
712  printf(" use %s for decoding", p2->decoder->name);
713 #endif
714  printf("\n");
715  }
716  printf("\n");
717  printf("Note, the names of encoders and decoders do not always match, so there are\n"
718  "several cases where the above table shows encoder only or decoder only entries\n"
719  "even though both encoding and decoding are supported. For example, the h263\n"
720  "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
721  "worse.\n");
722 }
723 
724 void show_bsfs(void)
725 {
726  AVBitStreamFilter *bsf = NULL;
727 
728  printf("Bitstream filters:\n");
729  while ((bsf = av_bitstream_filter_next(bsf)))
730  printf("%s\n", bsf->name);
731  printf("\n");
732 }
733 
734 void show_protocols(void)
735 {
736  void *opaque = NULL;
737  const char *name;
738 
739  printf("Supported file protocols:\n"
740  "Input:\n");
741  while ((name = avio_enum_protocols(&opaque, 0)))
742  printf("%s\n", name);
743  printf("Output:\n");
744  while ((name = avio_enum_protocols(&opaque, 1)))
745  printf("%s\n", name);
746 }
747 
748 void show_filters(void)
749 {
751 
752  printf("Filters:\n");
753 #if CONFIG_AVFILTER
754  while ((filter = av_filter_next(filter)) && *filter)
755  printf("%-16s %s\n", (*filter)->name, (*filter)->description);
756 #endif
757 }
758 
759 void show_pix_fmts(void)
760 {
761  enum PixelFormat pix_fmt;
762 
763  printf("Pixel formats:\n"
764  "I.... = Supported Input format for conversion\n"
765  ".O... = Supported Output format for conversion\n"
766  "..H.. = Hardware accelerated format\n"
767  "...P. = Paletted format\n"
768  "....B = Bitstream format\n"
769  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
770  "-----\n");
771 
772 #if !CONFIG_SWSCALE
773 # define sws_isSupportedInput(x) 0
774 # define sws_isSupportedOutput(x) 0
775 #endif
776 
777  for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
779  printf("%c%c%c%c%c %-16s %d %2d\n",
780  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
781  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
782  pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
783  pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
784  pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
785  pix_desc->name,
786  pix_desc->nb_components,
787  av_get_bits_per_pixel(pix_desc));
788  }
789 }
790 
791 int show_sample_fmts(const char *opt, const char *arg)
792 {
793  int i;
794  char fmt_str[128];
795  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
796  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
797  return 0;
798 }
799 
800 int read_yesno(void)
801 {
802  int c = getchar();
803  int yesno = (toupper(c) == 'Y');
804 
805  while (c != '\n' && c != EOF)
806  c = getchar();
807 
808  return yesno;
809 }
810 
811 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
812 {
813  int ret;
814  FILE *f = fopen(filename, "rb");
815 
816  if (!f) {
817  av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
818  strerror(errno));
819  return AVERROR(errno);
820  }
821  fseek(f, 0, SEEK_END);
822  *size = ftell(f);
823  fseek(f, 0, SEEK_SET);
824  *bufptr = av_malloc(*size + 1);
825  if (!*bufptr) {
826  av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
827  fclose(f);
828  return AVERROR(ENOMEM);
829  }
830  ret = fread(*bufptr, 1, *size, f);
831  if (ret < *size) {
832  av_free(*bufptr);
833  if (ferror(f)) {
834  av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
835  filename, strerror(errno));
836  ret = AVERROR(errno);
837  } else
838  ret = AVERROR_EOF;
839  } else {
840  ret = 0;
841  (*bufptr)[*size++] = '\0';
842  }
843 
844  fclose(f);
845  return ret;
846 }
847 
849 {
850  ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
851  ctx->last_pts = ctx->last_dts = INT64_MIN;
852 }
853 
854 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
855  int64_t dts)
856 {
857  int64_t pts = AV_NOPTS_VALUE;
858 
859  if (dts != AV_NOPTS_VALUE) {
860  ctx->num_faulty_dts += dts <= ctx->last_dts;
861  ctx->last_dts = dts;
862  }
863  if (reordered_pts != AV_NOPTS_VALUE) {
864  ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
865  ctx->last_pts = reordered_pts;
866  }
867  if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
868  && reordered_pts != AV_NOPTS_VALUE)
869  pts = reordered_pts;
870  else
871  pts = dts;
872 
873  return pts;
874 }
875 
876 FILE *get_preset_file(char *filename, size_t filename_size,
877  const char *preset_name, int is_path,
878  const char *codec_name)
879 {
880  FILE *f = NULL;
881  int i;
882  const char *base[3] = { getenv("AVCONV_DATADIR"),
883  getenv("HOME"),
884  AVCONV_DATADIR, };
885 
886  if (is_path) {
887  av_strlcpy(filename, preset_name, filename_size);
888  f = fopen(filename, "r");
889  } else {
890  for (i = 0; i < 3 && !f; i++) {
891  if (!base[i])
892  continue;
893  snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
894  i != 1 ? "" : "/.avconv", preset_name);
895  f = fopen(filename, "r");
896  if (!f && codec_name) {
897  snprintf(filename, filename_size,
898  "%s%s/%s-%s.avpreset",
899  base[i], i != 1 ? "" : "/.avconv", codec_name,
900  preset_name);
901  f = fopen(filename, "r");
902  }
903  }
904  }
905 
906  return f;
907 }
908 
909 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
910 {
911  if (*spec <= '9' && *spec >= '0') /* opt:index */
912  return strtol(spec, NULL, 0) == st->index;
913  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
914  *spec == 't') { /* opt:[vasdt] */
915  enum AVMediaType type;
916 
917  switch (*spec++) {
918  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
919  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
920  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
921  case 'd': type = AVMEDIA_TYPE_DATA; break;
922  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
923  }
924  if (type != st->codec->codec_type)
925  return 0;
926  if (*spec++ == ':') { /* possibly followed by :index */
927  int i, index = strtol(spec, NULL, 0);
928  for (i = 0; i < s->nb_streams; i++)
929  if (s->streams[i]->codec->codec_type == type && index-- == 0)
930  return i == st->index;
931  return 0;
932  }
933  return 1;
934  } else if (*spec == 'p' && *(spec + 1) == ':') {
935  int prog_id, i, j;
936  char *endptr;
937  spec += 2;
938  prog_id = strtol(spec, &endptr, 0);
939  for (i = 0; i < s->nb_programs; i++) {
940  if (s->programs[i]->id != prog_id)
941  continue;
942 
943  if (*endptr++ == ':') {
944  int stream_idx = strtol(endptr, NULL, 0);
945  return stream_idx >= 0 &&
946  stream_idx < s->programs[i]->nb_stream_indexes &&
947  st->index == s->programs[i]->stream_index[stream_idx];
948  }
949 
950  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
951  if (st->index == s->programs[i]->stream_index[j])
952  return 1;
953  }
954  return 0;
955  } else if (!*spec) /* empty specifier, matches everything */
956  return 1;
957 
958  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
959  return AVERROR(EINVAL);
960 }
961 
963  AVFormatContext *s, AVStream *st)
964 {
965  AVDictionary *ret = NULL;
967  AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
968  : avcodec_find_decoder(codec_id);
971  char prefix = 0;
972  const AVClass *cc = avcodec_get_class();
973 
974  if (!codec)
975  return NULL;
976 
977  switch (codec->type) {
978  case AVMEDIA_TYPE_VIDEO:
979  prefix = 'v';
980  flags |= AV_OPT_FLAG_VIDEO_PARAM;
981  break;
982  case AVMEDIA_TYPE_AUDIO:
983  prefix = 'a';
984  flags |= AV_OPT_FLAG_AUDIO_PARAM;
985  break;
987  prefix = 's';
989  break;
990  }
991 
992  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
993  char *p = strchr(t->key, ':');
994 
995  /* check stream specification in opt name */
996  if (p)
997  switch (check_stream_specifier(s, st, p + 1)) {
998  case 1: *p = 0; break;
999  case 0: continue;
1000  default: return NULL;
1001  }
1002 
1003  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1004  (codec && codec->priv_class &&
1005  av_opt_find(&codec->priv_class, t->key, NULL, flags,
1007  av_dict_set(&ret, t->key, t->value, 0);
1008  else if (t->key[0] == prefix &&
1009  av_opt_find(&cc, t->key + 1, NULL, flags,
1011  av_dict_set(&ret, t->key + 1, t->value, 0);
1012 
1013  if (p)
1014  *p = ':';
1015  }
1016  return ret;
1017 }
1018 
1020  AVDictionary *codec_opts)
1021 {
1022  int i;
1023  AVDictionary **opts;
1024 
1025  if (!s->nb_streams)
1026  return NULL;
1027  opts = av_mallocz(s->nb_streams * sizeof(*opts));
1028  if (!opts) {
1030  "Could not alloc memory for stream options.\n");
1031  return NULL;
1032  }
1033  for (i = 0; i < s->nb_streams; i++)
1034  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1035  s, s->streams[i]);
1036  return opts;
1037 }
1038 
1039 #if CONFIG_AVFILTER
1040 
1041 static int avsink_init(AVFilterContext *ctx, const char *args, void *opaque)
1042 {
1043  AVSinkContext *priv = ctx->priv;
1044 
1045  if (!opaque)
1046  return AVERROR(EINVAL);
1047  *priv = *(AVSinkContext *)opaque;
1048 
1049  return 0;
1050 }
1051 
1052 static void null_end_frame(AVFilterLink *inlink) { }
1053 
1054 static int avsink_query_formats(AVFilterContext *ctx)
1055 {
1056  AVSinkContext *priv = ctx->priv;
1057  enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1058 
1060  return 0;
1061 }
1062 
1063 AVFilter avsink = {
1064  .name = "avsink",
1065  .priv_size = sizeof(AVSinkContext),
1066  .init = avsink_init,
1067 
1068  .query_formats = avsink_query_formats,
1069 
1070  .inputs = (AVFilterPad[]) {{ .name = "default",
1071  .type = AVMEDIA_TYPE_VIDEO,
1072  .end_frame = null_end_frame,
1073  .min_perms = AV_PERM_READ, },
1074  { .name = NULL }},
1075  .outputs = (AVFilterPad[]) {{ .name = NULL }},
1076 };
1077 
1079  AVFilterBufferRef **picref_ptr, AVRational *tb)
1080 {
1081  int ret;
1082  AVFilterBufferRef *picref;
1083 
1084  if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1085  return ret;
1086  if (!(picref = ctx->inputs[0]->cur_buf))
1087  return AVERROR(ENOENT);
1088  *picref_ptr = picref;
1089  ctx->inputs[0]->cur_buf = NULL;
1090  *tb = ctx->inputs[0]->time_base;
1091 
1092  memcpy(frame->data, picref->data, sizeof(frame->data));
1093  memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1094  frame->interlaced_frame = picref->video->interlaced;
1095  frame->top_field_first = picref->video->top_field_first;
1096  frame->key_frame = picref->video->key_frame;
1097  frame->pict_type = picref->video->pict_type;
1098  frame->sample_aspect_ratio = picref->video->pixel_aspect;
1099 
1100  return 1;
1101 }
1102 
1103 #endif /* CONFIG_AVFILTER */
1104 
1105 void *grow_array(void *array, int elem_size, int *size, int new_size)
1106 {
1107  if (new_size >= INT_MAX / elem_size) {
1108  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1109  exit_program(1);
1110  }
1111  if (*size < new_size) {
1112  uint8_t *tmp = av_realloc(array, new_size*elem_size);
1113  if (!tmp) {
1114  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1115  exit_program(1);
1116  }
1117  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1118  *size = new_size;
1119  return tmp;
1120  }
1121  return array;
1122 }
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:41
#define LIBAV_VERSION
Definition: version.h:1
int64_t num_faulty_dts
Number of incorrect PTS values so far.
Definition: cmdutils.h:322
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:154
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:278
int size
Audio Video Frame.
Definition: avcodec.h:985
#define FLAGS
Definition: cmdutils.c:366
int64_t num_faulty_pts
Definition: cmdutils.h:321
AVOption.
Definition: opt.h:244
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:98
int opt_loglevel(const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: cmdutils.c:407
AVFilterBufferRefVideoProps * video
video buffer specific properties
Definition: avfilter.h:141
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:277
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:1431
AVCodec * avcodec_find_encoder(enum CodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1327
int linesize[8]
number of bytes per line
Definition: avfilter.h:127
#define AVCONV_DATADIR
Definition: config.h:6
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:483
void show_banner(void)
Print the program banner to stderr.
Definition: cmdutils.c:513
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:1135
const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:797
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:117
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:909
#define INDENT
Definition: cmdutils.c:469
enum PixelFormat pix_fmt
Definition: v4l.c:65
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:275
int index
stream index in AVFormatContext
Definition: avformat.h:621
AVOptions.
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
Definition: pixfmt.h:160
AVCodec * avcodec_find_decoder(enum CodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1357
int64_t last_pts
Number of incorrect DTS values so far.
Definition: cmdutils.h:323
enum AVMediaType type
Definition: avcodec.h:3197
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:117
#define FF_ARRAY_ELEMS(a)
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3203
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Definition: log.c:172
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:274
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:27
int id
Definition: avformat.h:836
#define OPT_DOUBLE
Definition: cmdutils.h:146
#define OPT_FLOAT
Definition: cmdutils.h:135
AVCodec.
Definition: avcodec.h:3189
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:71
void init_pts_correction(PtsCorrectionContext *ctx)
Reset the state of the PtsCorrectionContext.
Definition: cmdutils.c:848
static void null_end_frame(AVFilterLink *inlink)
Definition: vf_overlay.c:346
Format I/O context.
Definition: avformat.h:863
#define AV_PERM_READ
can read from the buffer
Definition: avfilter.h:81
unsigned int nb_stream_indexes
Definition: avformat.h:840
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:547
static int warned_cfg
Definition: cmdutils.c:467
Public dictionary API.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:78
AVBitStreamFilter * av_bitstream_filter_next(AVBitStreamFilter *f)
#define INT64_MIN
Definition: internal.h:76
Opaque data information usually continuous.
Definition: avutil.h:232
#define HAS_ARG
Definition: cmdutils.h:127
int top_field_first
field order
Definition: avfilter.h:111
void show_formats(void)
Print a listing containing all the formats supported by the program.
Definition: cmdutils.c:600
#define OPT_OFFSET
Definition: cmdutils.h:141
#define AV_LOG_QUIET
Definition: log.h:93
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
Definition: cmdutils.c:116
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:60
AVStream ** streams
Definition: avformat.h:908
int(* func2_arg)(void *, const char *, const char *)
Definition: cmdutils.h:150
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:105
const char * name
Definition: avcodec.h:4610
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:297
int key_frame
1 -> keyframe, 0-> not
Definition: avfilter.h:113
static int flags
Definition: log.c:34
#define OPT_SPEC
Definition: cmdutils.h:142
static void print_all_libs_info(int flags, int level)
Definition: cmdutils.c:500
#define AVERROR_EOF
End of file.
Definition: error.h:51
AVFilter avsink
int interlaced_frame
The content of the picture is interlaced.
Definition: avcodec.h:1167
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:155
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:357
external api for the swscale stuff
unsigned int * stream_index
Definition: avformat.h:839
AVRational pixel_aspect
pixel aspect ratio
Definition: avfilter.h:109
static float t
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
struct AVOutputFormat * oformat
Definition: avformat.h:877
const char * name
Definition: pixdesc.h:56
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1019
AVDictionary * format_opts
Definition: cmdutils.c:56
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
A filter pad used for either input or output.
Definition: avfilter.h:312
Main libavdevice API header.
enum CodecID codec_id
Definition: mov_chan.c:417
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:137
void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: defaults.c:234
static const uint16_t mask[17]
Definition: lzw.c:36
#define AVERROR(e)
Definition: error.h:43
#define SWS_BICUBIC
Definition: swscale.h:77
#define CC_VERSION
Definition: config.h:8
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:396
#define sws_isSupportedOutput(x)
#define OPT_FUNC2
Definition: cmdutils.h:140
#define CODEC_CAP_TRUNCATED
Definition: avcodec.h:724
struct SwsContext * sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat, int dstW, int dstH, enum PixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:1106
#define CONFIG_GPLV3
Definition: config.h:252
void * priv
private data for use by the filter
Definition: avfilter.h:553
int capabilities
Codec capabilities.
Definition: avcodec.h:3208
unsigned int nb_programs
Definition: avformat.h:1024
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:100
const char * name
Definition: cmdutils.h:125
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:224
#define PIX_FMT_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:87
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
AVFilterFormats * avfilter_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:90
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
int(* encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data)
Definition: avcodec.h:3201
int flags
Definition: cmdutils.h:126
void av_log_set_level(int level)
Definition: log.c:162
const AVPixFmtDescriptor av_pix_fmt_descriptors[PIX_FMT_NB]
The array of all the pixel format descriptors.
Definition: pixdesc.c:119
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:64
#define CONFIG_LGPLV3
Definition: config.h:253
static const OptionDef * find_option(const OptionDef *po, const char *name)
Definition: cmdutils.c:150
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
Definition: cmdutils.c:854
AVCodecContext * codec
codec context
Definition: avformat.h:623
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:747
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:311
unsigned int nb_streams
A list of all streams in the file.
Definition: avformat.h:907
#define AV_LOG_VERBOSE
Definition: log.h:120
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:57
size_t off
Definition: cmdutils.h:151
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1029
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:691
#define FFMIN(a, b)
Definition: common.h:55
int(* func_arg)(const char *, const char *)
Definition: cmdutils.h:149
#define f(n)
Definition: regs.h:33
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:447
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: avio.c:99
const char * name
Definition: avformat.h:390
#define OPT_EXIT
Definition: cmdutils.h:138
#define PIX_FMT_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:88
#define OPT_INT64
Definition: cmdutils.h:137
void exit_program(int ret)
Do all the necessary cleanup and abort.
Definition: avconv.c:663
#define sws_isSupportedInput(x)
AVFilter ** av_filter_next(AVFilter **filter)
If filter is NULL, returns a pointer to the first registered filter pointer, if filter is non-NULL...
Definition: avfilter.c:550
void show_version(void)
Print the version of the program to stdout.
Definition: cmdutils.c:525
Opaque data information usually sparse.
Definition: avutil.h:234
void * dst_ptr
Definition: cmdutils.h:148
void show_pix_fmts(void)
Print a listing containing all the pixel formats supported by the program.
Definition: cmdutils.c:759
AVOutputFormat * av_oformat_next(AVOutputFormat *f)
If f is NULL, returns the first registered output format, if f is non-NULL, returns the next register...
Definition: utils.c:133
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:467
#define CONFIG_GPL
Definition: config.h:191
Stream structure.
Definition: avformat.h:620
void show_filters(void)
Print a listing containing all the filters supported by the program.
Definition: cmdutils.c:748
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:75
A reference to an AVFilterBuffer.
Definition: avfilter.h:124
external postprocessing API
void show_license(void)
Print the license of the program to stdout.
Definition: cmdutils.c:531
#define PIX_FMT_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:89
NULL
Definition: eval.c:50
int opt_timelimit(const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:442
enum AVMediaType codec_type
Definition: avcodec.h:1574
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:162
AVDictionary * filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
Filter out options for given codec.
Definition: cmdutils.c:962
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:586
const char * help
Definition: cmdutils.h:153
uint8_t flags
Definition: pixdesc.h:76
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:55
static const OptionDef options[]
Definition: avconv.c:105
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:279
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:62
AVRational sample_aspect_ratio
sample aspect ratio for the video frame, 0/1 if unknown
Definition: avcodec.h:1292
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: avconv.c:85
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
enum PixelFormat pix_fmt
Definition: cmdutils.h:365
#define INT64_MAX
Definition: internal.h:80
static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
Definition: cmdutils.c:331
#define CONFIG_NONFREE
Definition: config.h:229
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:50
#define SHOW_VERSION
Definition: cmdutils.c:470
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:876
int get_filtered_video_frame(AVFilterContext *sink, AVFrame *frame, AVFilterBufferRef **picref, AVRational *pts_tb)
Extract a frame from sink.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:64
enum AVPictureType pict_type
picture type of the frame
Definition: avfilter.h:112
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)
Definition: cmdutils.c:473
Describe the class of an AVClass context structure.
Definition: log.h:33
Filter definition.
Definition: avfilter.h:497
int index
Definition: gxfenc.c:73
#define CODEC_CAP_DRAW_HORIZ_BAND
Definition: avcodec.h:713
#define CC_TYPE
Definition: config.h:7
rational number numerator/denominator
Definition: rational.h:43
const char program_name[]
program name, defined by the program for show_version().
Definition: avconv.c:84
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:104
#define printf
Definition: internal.h:151
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:1105
const char * argname
Definition: cmdutils.h:154
#define OPT_STRING
Definition: cmdutils.h:130
struct SwsContext * sws_opts
Definition: cmdutils.c:55
int avfilter_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:369
AVMediaType
Definition: avutil.h:228
const char * name
filter name
Definition: avfilter.h:498
int64_t last_dts
PTS of the last frame.
Definition: cmdutils.h:324
void show_protocols(void)
Print a listing containing all the protocols supported by the program.
Definition: cmdutils.c:734
misc parsing utilities
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:74
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:83
#define OPT_TIME
Definition: cmdutils.h:145
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:811
#define perror
Definition: internal.h:157
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3226
uint8_t level
Definition: svq3.c:123
const char * name
Definition: audioconvert.c:61
static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:22
#define OPT_BOOL
Definition: cmdutils.h:128
PixelFormat
Pixel format.
Definition: pixfmt.h:62
Main libavformat public API header.
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:455
static const int this_year
Definition: cmdutils.c:58
#define OPT_INT
Definition: cmdutils.h:134
AVDictionary * codec_opts
Definition: cmdutils.c:56
int interlaced
is frame interlaced
Definition: avfilter.h:110
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:125
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poi...
Definition: opt.h:456
AVCodec * av_codec_next(AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
Definition: utils.c:86
char * key
Definition: dict.h:75
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents...
Definition: cmdutils.c:68
union OptionDef::@2 u
AVInputFormat * av_iformat_next(AVInputFormat *f)
If f is NULL, returns the first registered input format, if f is non-NULL, returns the next registere...
Definition: utils.c:127
CodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:83
#define AVUNERROR(e)
Definition: error.h:44
void show_bsfs(void)
Print a listing containing all the bit stream filters supported by the program.
Definition: cmdutils.c:724
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:56
char * value
Definition: dict.h:76
int show_sample_fmts(const char *opt, const char *arg)
Print a listing containing all the sample formats supported by the program.
Definition: cmdutils.c:791
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: avcodec.h:1174
#define SHOW_CONFIG
Definition: cmdutils.c:471
int len
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
Definition: cmdutils.c:218
uint8_t * data[8]
picture/audio data for each plane
Definition: avfilter.h:126
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1022
int opt_default(const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:367
#define LIBAV_CONFIGURATION
Definition: config.h:4
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:140
An instance of a filter.
Definition: avfilter.h:538
void show_codecs(void)
Print a listing containing all the codecs supported by the program.
Definition: cmdutils.c:647
#define AV_LOG_INFO
Definition: log.h:119
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0...
Definition: cmdutils.c:800
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:460
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
#define INFINITY
Definition: mathematics.h:57
float min
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:227
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:271
#define av_unused
Definition: attributes.h:95
AVProgram ** programs
Definition: avformat.h:1025
simple arithmetic expression evaluator
enum CodecID codec_id
Definition: avcodec.h:1575