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 "libswscale/swscale.h"
36 #include "libswresample/swresample.h"
38 #include "libpostproc/postprocess.h"
40 #include "libavutil/avstring.h"
41 #include "libavutil/mathematics.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavutil/eval.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/opt.h"
50 #include "libavformat/network.h"
52 #if HAVE_SYS_RESOURCE_H
53 #include <sys/resource.h>
56 struct SwsContext *sws_opts;
57 AVDictionary *format_opts, *codec_opts;
59 const int this_year = 2012;
61 static FILE *report_file;
66 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
71 void uninit_opts(void)
74 sws_freeContext(sws_opts);
77 av_dict_free(&format_opts);
78 av_dict_free(&codec_opts);
81 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
83 vfprintf(stdout, fmt, vl);
86 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
90 static int print_prefix = 1;
93 av_log_default_callback(ptr, level, fmt, vl);
94 av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
96 fputs(line, report_file);
100 double parse_number_or_die(const char *context, const char *numstr, int type,
101 double min, double max)
105 double d = av_strtod(numstr, &tail);
107 error = "Expected number for %s but found: %s\n";
108 else if (d < min || d > max)
109 error = "The value for %s was %s which is not within %f - %f\n";
110 else if (type == OPT_INT64 && (int64_t)d != d)
111 error = "Expected int64 for %s but found %s\n";
112 else if (type == OPT_INT && (int)d != d)
113 error = "Expected int for %s but found %s\n";
116 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
121 int64_t parse_time_or_die(const char *context, const char *timestr,
125 if (av_parse_time(&us, timestr, is_duration) < 0) {
126 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
127 is_duration ? "duration" : "date", context, timestr);
133 void show_help_options(const OptionDef *options, const char *msg, int mask,
140 for (po = options; po->name != NULL; po++) {
142 if ((po->flags & mask) == value) {
147 av_strlcpy(buf, po->name, sizeof(buf));
148 if (po->flags & HAS_ARG) {
149 av_strlcat(buf, " ", sizeof(buf));
150 av_strlcat(buf, po->argname, sizeof(buf));
152 printf("-%-17s %s\n", buf, po->help);
157 void show_help_children(const AVClass *class, int flags)
159 const AVClass *child = NULL;
160 av_opt_show2(&class, NULL, flags, 0);
163 while (child = av_opt_child_class_next(class, child))
164 show_help_children(child, flags);
167 static const OptionDef *find_option(const OptionDef *po, const char *name)
169 const char *p = strchr(name, ':');
170 int len = p ? p - name : strlen(name);
172 while (po->name != NULL) {
173 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
180 #if defined(_WIN32) && !defined(__MINGW32CE__)
182 /* Will be leaked on exit */
183 static char** win32_argv_utf8 = NULL;
184 static int win32_argc = 0;
187 * Prepare command line arguments for executable.
188 * For Windows - perform wide-char to UTF-8 conversion.
189 * Input arguments should be main() function arguments.
190 * @param argc_ptr Arguments number (including executable)
191 * @param argv_ptr Arguments list.
193 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
197 int i, buffsize = 0, offset = 0;
199 if (win32_argv_utf8) {
200 *argc_ptr = win32_argc;
201 *argv_ptr = win32_argv_utf8;
206 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
207 if (win32_argc <= 0 || !argv_w)
210 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
211 for (i = 0; i < win32_argc; i++)
212 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
213 NULL, 0, NULL, NULL);
215 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
216 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
217 if (win32_argv_utf8 == NULL) {
222 for (i = 0; i < win32_argc; i++) {
223 win32_argv_utf8[i] = &argstr_flat[offset];
224 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
225 &argstr_flat[offset],
226 buffsize - offset, NULL, NULL);
228 win32_argv_utf8[i] = NULL;
231 *argc_ptr = win32_argc;
232 *argv_ptr = win32_argv_utf8;
235 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
239 #endif /* WIN32 && !__MINGW32CE__ */
241 int parse_option(void *optctx, const char *opt, const char *arg,
242 const OptionDef *options)
249 po = find_option(options, opt);
250 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
251 /* handle 'no' bool option */
252 po = find_option(options, opt + 2);
253 if (!(po->name && (po->flags & OPT_BOOL)))
258 po = find_option(options, "default");
261 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
262 return AVERROR(EINVAL);
264 if (po->flags & HAS_ARG && !arg) {
265 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
266 return AVERROR(EINVAL);
269 /* new-style options contain an offset into optctx, old-style address of
271 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
274 if (po->flags & OPT_SPEC) {
275 SpecifierOpt **so = dst;
276 char *p = strchr(opt, ':');
278 dstcount = (int *)(so + 1);
279 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
280 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
281 dst = &(*so)[*dstcount - 1].u;
284 if (po->flags & OPT_STRING) {
286 str = av_strdup(arg);
288 } else if (po->flags & OPT_BOOL) {
289 *(int *)dst = bool_val;
290 } else if (po->flags & OPT_INT) {
291 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
292 } else if (po->flags & OPT_INT64) {
293 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
294 } else if (po->flags & OPT_TIME) {
295 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
296 } else if (po->flags & OPT_FLOAT) {
297 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
298 } else if (po->flags & OPT_DOUBLE) {
299 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
300 } else if (po->u.func_arg) {
301 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
302 : po->u.func_arg(opt, arg);
304 av_log(NULL, AV_LOG_ERROR,
305 "Failed to set value '%s' for option '%s'\n", arg, opt);
309 if (po->flags & OPT_EXIT)
311 return !!(po->flags & HAS_ARG);
314 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
315 void (*parse_arg_function)(void *, const char*))
318 int optindex, handleoptions = 1, ret;
320 /* perform system-dependent conversions for arguments list */
321 prepare_app_arguments(&argc, &argv);
325 while (optindex < argc) {
326 opt = argv[optindex++];
328 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
329 if (opt[1] == '-' && opt[2] == '\0') {
335 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
339 if (parse_arg_function)
340 parse_arg_function(optctx, opt);
346 * Return index of option opt in argv or 0 if not found.
348 static 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;
424 char opt_stripped[128];
426 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc;
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);
455 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
456 return AVERROR_OPTION_NOT_FOUND;
459 int opt_loglevel(const char *opt, const char *arg)
461 const struct { const char *name; int level; } log_levels[] = {
462 { "quiet" , AV_LOG_QUIET },
463 { "panic" , AV_LOG_PANIC },
464 { "fatal" , AV_LOG_FATAL },
465 { "error" , AV_LOG_ERROR },
466 { "warning", AV_LOG_WARNING },
467 { "info" , AV_LOG_INFO },
468 { "verbose", AV_LOG_VERBOSE },
469 { "debug" , AV_LOG_DEBUG },
475 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
476 if (!strcmp(log_levels[i].name, arg)) {
477 av_log_set_level(log_levels[i].level);
482 level = strtol(arg, &tail, 10);
484 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
485 "Possible levels are numbers or:\n", arg);
486 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
487 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
490 av_log_set_level(level);
494 int opt_report(const char *opt)
500 if (report_file) /* already opened */
503 tm = localtime(&now);
504 snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
506 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
507 tm->tm_hour, tm->tm_min, tm->tm_sec);
508 report_file = fopen(filename, "w");
510 av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
511 filename, strerror(errno));
512 return AVERROR(errno);
514 av_log_set_callback(log_callback_report);
515 av_log(NULL, AV_LOG_INFO,
516 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
517 "Report written to \"%s\"\n",
519 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
520 tm->tm_hour, tm->tm_min, tm->tm_sec,
522 av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
526 int opt_max_alloc(const char *opt, const char *arg)
531 max = strtol(arg, &tail, 10);
533 av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
540 int opt_codec_debug(const char *opt, const char *arg)
542 av_log_set_level(AV_LOG_DEBUG);
543 return opt_default(opt, arg);
546 int opt_timelimit(const char *opt, const char *arg)
549 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
550 struct rlimit rl = { lim, lim + 1 };
551 if (setrlimit(RLIMIT_CPU, &rl))
554 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
559 void print_error(const char *filename, int err)
562 const char *errbuf_ptr = errbuf;
564 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
565 errbuf_ptr = strerror(AVUNERROR(err));
566 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
569 static int warned_cfg = 0;
572 #define SHOW_VERSION 2
573 #define SHOW_CONFIG 4
574 #define SHOW_COPYRIGHT 8
576 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
577 if (CONFIG_##LIBNAME) { \
578 const char *indent = flags & INDENT? " " : ""; \
579 if (flags & SHOW_VERSION) { \
580 unsigned int version = libname##_version(); \
581 av_log(NULL, level, "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",\
583 LIB##LIBNAME##_VERSION_MAJOR, \
584 LIB##LIBNAME##_VERSION_MINOR, \
585 LIB##LIBNAME##_VERSION_MICRO, \
586 version >> 16, version >> 8 & 0xff, version & 0xff); \
588 if (flags & SHOW_CONFIG) { \
589 const char *cfg = libname##_configuration(); \
590 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
592 av_log(NULL, level, \
593 "%sWARNING: library configuration mismatch\n", \
597 av_log(NULL, level, "%s%-11s configuration: %s\n", \
598 indent, #libname, cfg); \
603 static void print_all_libs_info(int flags, int level)
605 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
606 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
607 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
608 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
609 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
610 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
611 PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
613 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
617 static void print_program_info(int flags, int level)
619 const char *indent = flags & INDENT? " " : "";
621 av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
622 if (flags & SHOW_COPYRIGHT)
623 av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
624 program_birth_year, this_year);
625 av_log(NULL, level, "\n");
626 av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
627 indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
628 av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
631 void show_banner(int argc, char **argv, const OptionDef *options)
633 int idx = locate_option(argc, argv, options, "version");
637 print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
638 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
639 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
642 int opt_version(const char *opt, const char *arg) {
643 av_log_set_callback(log_callback_help);
644 print_program_info (0 , AV_LOG_INFO);
645 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
649 int opt_license(const char *opt, const char *arg)
653 "This version of %s has nonfree parts compiled in.\n"
654 "Therefore it is not legally redistributable.\n",
657 "%s is free software; you can redistribute it and/or modify\n"
658 "it under the terms of the GNU General Public License as published by\n"
659 "the Free Software Foundation; either version 3 of the License, or\n"
660 "(at your option) any later version.\n"
662 "%s is distributed in the hope that it will be useful,\n"
663 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
664 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
665 "GNU General Public License for more details.\n"
667 "You should have received a copy of the GNU General Public License\n"
668 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
669 program_name, program_name, program_name
671 "%s is free software; you can redistribute it and/or modify\n"
672 "it under the terms of the GNU General Public License as published by\n"
673 "the Free Software Foundation; either version 2 of the License, or\n"
674 "(at your option) any later version.\n"
676 "%s is distributed in the hope that it will be useful,\n"
677 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
678 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
679 "GNU General Public License for more details.\n"
681 "You should have received a copy of the GNU General Public License\n"
682 "along with %s; if not, write to the Free Software\n"
683 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
684 program_name, program_name, program_name
686 "%s is free software; you can redistribute it and/or modify\n"
687 "it under the terms of the GNU Lesser General Public License as published by\n"
688 "the Free Software Foundation; either version 3 of the License, or\n"
689 "(at your option) any later version.\n"
691 "%s is distributed in the hope that it will be useful,\n"
692 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
693 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
694 "GNU Lesser General Public License for more details.\n"
696 "You should have received a copy of the GNU Lesser General Public License\n"
697 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
698 program_name, program_name, program_name
700 "%s is free software; you can redistribute it and/or\n"
701 "modify it under the terms of the GNU Lesser General Public\n"
702 "License as published by the Free Software Foundation; either\n"
703 "version 2.1 of the License, or (at your option) any later version.\n"
705 "%s is distributed in the hope that it will be useful,\n"
706 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
707 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
708 "Lesser General Public License for more details.\n"
710 "You should have received a copy of the GNU Lesser General Public\n"
711 "License along with %s; if not, write to the Free Software\n"
712 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
713 program_name, program_name, program_name
719 int opt_formats(const char *opt, const char *arg)
721 AVInputFormat *ifmt = NULL;
722 AVOutputFormat *ofmt = NULL;
723 const char *last_name;
725 printf("File formats:\n"
726 " D. = Demuxing supported\n"
727 " .E = Muxing supported\n"
733 const char *name = NULL;
734 const char *long_name = NULL;
736 while ((ofmt = av_oformat_next(ofmt))) {
737 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
738 strcmp(ofmt->name, last_name) > 0) {
740 long_name = ofmt->long_name;
744 while ((ifmt = av_iformat_next(ifmt))) {
745 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
746 strcmp(ifmt->name, last_name) > 0) {
748 long_name = ifmt->long_name;
751 if (name && strcmp(ifmt->name, name) == 0)
758 printf(" %s%s %-15s %s\n",
762 long_name ? long_name:" ");
767 static char get_media_type_char(enum AVMediaType type)
769 static const char map[AVMEDIA_TYPE_NB] = {
770 [AVMEDIA_TYPE_VIDEO] = 'V',
771 [AVMEDIA_TYPE_AUDIO] = 'A',
772 [AVMEDIA_TYPE_DATA] = 'D',
773 [AVMEDIA_TYPE_SUBTITLE] = 'S',
774 [AVMEDIA_TYPE_ATTACHMENT] = 'T',
776 return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
779 int opt_codecs(const char *opt, const char *arg)
781 AVCodec *p = NULL, *p2;
782 const char *last_name;
784 " D..... = Decoding supported\n"
785 " .E.... = Encoding supported\n"
786 " ..V... = Video codec\n"
787 " ..A... = Audio codec\n"
788 " ..S... = Subtitle codec\n"
789 " ...S.. = Supports draw_horiz_band\n"
790 " ....D. = Supports direct rendering method 1\n"
791 " .....T = Supports weird frame truncation\n"
800 while ((p = av_codec_next(p))) {
801 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
802 strcmp(p->name, last_name) > 0) {
804 decode = encode = cap = 0;
806 if (p2 && strcmp(p->name, p2->name) == 0) {
811 cap |= p->capabilities;
816 last_name = p2->name;
818 printf(" %s%s%c%s%s%s %-15s %s",
819 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
821 get_media_type_char(p2->type),
822 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
823 cap & CODEC_CAP_DR1 ? "D" : " ",
824 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
826 p2->long_name ? p2->long_name : "");
828 if (p2->decoder && decode == 0)
829 printf(" use %s for decoding", p2->decoder->name);
834 printf("Note, the names of encoders and decoders do not always match, so there are\n"
835 "several cases where the above table shows encoder only or decoder only entries\n"
836 "even though both encoding and decoding are supported. For example, the h263\n"
837 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
842 int opt_bsfs(const char *opt, const char *arg)
844 AVBitStreamFilter *bsf = NULL;
846 printf("Bitstream filters:\n");
847 while ((bsf = av_bitstream_filter_next(bsf)))
848 printf("%s\n", bsf->name);
853 int opt_protocols(const char *opt, const char *arg)
855 URLProtocol *up=NULL;
857 printf("Supported file protocols:\n"
858 "I.. = Input supported\n"
859 ".O. = Output supported\n"
860 "..S = Seek supported\n"
863 while((up = av_protocol_next(up)))
864 printf("%c%c%c %s\n",
865 up->url_read ? 'I' : '.',
866 up->url_write ? 'O' : '.',
867 up->url_seek ? 'S' : '.',
872 int opt_filters(const char *opt, const char *arg)
874 AVFilter av_unused(**filter) = NULL;
875 char descr[64], *descr_cur;
877 const AVFilterPad *pad;
879 printf("Filters:\n");
881 while ((filter = av_filter_next(filter)) && *filter) {
883 for (i = 0; i < 2; i++) {
885 *(descr_cur++) = '-';
886 *(descr_cur++) = '>';
888 pad = i ? (*filter)->outputs : (*filter)->inputs;
889 for (j = 0; pad[j].name; j++) {
890 if (descr_cur >= descr + sizeof(descr) - 4)
892 *(descr_cur++) = get_media_type_char(pad[j].type);
895 *(descr_cur++) = '|';
898 printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
904 int opt_pix_fmts(const char *opt, const char *arg)
906 enum PixelFormat pix_fmt;
908 printf("Pixel formats:\n"
909 "I.... = Supported Input format for conversion\n"
910 ".O... = Supported Output format for conversion\n"
911 "..H.. = Hardware accelerated format\n"
912 "...P. = Paletted format\n"
913 "....B = Bitstream format\n"
914 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
918 # define sws_isSupportedInput(x) 0
919 # define sws_isSupportedOutput(x) 0
922 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
923 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
926 printf("%c%c%c%c%c %-16s %d %2d\n",
927 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
928 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
929 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
930 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
931 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
933 pix_desc->nb_components,
934 av_get_bits_per_pixel(pix_desc));
939 int show_sample_fmts(const char *opt, const char *arg)
943 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
944 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
951 int yesno = (toupper(c) == 'Y');
953 while (c != '\n' && c != EOF)
959 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
962 FILE *f = fopen(filename, "rb");
965 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
967 return AVERROR(errno);
969 fseek(f, 0, SEEK_END);
971 fseek(f, 0, SEEK_SET);
972 *bufptr = av_malloc(*size + 1);
974 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
976 return AVERROR(ENOMEM);
978 ret = fread(*bufptr, 1, *size, f);
982 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
983 filename, strerror(errno));
984 ret = AVERROR(errno);
989 (*bufptr)[*size++] = '\0';
996 FILE *get_preset_file(char *filename, size_t filename_size,
997 const char *preset_name, int is_path,
998 const char *codec_name)
1002 const char *base[3] = { getenv("FFMPEG_DATADIR"),
1007 av_strlcpy(filename, preset_name, filename_size);
1008 f = fopen(filename, "r");
1011 char datadir[MAX_PATH], *ls;
1014 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1016 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1017 if (*ls == '\\') *ls = '/';
1019 if (ls = strrchr(datadir, '/'))
1022 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
1027 for (i = 0; i < 3 && !f; i++) {
1030 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1031 i != 1 ? "" : "/.ffmpeg", preset_name);
1032 f = fopen(filename, "r");
1033 if (!f && codec_name) {
1034 snprintf(filename, filename_size,
1035 "%s%s/%s-%s.ffpreset",
1036 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1038 f = fopen(filename, "r");
1046 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1048 if (*spec <= '9' && *spec >= '0') /* opt:index */
1049 return strtol(spec, NULL, 0) == st->index;
1050 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1051 *spec == 't') { /* opt:[vasdt] */
1052 enum AVMediaType type;
1055 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
1056 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
1057 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
1058 case 'd': type = AVMEDIA_TYPE_DATA; break;
1059 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1060 default: abort(); // never reached, silence warning
1062 if (type != st->codec->codec_type)
1064 if (*spec++ == ':') { /* possibly followed by :index */
1065 int i, index = strtol(spec, NULL, 0);
1066 for (i = 0; i < s->nb_streams; i++)
1067 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1068 return i == st->index;
1072 } else if (*spec == 'p' && *(spec + 1) == ':') {
1076 prog_id = strtol(spec, &endptr, 0);
1077 for (i = 0; i < s->nb_programs; i++) {
1078 if (s->programs[i]->id != prog_id)
1081 if (*endptr++ == ':') {
1082 int stream_idx = strtol(endptr, NULL, 0);
1083 return stream_idx >= 0 &&
1084 stream_idx < s->programs[i]->nb_stream_indexes &&
1085 st->index == s->programs[i]->stream_index[stream_idx];
1088 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1089 if (st->index == s->programs[i]->stream_index[j])
1093 } else if (!*spec) /* empty specifier, matches everything */
1096 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1097 return AVERROR(EINVAL);
1100 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1101 AVFormatContext *s, AVStream *st)
1103 AVDictionary *ret = NULL;
1104 AVDictionaryEntry *t = NULL;
1105 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1106 : AV_OPT_FLAG_DECODING_PARAM;
1108 const AVClass *cc = avcodec_get_class();
1113 switch (codec->type) {
1114 case AVMEDIA_TYPE_VIDEO:
1116 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1118 case AVMEDIA_TYPE_AUDIO:
1120 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1122 case AVMEDIA_TYPE_SUBTITLE:
1124 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1128 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1129 char *p = strchr(t->key, ':');
1131 /* check stream specification in opt name */
1133 switch (check_stream_specifier(s, st, p + 1)) {
1134 case 1: *p = 0; break;
1136 default: return NULL;
1139 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1140 (codec && codec->priv_class &&
1141 av_opt_find(&codec->priv_class, t->key, NULL, flags,
1142 AV_OPT_SEARCH_FAKE_OBJ)))
1143 av_dict_set(&ret, t->key, t->value, 0);
1144 else if (t->key[0] == prefix &&
1145 av_opt_find(&cc, t->key + 1, NULL, flags,
1146 AV_OPT_SEARCH_FAKE_OBJ))
1147 av_dict_set(&ret, t->key + 1, t->value, 0);
1155 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1156 AVDictionary *codec_opts)
1159 AVDictionary **opts;
1163 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1165 av_log(NULL, AV_LOG_ERROR,
1166 "Could not alloc memory for stream options.\n");
1169 for (i = 0; i < s->nb_streams; i++)
1170 opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1175 void *grow_array(void *array, int elem_size, int *size, int new_size)
1177 if (new_size >= INT_MAX / elem_size) {
1178 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1181 if (*size < new_size) {
1182 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1184 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1187 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);