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)))
257 po = find_option(options, "default");
259 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
260 return AVERROR(EINVAL);
262 if (po->flags & HAS_ARG && !arg) {
263 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
264 return AVERROR(EINVAL);
267 /* new-style options contain an offset into optctx, old-style address of
269 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
272 if (po->flags & OPT_SPEC) {
273 SpecifierOpt **so = dst;
274 char *p = strchr(opt, ':');
276 dstcount = (int *)(so + 1);
277 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
278 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
279 dst = &(*so)[*dstcount - 1].u;
282 if (po->flags & OPT_STRING) {
284 str = av_strdup(arg);
286 } else if (po->flags & OPT_BOOL) {
287 *(int *)dst = bool_val;
288 } else if (po->flags & OPT_INT) {
289 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
290 } else if (po->flags & OPT_INT64) {
291 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
292 } else if (po->flags & OPT_TIME) {
293 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
294 } else if (po->flags & OPT_FLOAT) {
295 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
296 } else if (po->flags & OPT_DOUBLE) {
297 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
298 } else if (po->u.func_arg) {
299 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
300 : po->u.func_arg(opt, arg);
302 av_log(NULL, AV_LOG_ERROR,
303 "Failed to set value '%s' for option '%s'\n", arg, opt);
307 if (po->flags & OPT_EXIT)
309 return !!(po->flags & HAS_ARG);
312 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
313 void (*parse_arg_function)(void *, const char*))
316 int optindex, handleoptions = 1, ret;
318 /* perform system-dependent conversions for arguments list */
319 prepare_app_arguments(&argc, &argv);
323 while (optindex < argc) {
324 opt = argv[optindex++];
326 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
327 if (opt[1] == '-' && opt[2] == '\0') {
333 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
337 if (parse_arg_function)
338 parse_arg_function(optctx, opt);
344 * Return index of option opt in argv or 0 if not found.
346 static int locate_option(int argc, char **argv, const OptionDef *options,
352 for (i = 1; i < argc; i++) {
353 const char *cur_opt = argv[i];
355 if (*cur_opt++ != '-')
358 po = find_option(options, cur_opt);
359 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
360 po = find_option(options, cur_opt + 2);
362 if ((!po->name && !strcmp(cur_opt, optname)) ||
363 (po->name && !strcmp(optname, po->name)))
366 if (!po || po->flags & HAS_ARG)
372 static void dump_argument(const char *a)
374 const unsigned char *p;
377 if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
378 *p == '_' || (*p >= 'a' && *p <= 'z')))
381 fputs(a, report_file);
384 fputc('"', report_file);
385 for (p = a; *p; p++) {
386 if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
387 fprintf(report_file, "\\%c", *p);
388 else if (*p < ' ' || *p > '~')
389 fprintf(report_file, "\\x%02x", *p);
391 fputc(*p, report_file);
393 fputc('"', report_file);
396 void parse_loglevel(int argc, char **argv, const OptionDef *options)
398 int idx = locate_option(argc, argv, options, "loglevel");
400 idx = locate_option(argc, argv, options, "v");
401 if (idx && argv[idx + 1])
402 opt_loglevel("loglevel", argv[idx + 1]);
403 idx = locate_option(argc, argv, options, "report");
404 if (idx || getenv("FFREPORT")) {
405 opt_report("report");
408 fprintf(report_file, "Command line:\n");
409 for (i = 0; i < argc; i++) {
410 dump_argument(argv[i]);
411 fputc(i < argc - 1 ? ' ' : '\n', report_file);
418 #define FLAGS(o) ((o)->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
419 int opt_default(const char *opt, const char *arg)
421 const AVOption *oc, *of, *os;
422 char opt_stripped[128];
424 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc;
426 if (!(p = strchr(opt, ':')))
427 p = opt + strlen(opt);
428 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
430 if ((oc = av_opt_find(&cc, opt_stripped, NULL, 0,
431 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
432 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
433 (oc = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
434 av_dict_set(&codec_opts, opt, arg, FLAGS(oc));
435 if ((of = av_opt_find(&fc, opt, NULL, 0,
436 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
437 av_dict_set(&format_opts, opt, arg, FLAGS(of));
439 sc = sws_get_class();
440 if ((os = av_opt_find(&sc, opt, NULL, 0,
441 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
442 // XXX we only support sws_flags, not arbitrary sws options
443 int ret = av_opt_set(sws_opts, opt, arg, 0);
445 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
453 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
454 return AVERROR_OPTION_NOT_FOUND;
457 int opt_loglevel(const char *opt, const char *arg)
459 const struct { const char *name; int level; } log_levels[] = {
460 { "quiet" , AV_LOG_QUIET },
461 { "panic" , AV_LOG_PANIC },
462 { "fatal" , AV_LOG_FATAL },
463 { "error" , AV_LOG_ERROR },
464 { "warning", AV_LOG_WARNING },
465 { "info" , AV_LOG_INFO },
466 { "verbose", AV_LOG_VERBOSE },
467 { "debug" , AV_LOG_DEBUG },
473 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
474 if (!strcmp(log_levels[i].name, arg)) {
475 av_log_set_level(log_levels[i].level);
480 level = strtol(arg, &tail, 10);
482 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
483 "Possible levels are numbers or:\n", arg);
484 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
485 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
488 av_log_set_level(level);
492 int opt_report(const char *opt)
498 if (report_file) /* already opened */
501 tm = localtime(&now);
502 snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
504 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
505 tm->tm_hour, tm->tm_min, tm->tm_sec);
506 report_file = fopen(filename, "w");
508 av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
509 filename, strerror(errno));
510 return AVERROR(errno);
512 av_log_set_callback(log_callback_report);
513 av_log(NULL, AV_LOG_INFO,
514 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
515 "Report written to \"%s\"\n",
517 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
518 tm->tm_hour, tm->tm_min, tm->tm_sec,
520 av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
524 int opt_max_alloc(const char *opt, const char *arg)
529 max = strtol(arg, &tail, 10);
531 av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
538 int opt_cpuflags(const char *opt, const char *arg)
541 long flags = strtol(arg, &tail, 10);
544 av_log(NULL, AV_LOG_FATAL, "Invalid cpuflags \"%s\".\n", arg);
547 av_force_cpu_flags(flags);
551 int opt_codec_debug(const char *opt, const char *arg)
553 av_log_set_level(AV_LOG_DEBUG);
554 return opt_default(opt, arg);
557 int opt_timelimit(const char *opt, const char *arg)
560 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
561 struct rlimit rl = { lim, lim + 1 };
562 if (setrlimit(RLIMIT_CPU, &rl))
565 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
570 void print_error(const char *filename, int err)
573 const char *errbuf_ptr = errbuf;
575 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
576 errbuf_ptr = strerror(AVUNERROR(err));
577 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
580 static int warned_cfg = 0;
583 #define SHOW_VERSION 2
584 #define SHOW_CONFIG 4
585 #define SHOW_COPYRIGHT 8
587 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
588 if (CONFIG_##LIBNAME) { \
589 const char *indent = flags & INDENT? " " : ""; \
590 if (flags & SHOW_VERSION) { \
591 unsigned int version = libname##_version(); \
592 av_log(NULL, level, "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",\
594 LIB##LIBNAME##_VERSION_MAJOR, \
595 LIB##LIBNAME##_VERSION_MINOR, \
596 LIB##LIBNAME##_VERSION_MICRO, \
597 version >> 16, version >> 8 & 0xff, version & 0xff); \
599 if (flags & SHOW_CONFIG) { \
600 const char *cfg = libname##_configuration(); \
601 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
603 av_log(NULL, level, \
604 "%sWARNING: library configuration mismatch\n", \
608 av_log(NULL, level, "%s%-11s configuration: %s\n", \
609 indent, #libname, cfg); \
614 static void print_all_libs_info(int flags, int level)
616 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
617 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
618 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
619 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
620 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
621 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
622 PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
624 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
628 static void print_program_info(int flags, int level)
630 const char *indent = flags & INDENT? " " : "";
632 av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
633 if (flags & SHOW_COPYRIGHT)
634 av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
635 program_birth_year, this_year);
636 av_log(NULL, level, "\n");
637 av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
638 indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
639 av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
642 void show_banner(int argc, char **argv, const OptionDef *options)
644 int idx = locate_option(argc, argv, options, "version");
648 print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
649 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
650 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
653 int opt_version(const char *opt, const char *arg) {
654 av_log_set_callback(log_callback_help);
655 print_program_info (0 , AV_LOG_INFO);
656 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
660 int opt_license(const char *opt, const char *arg)
664 "This version of %s has nonfree parts compiled in.\n"
665 "Therefore it is not legally redistributable.\n",
668 "%s is free software; you can redistribute it and/or modify\n"
669 "it under the terms of the GNU General Public License as published by\n"
670 "the Free Software Foundation; either version 3 of the License, or\n"
671 "(at your option) any later version.\n"
673 "%s is distributed in the hope that it will be useful,\n"
674 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
675 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
676 "GNU General Public License for more details.\n"
678 "You should have received a copy of the GNU General Public License\n"
679 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
680 program_name, program_name, program_name
682 "%s is free software; you can redistribute it and/or modify\n"
683 "it under the terms of the GNU General Public License as published by\n"
684 "the Free Software Foundation; either version 2 of the License, or\n"
685 "(at your option) any later version.\n"
687 "%s is distributed in the hope that it will be useful,\n"
688 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
689 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
690 "GNU General Public License for more details.\n"
692 "You should have received a copy of the GNU General Public License\n"
693 "along with %s; if not, write to the Free Software\n"
694 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
695 program_name, program_name, program_name
697 "%s is free software; you can redistribute it and/or modify\n"
698 "it under the terms of the GNU Lesser General Public License as published by\n"
699 "the Free Software Foundation; either version 3 of the License, or\n"
700 "(at your option) any later version.\n"
702 "%s is distributed in the hope that it will be useful,\n"
703 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
704 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
705 "GNU Lesser General Public License for more details.\n"
707 "You should have received a copy of the GNU Lesser General Public License\n"
708 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
709 program_name, program_name, program_name
711 "%s is free software; you can redistribute it and/or\n"
712 "modify it under the terms of the GNU Lesser General Public\n"
713 "License as published by the Free Software Foundation; either\n"
714 "version 2.1 of the License, or (at your option) any later version.\n"
716 "%s is distributed in the hope that it will be useful,\n"
717 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
718 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
719 "Lesser General Public License for more details.\n"
721 "You should have received a copy of the GNU Lesser General Public\n"
722 "License along with %s; if not, write to the Free Software\n"
723 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
724 program_name, program_name, program_name
730 int opt_formats(const char *opt, const char *arg)
732 AVInputFormat *ifmt = NULL;
733 AVOutputFormat *ofmt = NULL;
734 const char *last_name;
736 printf("File formats:\n"
737 " D. = Demuxing supported\n"
738 " .E = Muxing supported\n"
744 const char *name = NULL;
745 const char *long_name = NULL;
747 while ((ofmt = av_oformat_next(ofmt))) {
748 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
749 strcmp(ofmt->name, last_name) > 0) {
751 long_name = ofmt->long_name;
755 while ((ifmt = av_iformat_next(ifmt))) {
756 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
757 strcmp(ifmt->name, last_name) > 0) {
759 long_name = ifmt->long_name;
762 if (name && strcmp(ifmt->name, name) == 0)
769 printf(" %s%s %-15s %s\n",
773 long_name ? long_name:" ");
778 static char get_media_type_char(enum AVMediaType type)
780 static const char map[AVMEDIA_TYPE_NB] = {
781 [AVMEDIA_TYPE_VIDEO] = 'V',
782 [AVMEDIA_TYPE_AUDIO] = 'A',
783 [AVMEDIA_TYPE_DATA] = 'D',
784 [AVMEDIA_TYPE_SUBTITLE] = 'S',
785 [AVMEDIA_TYPE_ATTACHMENT] = 'T',
787 return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
790 int opt_codecs(const char *opt, const char *arg)
792 AVCodec *p = NULL, *p2;
793 const char *last_name;
795 " D..... = Decoding supported\n"
796 " .E.... = Encoding supported\n"
797 " ..V... = Video codec\n"
798 " ..A... = Audio codec\n"
799 " ..S... = Subtitle codec\n"
800 " ...S.. = Supports draw_horiz_band\n"
801 " ....D. = Supports direct rendering method 1\n"
802 " .....T = Supports weird frame truncation\n"
811 while ((p = av_codec_next(p))) {
812 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
813 strcmp(p->name, last_name) > 0) {
815 decode = encode = cap = 0;
817 if (p2 && strcmp(p->name, p2->name) == 0) {
818 if (av_codec_is_decoder(p))
820 if (av_codec_is_encoder(p))
822 cap |= p->capabilities;
827 last_name = p2->name;
829 printf(" %s%s%c%s%s%s %-15s %s",
830 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
832 get_media_type_char(p2->type),
833 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
834 cap & CODEC_CAP_DR1 ? "D" : " ",
835 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
837 p2->long_name ? p2->long_name : "");
839 if (p2->decoder && decode == 0)
840 printf(" use %s for decoding", p2->decoder->name);
845 printf("Note, the names of encoders and decoders do not always match, so there are\n"
846 "several cases where the above table shows encoder only or decoder only entries\n"
847 "even though both encoding and decoding are supported. For example, the h263\n"
848 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
853 int opt_bsfs(const char *opt, const char *arg)
855 AVBitStreamFilter *bsf = NULL;
857 printf("Bitstream filters:\n");
858 while ((bsf = av_bitstream_filter_next(bsf)))
859 printf("%s\n", bsf->name);
864 int opt_protocols(const char *opt, const char *arg)
869 printf("Supported file protocols:\n"
871 while ((name = avio_enum_protocols(&opaque, 0)))
872 printf("%s\n", name);
874 while ((name = avio_enum_protocols(&opaque, 1)))
875 printf("%s\n", name);
879 int opt_filters(const char *opt, const char *arg)
881 AVFilter av_unused(**filter) = NULL;
882 char descr[64], *descr_cur;
884 const AVFilterPad *pad;
886 printf("Filters:\n");
888 while ((filter = av_filter_next(filter)) && *filter) {
890 for (i = 0; i < 2; i++) {
892 *(descr_cur++) = '-';
893 *(descr_cur++) = '>';
895 pad = i ? (*filter)->outputs : (*filter)->inputs;
896 for (j = 0; pad[j].name; j++) {
897 if (descr_cur >= descr + sizeof(descr) - 4)
899 *(descr_cur++) = get_media_type_char(pad[j].type);
902 *(descr_cur++) = '|';
905 printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
911 int opt_pix_fmts(const char *opt, const char *arg)
913 enum PixelFormat pix_fmt;
915 printf("Pixel formats:\n"
916 "I.... = Supported Input format for conversion\n"
917 ".O... = Supported Output format for conversion\n"
918 "..H.. = Hardware accelerated format\n"
919 "...P. = Paletted format\n"
920 "....B = Bitstream format\n"
921 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
925 # define sws_isSupportedInput(x) 0
926 # define sws_isSupportedOutput(x) 0
929 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
930 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
933 printf("%c%c%c%c%c %-16s %d %2d\n",
934 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
935 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
936 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
937 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
938 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
940 pix_desc->nb_components,
941 av_get_bits_per_pixel(pix_desc));
946 int show_sample_fmts(const char *opt, const char *arg)
950 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
951 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
958 int yesno = (toupper(c) == 'Y');
960 while (c != '\n' && c != EOF)
966 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
969 FILE *f = fopen(filename, "rb");
972 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
974 return AVERROR(errno);
976 fseek(f, 0, SEEK_END);
978 fseek(f, 0, SEEK_SET);
979 *bufptr = av_malloc(*size + 1);
981 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
983 return AVERROR(ENOMEM);
985 ret = fread(*bufptr, 1, *size, f);
989 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
990 filename, strerror(errno));
991 ret = AVERROR(errno);
996 (*bufptr)[*size++] = '\0';
1003 FILE *get_preset_file(char *filename, size_t filename_size,
1004 const char *preset_name, int is_path,
1005 const char *codec_name)
1009 const char *base[3] = { getenv("FFMPEG_DATADIR"),
1014 av_strlcpy(filename, preset_name, filename_size);
1015 f = fopen(filename, "r");
1018 char datadir[MAX_PATH], *ls;
1021 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1023 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1024 if (*ls == '\\') *ls = '/';
1026 if (ls = strrchr(datadir, '/'))
1029 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
1034 for (i = 0; i < 3 && !f; i++) {
1037 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1038 i != 1 ? "" : "/.ffmpeg", preset_name);
1039 f = fopen(filename, "r");
1040 if (!f && codec_name) {
1041 snprintf(filename, filename_size,
1042 "%s%s/%s-%s.ffpreset",
1043 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1045 f = fopen(filename, "r");
1053 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1055 if (*spec <= '9' && *spec >= '0') /* opt:index */
1056 return strtol(spec, NULL, 0) == st->index;
1057 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1058 *spec == 't') { /* opt:[vasdt] */
1059 enum AVMediaType type;
1062 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
1063 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
1064 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
1065 case 'd': type = AVMEDIA_TYPE_DATA; break;
1066 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1067 default: abort(); // never reached, silence warning
1069 if (type != st->codec->codec_type)
1071 if (*spec++ == ':') { /* possibly followed by :index */
1072 int i, index = strtol(spec, NULL, 0);
1073 for (i = 0; i < s->nb_streams; i++)
1074 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1075 return i == st->index;
1079 } else if (*spec == 'p' && *(spec + 1) == ':') {
1083 prog_id = strtol(spec, &endptr, 0);
1084 for (i = 0; i < s->nb_programs; i++) {
1085 if (s->programs[i]->id != prog_id)
1088 if (*endptr++ == ':') {
1089 int stream_idx = strtol(endptr, NULL, 0);
1090 return stream_idx >= 0 &&
1091 stream_idx < s->programs[i]->nb_stream_indexes &&
1092 st->index == s->programs[i]->stream_index[stream_idx];
1095 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1096 if (st->index == s->programs[i]->stream_index[j])
1100 } else if (!*spec) /* empty specifier, matches everything */
1103 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1104 return AVERROR(EINVAL);
1107 AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
1108 AVFormatContext *s, AVStream *st)
1110 AVDictionary *ret = NULL;
1111 AVDictionaryEntry *t = NULL;
1112 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1113 : AV_OPT_FLAG_DECODING_PARAM;
1115 const AVClass *cc = avcodec_get_class();
1120 switch (codec->type) {
1121 case AVMEDIA_TYPE_VIDEO:
1123 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1125 case AVMEDIA_TYPE_AUDIO:
1127 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1129 case AVMEDIA_TYPE_SUBTITLE:
1131 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1135 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1136 char *p = strchr(t->key, ':');
1138 /* check stream specification in opt name */
1140 switch (check_stream_specifier(s, st, p + 1)) {
1141 case 1: *p = 0; break;
1143 default: return NULL;
1146 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1147 (codec && codec->priv_class &&
1148 av_opt_find(&codec->priv_class, t->key, NULL, flags,
1149 AV_OPT_SEARCH_FAKE_OBJ)))
1150 av_dict_set(&ret, t->key, t->value, 0);
1151 else if (t->key[0] == prefix &&
1152 av_opt_find(&cc, t->key + 1, NULL, flags,
1153 AV_OPT_SEARCH_FAKE_OBJ))
1154 av_dict_set(&ret, t->key + 1, t->value, 0);
1162 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1163 AVDictionary *codec_opts)
1166 AVDictionary **opts;
1170 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1172 av_log(NULL, AV_LOG_ERROR,
1173 "Could not alloc memory for stream options.\n");
1176 for (i = 0; i < s->nb_streams; i++)
1177 opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id),
1182 void *grow_array(void *array, int elem_size, int *size, int new_size)
1184 if (new_size >= INT_MAX / elem_size) {
1185 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1188 if (*size < new_size) {
1189 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1191 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1194 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);