2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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. */
32 #include "libavformat/avformat.h"
33 #include "libavfilter/avfilter.h"
34 #include "libavdevice/avdevice.h"
35 #include "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libswresample/swresample.h"
39 #include "libpostproc/postprocess.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/parseutils.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/eval.h"
47 #include "libavutil/dict.h"
48 #include "libavutil/opt.h"
52 #include "libavformat/network.h"
54 #if HAVE_SYS_RESOURCE_H
55 #include <sys/resource.h>
58 struct SwsContext *sws_opts;
60 AVDictionary *format_opts, *codec_opts;
62 const int this_year = 2012;
64 static FILE *report_file;
69 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
72 swr_opts = swr_alloc();
75 void uninit_opts(void)
78 sws_freeContext(sws_opts);
82 av_dict_free(&format_opts);
83 av_dict_free(&codec_opts);
86 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
88 vfprintf(stdout, fmt, vl);
91 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
95 static int print_prefix = 1;
98 av_log_default_callback(ptr, level, fmt, vl);
99 av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
101 fputs(line, report_file);
105 double parse_number_or_die(const char *context, const char *numstr, int type,
106 double min, double max)
110 double d = av_strtod(numstr, &tail);
112 error = "Expected number for %s but found: %s\n";
113 else if (d < min || d > max)
114 error = "The value for %s was %s which is not within %f - %f\n";
115 else if (type == OPT_INT64 && (int64_t)d != d)
116 error = "Expected int64 for %s but found %s\n";
117 else if (type == OPT_INT && (int)d != d)
118 error = "Expected int for %s but found %s\n";
121 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
126 int64_t parse_time_or_die(const char *context, const char *timestr,
130 if (av_parse_time(&us, timestr, is_duration) < 0) {
131 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
132 is_duration ? "duration" : "date", context, timestr);
138 void show_help_options(const OptionDef *options, const char *msg, int mask,
145 for (po = options; po->name != NULL; po++) {
147 if ((po->flags & mask) == value) {
152 av_strlcpy(buf, po->name, sizeof(buf));
153 if (po->flags & HAS_ARG) {
154 av_strlcat(buf, " ", sizeof(buf));
155 av_strlcat(buf, po->argname, sizeof(buf));
157 printf("-%-17s %s\n", buf, po->help);
162 void show_help_children(const AVClass *class, int flags)
164 const AVClass *child = NULL;
165 av_opt_show2(&class, NULL, flags, 0);
168 while (child = av_opt_child_class_next(class, child))
169 show_help_children(child, flags);
172 static const OptionDef *find_option(const OptionDef *po, const char *name)
174 const char *p = strchr(name, ':');
175 int len = p ? p - name : strlen(name);
177 while (po->name != NULL) {
178 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
185 #if defined(_WIN32) && !defined(__MINGW32CE__)
187 /* Will be leaked on exit */
188 static char** win32_argv_utf8 = NULL;
189 static int win32_argc = 0;
192 * Prepare command line arguments for executable.
193 * For Windows - perform wide-char to UTF-8 conversion.
194 * Input arguments should be main() function arguments.
195 * @param argc_ptr Arguments number (including executable)
196 * @param argv_ptr Arguments list.
198 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
202 int i, buffsize = 0, offset = 0;
204 if (win32_argv_utf8) {
205 *argc_ptr = win32_argc;
206 *argv_ptr = win32_argv_utf8;
211 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
212 if (win32_argc <= 0 || !argv_w)
215 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
216 for (i = 0; i < win32_argc; i++)
217 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
218 NULL, 0, NULL, NULL);
220 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
221 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
222 if (win32_argv_utf8 == NULL) {
227 for (i = 0; i < win32_argc; i++) {
228 win32_argv_utf8[i] = &argstr_flat[offset];
229 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
230 &argstr_flat[offset],
231 buffsize - offset, NULL, NULL);
233 win32_argv_utf8[i] = NULL;
236 *argc_ptr = win32_argc;
237 *argv_ptr = win32_argv_utf8;
240 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
244 #endif /* WIN32 && !__MINGW32CE__ */
246 int parse_option(void *optctx, const char *opt, const char *arg,
247 const OptionDef *options)
254 po = find_option(options, opt);
255 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
256 /* handle 'no' bool option */
257 po = find_option(options, opt + 2);
258 if ((po->name && (po->flags & OPT_BOOL)))
262 po = find_option(options, "default");
264 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
265 return AVERROR(EINVAL);
267 if (po->flags & HAS_ARG && !arg) {
268 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
269 return AVERROR(EINVAL);
272 /* new-style options contain an offset into optctx, old-style address of
274 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
277 if (po->flags & OPT_SPEC) {
278 SpecifierOpt **so = dst;
279 char *p = strchr(opt, ':');
281 dstcount = (int *)(so + 1);
282 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
283 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
284 dst = &(*so)[*dstcount - 1].u;
287 if (po->flags & OPT_STRING) {
289 str = av_strdup(arg);
291 } else if (po->flags & OPT_BOOL) {
292 *(int *)dst = bool_val;
293 } else if (po->flags & OPT_INT) {
294 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
295 } else if (po->flags & OPT_INT64) {
296 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
297 } else if (po->flags & OPT_TIME) {
298 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
299 } else if (po->flags & OPT_FLOAT) {
300 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
301 } else if (po->flags & OPT_DOUBLE) {
302 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
303 } else if (po->u.func_arg) {
304 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
305 : po->u.func_arg(opt, arg);
307 av_log(NULL, AV_LOG_ERROR,
308 "Failed to set value '%s' for option '%s'\n", arg, opt);
312 if (po->flags & OPT_EXIT)
314 return !!(po->flags & HAS_ARG);
317 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
318 void (*parse_arg_function)(void *, const char*))
321 int optindex, handleoptions = 1, ret;
323 /* perform system-dependent conversions for arguments list */
324 prepare_app_arguments(&argc, &argv);
328 while (optindex < argc) {
329 opt = argv[optindex++];
331 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
332 if (opt[1] == '-' && opt[2] == '\0') {
338 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
342 if (parse_arg_function)
343 parse_arg_function(optctx, opt);
348 int locate_option(int argc, char **argv, const OptionDef *options,
354 for (i = 1; i < argc; i++) {
355 const char *cur_opt = argv[i];
357 if (*cur_opt++ != '-')
360 po = find_option(options, cur_opt);
361 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
362 po = find_option(options, cur_opt + 2);
364 if ((!po->name && !strcmp(cur_opt, optname)) ||
365 (po->name && !strcmp(optname, po->name)))
368 if (!po || po->flags & HAS_ARG)
374 static void dump_argument(const char *a)
376 const unsigned char *p;
379 if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
380 *p == '_' || (*p >= 'a' && *p <= 'z')))
383 fputs(a, report_file);
386 fputc('"', report_file);
387 for (p = a; *p; p++) {
388 if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
389 fprintf(report_file, "\\%c", *p);
390 else if (*p < ' ' || *p > '~')
391 fprintf(report_file, "\\x%02x", *p);
393 fputc(*p, report_file);
395 fputc('"', report_file);
398 void parse_loglevel(int argc, char **argv, const OptionDef *options)
400 int idx = locate_option(argc, argv, options, "loglevel");
402 idx = locate_option(argc, argv, options, "v");
403 if (idx && argv[idx + 1])
404 opt_loglevel("loglevel", argv[idx + 1]);
405 idx = locate_option(argc, argv, options, "report");
406 if (idx || getenv("FFREPORT")) {
407 opt_report("report");
410 fprintf(report_file, "Command line:\n");
411 for (i = 0; i < argc; i++) {
412 dump_argument(argv[i]);
413 fputc(i < argc - 1 ? ' ' : '\n', report_file);
420 #define FLAGS(o) ((o)->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
421 int opt_default(const char *opt, const char *arg)
423 const AVOption *oc, *of, *os, *oswr = NULL;
424 char opt_stripped[128];
426 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc, *swr_class;
428 if (!(p = strchr(opt, ':')))
429 p = opt + strlen(opt);
430 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
432 if ((oc = av_opt_find(&cc, opt_stripped, NULL, 0,
433 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
434 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
435 (oc = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
436 av_dict_set(&codec_opts, opt, arg, FLAGS(oc));
437 if ((of = av_opt_find(&fc, opt, NULL, 0,
438 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
439 av_dict_set(&format_opts, opt, arg, FLAGS(of));
441 sc = sws_get_class();
442 if ((os = av_opt_find(&sc, opt, NULL, 0,
443 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
444 // XXX we only support sws_flags, not arbitrary sws options
445 int ret = av_opt_set(sws_opts, opt, arg, 0);
447 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
452 swr_class = swr_get_class();
453 if (!oc && !of && !os && (oswr = av_opt_find(&swr_class, opt, NULL, 0,
454 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
455 int ret = av_opt_set(swr_opts, opt, arg, 0);
457 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
462 if (oc || of || os || oswr)
464 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
465 return AVERROR_OPTION_NOT_FOUND;
468 int opt_loglevel(const char *opt, const char *arg)
470 const struct { const char *name; int level; } log_levels[] = {
471 { "quiet" , AV_LOG_QUIET },
472 { "panic" , AV_LOG_PANIC },
473 { "fatal" , AV_LOG_FATAL },
474 { "error" , AV_LOG_ERROR },
475 { "warning", AV_LOG_WARNING },
476 { "info" , AV_LOG_INFO },
477 { "verbose", AV_LOG_VERBOSE },
478 { "debug" , AV_LOG_DEBUG },
484 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
485 if (!strcmp(log_levels[i].name, arg)) {
486 av_log_set_level(log_levels[i].level);
491 level = strtol(arg, &tail, 10);
493 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
494 "Possible levels are numbers or:\n", arg);
495 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
496 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
499 av_log_set_level(level);
503 int opt_report(const char *opt)
509 if (report_file) /* already opened */
512 tm = localtime(&now);
513 snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
515 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
516 tm->tm_hour, tm->tm_min, tm->tm_sec);
517 report_file = fopen(filename, "w");
519 av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
520 filename, strerror(errno));
521 return AVERROR(errno);
523 av_log_set_callback(log_callback_report);
524 av_log(NULL, AV_LOG_INFO,
525 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
526 "Report written to \"%s\"\n",
528 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
529 tm->tm_hour, tm->tm_min, tm->tm_sec,
531 av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
535 int opt_max_alloc(const char *opt, const char *arg)
540 max = strtol(arg, &tail, 10);
542 av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
549 int opt_cpuflags(const char *opt, const char *arg)
552 unsigned flags = av_get_cpu_flags();
554 if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
557 av_force_cpu_flags(flags);
561 int opt_codec_debug(const char *opt, const char *arg)
563 av_log_set_level(AV_LOG_DEBUG);
564 return opt_default(opt, arg);
567 int opt_timelimit(const char *opt, const char *arg)
570 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
571 struct rlimit rl = { lim, lim + 1 };
572 if (setrlimit(RLIMIT_CPU, &rl))
575 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
580 void print_error(const char *filename, int err)
583 const char *errbuf_ptr = errbuf;
585 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
586 errbuf_ptr = strerror(AVUNERROR(err));
587 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
590 static int warned_cfg = 0;
593 #define SHOW_VERSION 2
594 #define SHOW_CONFIG 4
595 #define SHOW_COPYRIGHT 8
597 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
598 if (CONFIG_##LIBNAME) { \
599 const char *indent = flags & INDENT? " " : ""; \
600 if (flags & SHOW_VERSION) { \
601 unsigned int version = libname##_version(); \
602 av_log(NULL, level, \
603 "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
605 LIB##LIBNAME##_VERSION_MAJOR, \
606 LIB##LIBNAME##_VERSION_MINOR, \
607 LIB##LIBNAME##_VERSION_MICRO, \
608 version >> 16, version >> 8 & 0xff, version & 0xff); \
610 if (flags & SHOW_CONFIG) { \
611 const char *cfg = libname##_configuration(); \
612 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
614 av_log(NULL, level, \
615 "%sWARNING: library configuration mismatch\n", \
619 av_log(NULL, level, "%s%-11s configuration: %s\n", \
620 indent, #libname, cfg); \
625 static void print_all_libs_info(int flags, int level)
627 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
628 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
629 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
630 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
631 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
632 // PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
633 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
634 PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
636 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
640 static void print_program_info(int flags, int level)
642 const char *indent = flags & INDENT? " " : "";
644 av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
645 if (flags & SHOW_COPYRIGHT)
646 av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
647 program_birth_year, this_year);
648 av_log(NULL, level, "\n");
649 av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
650 indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
651 av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
654 void show_banner(int argc, char **argv, const OptionDef *options)
656 int idx = locate_option(argc, argv, options, "version");
660 print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
661 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
662 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
665 int opt_version(const char *opt, const char *arg) {
666 av_log_set_callback(log_callback_help);
667 print_program_info (0 , AV_LOG_INFO);
668 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
672 int opt_license(const char *opt, const char *arg)
676 "This version of %s has nonfree parts compiled in.\n"
677 "Therefore it is not legally redistributable.\n",
680 "%s is free software; you can redistribute it and/or modify\n"
681 "it under the terms of the GNU General Public License as published by\n"
682 "the Free Software Foundation; either version 3 of the License, or\n"
683 "(at your option) any later version.\n"
685 "%s is distributed in the hope that it will be useful,\n"
686 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
687 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
688 "GNU General Public License for more details.\n"
690 "You should have received a copy of the GNU General Public License\n"
691 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
692 program_name, program_name, program_name
694 "%s is free software; you can redistribute it and/or modify\n"
695 "it under the terms of the GNU General Public License as published by\n"
696 "the Free Software Foundation; either version 2 of the License, or\n"
697 "(at your option) any later version.\n"
699 "%s is distributed in the hope that it will be useful,\n"
700 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
701 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
702 "GNU General Public License for more details.\n"
704 "You should have received a copy of the GNU General Public License\n"
705 "along with %s; if not, write to the Free Software\n"
706 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
707 program_name, program_name, program_name
709 "%s is free software; you can redistribute it and/or modify\n"
710 "it under the terms of the GNU Lesser General Public License as published by\n"
711 "the Free Software Foundation; either version 3 of the License, or\n"
712 "(at your option) any later version.\n"
714 "%s is distributed in the hope that it will be useful,\n"
715 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
716 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
717 "GNU Lesser General Public License for more details.\n"
719 "You should have received a copy of the GNU Lesser General Public License\n"
720 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
721 program_name, program_name, program_name
723 "%s is free software; you can redistribute it and/or\n"
724 "modify it under the terms of the GNU Lesser General Public\n"
725 "License as published by the Free Software Foundation; either\n"
726 "version 2.1 of the License, or (at your option) any later version.\n"
728 "%s is distributed in the hope that it will be useful,\n"
729 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
730 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
731 "Lesser General Public License for more details.\n"
733 "You should have received a copy of the GNU Lesser General Public\n"
734 "License along with %s; if not, write to the Free Software\n"
735 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
736 program_name, program_name, program_name
742 int opt_formats(const char *opt, const char *arg)
744 AVInputFormat *ifmt = NULL;
745 AVOutputFormat *ofmt = NULL;
746 const char *last_name;
748 printf("File formats:\n"
749 " D. = Demuxing supported\n"
750 " .E = Muxing supported\n"
756 const char *name = NULL;
757 const char *long_name = NULL;
759 while ((ofmt = av_oformat_next(ofmt))) {
760 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
761 strcmp(ofmt->name, last_name) > 0) {
763 long_name = ofmt->long_name;
767 while ((ifmt = av_iformat_next(ifmt))) {
768 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
769 strcmp(ifmt->name, last_name) > 0) {
771 long_name = ifmt->long_name;
774 if (name && strcmp(ifmt->name, name) == 0)
781 printf(" %s%s %-15s %s\n",
785 long_name ? long_name:" ");
790 static char get_media_type_char(enum AVMediaType type)
792 static const char map[AVMEDIA_TYPE_NB] = {
793 [AVMEDIA_TYPE_VIDEO] = 'V',
794 [AVMEDIA_TYPE_AUDIO] = 'A',
795 [AVMEDIA_TYPE_DATA] = 'D',
796 [AVMEDIA_TYPE_SUBTITLE] = 'S',
797 [AVMEDIA_TYPE_ATTACHMENT] = 'T',
799 return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
802 int opt_codecs(const char *opt, const char *arg)
804 AVCodec *p = NULL, *p2;
805 const char *last_name;
807 " D..... = Decoding supported\n"
808 " .E.... = Encoding supported\n"
809 " ..V... = Video codec\n"
810 " ..A... = Audio codec\n"
811 " ..S... = Subtitle codec\n"
812 " ...S.. = Supports draw_horiz_band\n"
813 " ....D. = Supports direct rendering method 1\n"
814 " .....T = Supports weird frame truncation\n"
823 while ((p = av_codec_next(p))) {
824 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
825 strcmp(p->name, last_name) > 0) {
827 decode = encode = cap = 0;
829 if (p2 && strcmp(p->name, p2->name) == 0) {
830 if (av_codec_is_decoder(p))
832 if (av_codec_is_encoder(p))
834 cap |= p->capabilities;
839 last_name = p2->name;
841 printf(" %s%s%c%s%s%s %-15s %s",
842 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
844 get_media_type_char(p2->type),
845 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
846 cap & CODEC_CAP_DR1 ? "D" : " ",
847 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
849 p2->long_name ? p2->long_name : "");
851 if (p2->decoder && decode == 0)
852 printf(" use %s for decoding", p2->decoder->name);
857 printf("Note, the names of encoders and decoders do not always match, so there are\n"
858 "several cases where the above table shows encoder only or decoder only entries\n"
859 "even though both encoding and decoding are supported. For example, the h263\n"
860 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
865 int opt_bsfs(const char *opt, const char *arg)
867 AVBitStreamFilter *bsf = NULL;
869 printf("Bitstream filters:\n");
870 while ((bsf = av_bitstream_filter_next(bsf)))
871 printf("%s\n", bsf->name);
876 int opt_protocols(const char *opt, const char *arg)
881 printf("Supported file protocols:\n"
883 while ((name = avio_enum_protocols(&opaque, 0)))
884 printf("%s\n", name);
886 while ((name = avio_enum_protocols(&opaque, 1)))
887 printf("%s\n", name);
891 int opt_filters(const char *opt, const char *arg)
893 AVFilter av_unused(**filter) = NULL;
894 char descr[64], *descr_cur;
896 const AVFilterPad *pad;
898 printf("Filters:\n");
900 while ((filter = av_filter_next(filter)) && *filter) {
902 for (i = 0; i < 2; i++) {
904 *(descr_cur++) = '-';
905 *(descr_cur++) = '>';
907 pad = i ? (*filter)->outputs : (*filter)->inputs;
908 for (j = 0; pad[j].name; j++) {
909 if (descr_cur >= descr + sizeof(descr) - 4)
911 *(descr_cur++) = get_media_type_char(pad[j].type);
914 *(descr_cur++) = '|';
917 printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
923 int opt_pix_fmts(const char *opt, const char *arg)
925 enum PixelFormat pix_fmt;
927 printf("Pixel formats:\n"
928 "I.... = Supported Input format for conversion\n"
929 ".O... = Supported Output format for conversion\n"
930 "..H.. = Hardware accelerated format\n"
931 "...P. = Paletted format\n"
932 "....B = Bitstream format\n"
933 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
937 # define sws_isSupportedInput(x) 0
938 # define sws_isSupportedOutput(x) 0
941 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
942 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
945 printf("%c%c%c%c%c %-16s %d %2d\n",
946 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
947 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
948 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
949 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
950 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
952 pix_desc->nb_components,
953 av_get_bits_per_pixel(pix_desc));
958 int show_sample_fmts(const char *opt, const char *arg)
962 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
963 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
970 int yesno = (toupper(c) == 'Y');
972 while (c != '\n' && c != EOF)
978 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
981 FILE *f = fopen(filename, "rb");
984 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
986 return AVERROR(errno);
988 fseek(f, 0, SEEK_END);
990 fseek(f, 0, SEEK_SET);
991 *bufptr = av_malloc(*size + 1);
993 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
995 return AVERROR(ENOMEM);
997 ret = fread(*bufptr, 1, *size, f);
1001 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1002 filename, strerror(errno));
1003 ret = AVERROR(errno);
1008 (*bufptr)[*size++] = '\0';
1015 FILE *get_preset_file(char *filename, size_t filename_size,
1016 const char *preset_name, int is_path,
1017 const char *codec_name)
1021 const char *base[3] = { getenv("FFMPEG_DATADIR"),
1026 av_strlcpy(filename, preset_name, filename_size);
1027 f = fopen(filename, "r");
1030 char datadir[MAX_PATH], *ls;
1033 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1035 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1036 if (*ls == '\\') *ls = '/';
1038 if (ls = strrchr(datadir, '/'))
1041 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
1046 for (i = 0; i < 3 && !f; i++) {
1049 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1050 i != 1 ? "" : "/.ffmpeg", preset_name);
1051 f = fopen(filename, "r");
1052 if (!f && codec_name) {
1053 snprintf(filename, filename_size,
1054 "%s%s/%s-%s.ffpreset",
1055 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1057 f = fopen(filename, "r");
1065 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1067 if (*spec <= '9' && *spec >= '0') /* opt:index */
1068 return strtol(spec, NULL, 0) == st->index;
1069 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1070 *spec == 't') { /* opt:[vasdt] */
1071 enum AVMediaType type;
1074 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
1075 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
1076 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
1077 case 'd': type = AVMEDIA_TYPE_DATA; break;
1078 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1079 default: av_assert0(0);
1081 if (type != st->codec->codec_type)
1083 if (*spec++ == ':') { /* possibly followed by :index */
1084 int i, index = strtol(spec, NULL, 0);
1085 for (i = 0; i < s->nb_streams; i++)
1086 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1087 return i == st->index;
1091 } else if (*spec == 'p' && *(spec + 1) == ':') {
1095 prog_id = strtol(spec, &endptr, 0);
1096 for (i = 0; i < s->nb_programs; i++) {
1097 if (s->programs[i]->id != prog_id)
1100 if (*endptr++ == ':') {
1101 int stream_idx = strtol(endptr, NULL, 0);
1102 return stream_idx >= 0 &&
1103 stream_idx < s->programs[i]->nb_stream_indexes &&
1104 st->index == s->programs[i]->stream_index[stream_idx];
1107 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1108 if (st->index == s->programs[i]->stream_index[j])
1112 } else if (*spec == '#') {
1115 sid = strtol(spec + 1, &endptr, 0);
1117 return st->id == sid;
1118 } else if (!*spec) /* empty specifier, matches everything */
1121 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1122 return AVERROR(EINVAL);
1125 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1126 AVFormatContext *s, AVStream *st)
1128 AVDictionary *ret = NULL;
1129 AVDictionaryEntry *t = NULL;
1130 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1131 : AV_OPT_FLAG_DECODING_PARAM;
1133 const AVClass *cc = avcodec_get_class();
1138 switch (codec->type) {
1139 case AVMEDIA_TYPE_VIDEO:
1141 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1143 case AVMEDIA_TYPE_AUDIO:
1145 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1147 case AVMEDIA_TYPE_SUBTITLE:
1149 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1153 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1154 char *p = strchr(t->key, ':');
1156 /* check stream specification in opt name */
1158 switch (check_stream_specifier(s, st, p + 1)) {
1159 case 1: *p = 0; break;
1161 default: return NULL;
1164 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1165 (codec && codec->priv_class &&
1166 av_opt_find(&codec->priv_class, t->key, NULL, flags,
1167 AV_OPT_SEARCH_FAKE_OBJ)))
1168 av_dict_set(&ret, t->key, t->value, 0);
1169 else if (t->key[0] == prefix &&
1170 av_opt_find(&cc, t->key + 1, NULL, flags,
1171 AV_OPT_SEARCH_FAKE_OBJ))
1172 av_dict_set(&ret, t->key + 1, t->value, 0);
1180 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1181 AVDictionary *codec_opts)
1184 AVDictionary **opts;
1188 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1190 av_log(NULL, AV_LOG_ERROR,
1191 "Could not alloc memory for stream options.\n");
1194 for (i = 0; i < s->nb_streams; i++)
1195 opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1200 void *grow_array(void *array, int elem_size, int *size, int new_size)
1202 if (new_size >= INT_MAX / elem_size) {
1203 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1206 if (*size < new_size) {
1207 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1209 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1212 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);