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(), *sc = sws_get_class();
373 
374  if (!(p = strchr(opt, ':')))
375  p = opt + strlen(opt);
376  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
377 
378  if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
380  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
381  (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
382  av_dict_set(&codec_opts, opt, arg, FLAGS);
383  else if ((o = av_opt_find(&fc, opt, NULL, 0,
385  av_dict_set(&format_opts, opt, arg, FLAGS);
386  else if ((o = av_opt_find(&sc, opt, NULL, 0,
388  // XXX we only support sws_flags, not arbitrary sws options
389  int ret = av_opt_set(sws_opts, opt, arg, 0);
390  if (ret < 0) {
391  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
392  return ret;
393  }
394  }
395 
396  if (o)
397  return 0;
398  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
400 }
401 
402 int opt_loglevel(const char *opt, const char *arg)
403 {
404  const struct { const char *name; int level; } log_levels[] = {
405  { "quiet" , AV_LOG_QUIET },
406  { "panic" , AV_LOG_PANIC },
407  { "fatal" , AV_LOG_FATAL },
408  { "error" , AV_LOG_ERROR },
409  { "warning", AV_LOG_WARNING },
410  { "info" , AV_LOG_INFO },
411  { "verbose", AV_LOG_VERBOSE },
412  { "debug" , AV_LOG_DEBUG },
413  };
414  char *tail;
415  int level;
416  int i;
417 
418  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
419  if (!strcmp(log_levels[i].name, arg)) {
420  av_log_set_level(log_levels[i].level);
421  return 0;
422  }
423  }
424 
425  level = strtol(arg, &tail, 10);
426  if (*tail) {
427  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
428  "Possible levels are numbers or:\n", arg);
429  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
430  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
431  exit_program(1);
432  }
433  av_log_set_level(level);
434  return 0;
435 }
436 
437 int opt_timelimit(const char *opt, const char *arg)
438 {
439 #if HAVE_SETRLIMIT
440  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
441  struct rlimit rl = { lim, lim + 1 };
442  if (setrlimit(RLIMIT_CPU, &rl))
443  perror("setrlimit");
444 #else
445  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
446 #endif
447  return 0;
448 }
449 
450 void print_error(const char *filename, int err)
451 {
452  char errbuf[128];
453  const char *errbuf_ptr = errbuf;
454 
455  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
456  errbuf_ptr = strerror(AVUNERROR(err));
457  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
458 }
459 
460 // Debian/Ubuntu: see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=619530
461 // https://launchpad.net/bugs/765357
462 static int warned_cfg = 1;
463 
464 #define INDENT 1
465 #define SHOW_VERSION 2
466 #define SHOW_CONFIG 4
467 
468 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
469  if (CONFIG_##LIBNAME) { \
470  const char *indent = flags & INDENT? " " : ""; \
471  if (flags & SHOW_VERSION) { \
472  unsigned int version = libname##_version(); \
473  av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
474  indent, #libname, \
475  LIB##LIBNAME##_VERSION_MAJOR, \
476  LIB##LIBNAME##_VERSION_MINOR, \
477  LIB##LIBNAME##_VERSION_MICRO, \
478  version >> 16, version >> 8 & 0xff, version & 0xff); \
479  } \
480  if (flags & SHOW_CONFIG) { \
481  const char *cfg = libname##_configuration(); \
482  if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
483  if (!warned_cfg) { \
484  av_log(NULL, level, \
485  "%sWARNING: library configuration mismatch\n", \
486  indent); \
487  warned_cfg = 1; \
488  } \
489  av_log(NULL, level, "%s%-11s configuration: %s\n", \
490  indent, #libname, cfg); \
491  } \
492  } \
493  } \
494 
495 static void print_all_libs_info(int flags, int level)
496 {
497  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
498  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
499  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
500  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
501  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
502  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
503 #if CONFIG_POSTPROC
504  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
505 #endif
506 }
507 
508 void show_banner(void)
509 {
511  "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
513  av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
514  __DATE__, __TIME__, CC_TYPE, CC_VERSION);
515  av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
518 }
519 
520 void show_version(void) {
522  printf("%s " LIBAV_VERSION "\n", program_name);
524 }
525 
526 void show_license(void)
527 {
528  printf(
529 #if CONFIG_NONFREE
530  "This version of %s has nonfree parts compiled in.\n"
531  "Therefore it is not legally redistributable.\n",
533 #elif CONFIG_GPLV3
534  "%s is free software; you can redistribute it and/or modify\n"
535  "it under the terms of the GNU General Public License as published by\n"
536  "the Free Software Foundation; either version 3 of the License, or\n"
537  "(at your option) any later version.\n"
538  "\n"
539  "%s is distributed in the hope that it will be useful,\n"
540  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
541  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
542  "GNU General Public License for more details.\n"
543  "\n"
544  "You should have received a copy of the GNU General Public License\n"
545  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
547 #elif CONFIG_GPL
548  "%s is free software; you can redistribute it and/or modify\n"
549  "it under the terms of the GNU General Public License as published by\n"
550  "the Free Software Foundation; either version 2 of the License, or\n"
551  "(at your option) any later version.\n"
552  "\n"
553  "%s is distributed in the hope that it will be useful,\n"
554  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
555  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
556  "GNU General Public License for more details.\n"
557  "\n"
558  "You should have received a copy of the GNU General Public License\n"
559  "along with %s; if not, write to the Free Software\n"
560  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
562 #elif CONFIG_LGPLV3
563  "%s is free software; you can redistribute it and/or modify\n"
564  "it under the terms of the GNU Lesser General Public License as published by\n"
565  "the Free Software Foundation; either version 3 of the License, or\n"
566  "(at your option) any later version.\n"
567  "\n"
568  "%s is distributed in the hope that it will be useful,\n"
569  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
570  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
571  "GNU Lesser General Public License for more details.\n"
572  "\n"
573  "You should have received a copy of the GNU Lesser General Public License\n"
574  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
576 #else
577  "%s is free software; you can redistribute it and/or\n"
578  "modify it under the terms of the GNU Lesser General Public\n"
579  "License as published by the Free Software Foundation; either\n"
580  "version 2.1 of the License, or (at your option) any later version.\n"
581  "\n"
582  "%s is distributed in the hope that it will be useful,\n"
583  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
584  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
585  "Lesser General Public License for more details.\n"
586  "\n"
587  "You should have received a copy of the GNU Lesser General Public\n"
588  "License along with %s; if not, write to the Free Software\n"
589  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
591 #endif
592  );
593 }
594 
595 void show_formats(void)
596 {
597  AVInputFormat *ifmt = NULL;
598  AVOutputFormat *ofmt = NULL;
599  const char *last_name;
600 
601  printf("File formats:\n"
602  " D. = Demuxing supported\n"
603  " .E = Muxing supported\n"
604  " --\n");
605  last_name = "000";
606  for (;;) {
607  int decode = 0;
608  int encode = 0;
609  const char *name = NULL;
610  const char *long_name = NULL;
611 
612  while ((ofmt = av_oformat_next(ofmt))) {
613  if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
614  strcmp(ofmt->name, last_name) > 0) {
615  name = ofmt->name;
616  long_name = ofmt->long_name;
617  encode = 1;
618  }
619  }
620  while ((ifmt = av_iformat_next(ifmt))) {
621  if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
622  strcmp(ifmt->name, last_name) > 0) {
623  name = ifmt->name;
624  long_name = ifmt->long_name;
625  encode = 0;
626  }
627  if (name && strcmp(ifmt->name, name) == 0)
628  decode = 1;
629  }
630  if (name == NULL)
631  break;
632  last_name = name;
633 
634  printf(" %s%s %-15s %s\n",
635  decode ? "D" : " ",
636  encode ? "E" : " ",
637  name,
638  long_name ? long_name:" ");
639  }
640 }
641 
642 void show_codecs(void)
643 {
644  AVCodec *p = NULL, *p2;
645  const char *last_name;
646  printf("Codecs:\n"
647  " D..... = Decoding supported\n"
648  " .E.... = Encoding supported\n"
649  " ..V... = Video codec\n"
650  " ..A... = Audio codec\n"
651  " ..S... = Subtitle codec\n"
652  " ...S.. = Supports draw_horiz_band\n"
653  " ....D. = Supports direct rendering method 1\n"
654  " .....T = Supports weird frame truncation\n"
655  " ------\n");
656  last_name= "000";
657  for (;;) {
658  int decode = 0;
659  int encode = 0;
660  int cap = 0;
661  const char *type_str;
662 
663  p2 = NULL;
664  while ((p = av_codec_next(p))) {
665  if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
666  strcmp(p->name, last_name) > 0) {
667  p2 = p;
668  decode = encode = cap = 0;
669  }
670  if (p2 && strcmp(p->name, p2->name) == 0) {
671  if (p->decode)
672  decode = 1;
673  if (p->encode)
674  encode = 1;
675  cap |= p->capabilities;
676  }
677  }
678  if (p2 == NULL)
679  break;
680  last_name = p2->name;
681 
682  switch (p2->type) {
683  case AVMEDIA_TYPE_VIDEO:
684  type_str = "V";
685  break;
686  case AVMEDIA_TYPE_AUDIO:
687  type_str = "A";
688  break;
690  type_str = "S";
691  break;
692  default:
693  type_str = "?";
694  break;
695  }
696  printf(" %s%s%s%s%s%s %-15s %s",
697  decode ? "D" : (/* p2->decoder ? "d" : */ " "),
698  encode ? "E" : " ",
699  type_str,
700  cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
701  cap & CODEC_CAP_DR1 ? "D" : " ",
702  cap & CODEC_CAP_TRUNCATED ? "T" : " ",
703  p2->name,
704  p2->long_name ? p2->long_name : "");
705 #if 0
706  if (p2->decoder && decode == 0)
707  printf(" use %s for decoding", p2->decoder->name);
708 #endif
709  printf("\n");
710  }
711  printf("\n");
712  printf("Note, the names of encoders and decoders do not always match, so there are\n"
713  "several cases where the above table shows encoder only or decoder only entries\n"
714  "even though both encoding and decoding are supported. For example, the h263\n"
715  "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
716  "worse.\n");
717 }
718 
719 void show_bsfs(void)
720 {
721  AVBitStreamFilter *bsf = NULL;
722 
723  printf("Bitstream filters:\n");
724  while ((bsf = av_bitstream_filter_next(bsf)))
725  printf("%s\n", bsf->name);
726  printf("\n");
727 }
728 
729 void show_protocols(void)
730 {
731  void *opaque = NULL;
732  const char *name;
733 
734  printf("Supported file protocols:\n"
735  "Input:\n");
736  while ((name = avio_enum_protocols(&opaque, 0)))
737  printf("%s\n", name);
738  printf("Output:\n");
739  while ((name = avio_enum_protocols(&opaque, 1)))
740  printf("%s\n", name);
741 }
742 
743 void show_filters(void)
744 {
746 
747  printf("Filters:\n");
748 #if CONFIG_AVFILTER
749  while ((filter = av_filter_next(filter)) && *filter)
750  printf("%-16s %s\n", (*filter)->name, (*filter)->description);
751 #endif
752 }
753 
754 void show_pix_fmts(void)
755 {
756  enum PixelFormat pix_fmt;
757 
758  printf("Pixel formats:\n"
759  "I.... = Supported Input format for conversion\n"
760  ".O... = Supported Output format for conversion\n"
761  "..H.. = Hardware accelerated format\n"
762  "...P. = Paletted format\n"
763  "....B = Bitstream format\n"
764  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
765  "-----\n");
766 
767 #if !CONFIG_SWSCALE
768 # define sws_isSupportedInput(x) 0
769 # define sws_isSupportedOutput(x) 0
770 #endif
771 
772  for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
774  printf("%c%c%c%c%c %-16s %d %2d\n",
775  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
776  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
777  pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
778  pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
779  pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
780  pix_desc->name,
781  pix_desc->nb_components,
782  av_get_bits_per_pixel(pix_desc));
783  }
784 }
785 
786 int show_sample_fmts(const char *opt, const char *arg)
787 {
788  int i;
789  char fmt_str[128];
790  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
791  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
792  return 0;
793 }
794 
795 int read_yesno(void)
796 {
797  int c = getchar();
798  int yesno = (toupper(c) == 'Y');
799 
800  while (c != '\n' && c != EOF)
801  c = getchar();
802 
803  return yesno;
804 }
805 
806 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
807 {
808  int ret;
809  FILE *f = fopen(filename, "rb");
810 
811  if (!f) {
812  av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
813  strerror(errno));
814  return AVERROR(errno);
815  }
816  fseek(f, 0, SEEK_END);
817  *size = ftell(f);
818  fseek(f, 0, SEEK_SET);
819  *bufptr = av_malloc(*size + 1);
820  if (!*bufptr) {
821  av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
822  fclose(f);
823  return AVERROR(ENOMEM);
824  }
825  ret = fread(*bufptr, 1, *size, f);
826  if (ret < *size) {
827  av_free(*bufptr);
828  if (ferror(f)) {
829  av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
830  filename, strerror(errno));
831  ret = AVERROR(errno);
832  } else
833  ret = AVERROR_EOF;
834  } else {
835  ret = 0;
836  (*bufptr)[*size++] = '\0';
837  }
838 
839  fclose(f);
840  return ret;
841 }
842 
844 {
845  ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
846  ctx->last_pts = ctx->last_dts = INT64_MIN;
847 }
848 
849 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
850  int64_t dts)
851 {
852  int64_t pts = AV_NOPTS_VALUE;
853 
854  if (dts != AV_NOPTS_VALUE) {
855  ctx->num_faulty_dts += dts <= ctx->last_dts;
856  ctx->last_dts = dts;
857  }
858  if (reordered_pts != AV_NOPTS_VALUE) {
859  ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
860  ctx->last_pts = reordered_pts;
861  }
862  if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
863  && reordered_pts != AV_NOPTS_VALUE)
864  pts = reordered_pts;
865  else
866  pts = dts;
867 
868  return pts;
869 }
870 
871 FILE *get_preset_file(char *filename, size_t filename_size,
872  const char *preset_name, int is_path,
873  const char *codec_name)
874 {
875  FILE *f = NULL;
876  int i;
877  const char *base[3] = { getenv("AVCONV_DATADIR"),
878  getenv("HOME"),
879  AVCONV_DATADIR, };
880 
881  if (is_path) {
882  av_strlcpy(filename, preset_name, filename_size);
883  f = fopen(filename, "r");
884  } else {
885  for (i = 0; i < 3 && !f; i++) {
886  if (!base[i])
887  continue;
888  snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
889  i != 1 ? "" : "/.avconv", preset_name);
890  f = fopen(filename, "r");
891  if (!f && codec_name) {
892  snprintf(filename, filename_size,
893  "%s%s/%s-%s.avpreset",
894  base[i], i != 1 ? "" : "/.avconv", codec_name,
895  preset_name);
896  f = fopen(filename, "r");
897  }
898  }
899  }
900 
901  return f;
902 }
903 
904 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
905 {
906  if (*spec <= '9' && *spec >= '0') /* opt:index */
907  return strtol(spec, NULL, 0) == st->index;
908  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
909  *spec == 't') { /* opt:[vasdt] */
910  enum AVMediaType type;
911 
912  switch (*spec++) {
913  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
914  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
915  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
916  case 'd': type = AVMEDIA_TYPE_DATA; break;
917  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
918  }
919  if (type != st->codec->codec_type)
920  return 0;
921  if (*spec++ == ':') { /* possibly followed by :index */
922  int i, index = strtol(spec, NULL, 0);
923  for (i = 0; i < s->nb_streams; i++)
924  if (s->streams[i]->codec->codec_type == type && index-- == 0)
925  return i == st->index;
926  return 0;
927  }
928  return 1;
929  } else if (*spec == 'p' && *(spec + 1) == ':') {
930  int prog_id, i, j;
931  char *endptr;
932  spec += 2;
933  prog_id = strtol(spec, &endptr, 0);
934  for (i = 0; i < s->nb_programs; i++) {
935  if (s->programs[i]->id != prog_id)
936  continue;
937 
938  if (*endptr++ == ':') {
939  int stream_idx = strtol(endptr, NULL, 0);
940  return stream_idx >= 0 &&
941  stream_idx < s->programs[i]->nb_stream_indexes &&
942  st->index == s->programs[i]->stream_index[stream_idx];
943  }
944 
945  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
946  if (st->index == s->programs[i]->stream_index[j])
947  return 1;
948  }
949  return 0;
950  } else if (!*spec) /* empty specifier, matches everything */
951  return 1;
952 
953  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
954  return AVERROR(EINVAL);
955 }
956 
958  AVFormatContext *s, AVStream *st)
959 {
960  AVDictionary *ret = NULL;
962  AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
963  : avcodec_find_decoder(codec_id);
966  char prefix = 0;
967  const AVClass *cc = avcodec_get_class();
968 
969  if (!codec)
970  return NULL;
971 
972  switch (codec->type) {
973  case AVMEDIA_TYPE_VIDEO:
974  prefix = 'v';
975  flags |= AV_OPT_FLAG_VIDEO_PARAM;
976  break;
977  case AVMEDIA_TYPE_AUDIO:
978  prefix = 'a';
979  flags |= AV_OPT_FLAG_AUDIO_PARAM;
980  break;
982  prefix = 's';
984  break;
985  }
986 
987  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
988  char *p = strchr(t->key, ':');
989 
990  /* check stream specification in opt name */
991  if (p)
992  switch (check_stream_specifier(s, st, p + 1)) {
993  case 1: *p = 0; break;
994  case 0: continue;
995  default: return NULL;
996  }
997 
998  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
999  (codec && codec->priv_class &&
1000  av_opt_find(&codec->priv_class, t->key, NULL, flags,
1002  av_dict_set(&ret, t->key, t->value, 0);
1003  else if (t->key[0] == prefix &&
1004  av_opt_find(&cc, t->key + 1, NULL, flags,
1006  av_dict_set(&ret, t->key + 1, t->value, 0);
1007 
1008  if (p)
1009  *p = ':';
1010  }
1011  return ret;
1012 }
1013 
1015  AVDictionary *codec_opts)
1016 {
1017  int i;
1018  AVDictionary **opts;
1019 
1020  if (!s->nb_streams)
1021  return NULL;
1022  opts = av_mallocz(s->nb_streams * sizeof(*opts));
1023  if (!opts) {
1025  "Could not alloc memory for stream options.\n");
1026  return NULL;
1027  }
1028  for (i = 0; i < s->nb_streams; i++)
1029  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1030  s, s->streams[i]);
1031  return opts;
1032 }
1033 
1034 #if CONFIG_AVFILTER
1035 
1036 static int avsink_init(AVFilterContext *ctx, const char *args, void *opaque)
1037 {
1038  AVSinkContext *priv = ctx->priv;
1039 
1040  if (!opaque)
1041  return AVERROR(EINVAL);
1042  *priv = *(AVSinkContext *)opaque;
1043 
1044  return 0;
1045 }
1046 
1047 static void null_end_frame(AVFilterLink *inlink) { }
1048 
1049 static int avsink_query_formats(AVFilterContext *ctx)
1050 {
1051  AVSinkContext *priv = ctx->priv;
1052  enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1053 
1055  return 0;
1056 }
1057 
1058 AVFilter avsink = {
1059  .name = "avsink",
1060  .priv_size = sizeof(AVSinkContext),
1061  .init = avsink_init,
1062 
1063  .query_formats = avsink_query_formats,
1064 
1065  .inputs = (AVFilterPad[]) {{ .name = "default",
1066  .type = AVMEDIA_TYPE_VIDEO,
1067  .end_frame = null_end_frame,
1068  .min_perms = AV_PERM_READ, },
1069  { .name = NULL }},
1070  .outputs = (AVFilterPad[]) {{ .name = NULL }},
1071 };
1072 
1074  AVFilterBufferRef **picref_ptr, AVRational *tb)
1075 {
1076  int ret;
1077  AVFilterBufferRef *picref;
1078 
1079  if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1080  return ret;
1081  if (!(picref = ctx->inputs[0]->cur_buf))
1082  return AVERROR(ENOENT);
1083  *picref_ptr = picref;
1084  ctx->inputs[0]->cur_buf = NULL;
1085  *tb = ctx->inputs[0]->time_base;
1086 
1087  memcpy(frame->data, picref->data, sizeof(frame->data));
1088  memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1089  frame->interlaced_frame = picref->video->interlaced;
1090  frame->top_field_first = picref->video->top_field_first;
1091  frame->key_frame = picref->video->key_frame;
1092  frame->pict_type = picref->video->pict_type;
1093  frame->sample_aspect_ratio = picref->video->pixel_aspect;
1094 
1095  return 1;
1096 }
1097 
1098 #endif /* CONFIG_AVFILTER */
1099 
1100 void *grow_array(void *array, int elem_size, int *size, int new_size)
1101 {
1102  if (new_size >= INT_MAX / elem_size) {
1103  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1104  exit_program(1);
1105  }
1106  if (*size < new_size) {
1107  uint8_t *tmp = av_realloc(array, new_size*elem_size);
1108  if (!tmp) {
1109  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1110  exit_program(1);
1111  }
1112  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1113  *size = new_size;
1114  return tmp;
1115  }
1116  return array;
1117 }