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 }