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/imgutils.h"
45 #include "libavutil/parseutils.h"
46 #include "libavutil/pixdesc.h"
47 #include "libavutil/eval.h"
48 #include "libavutil/dict.h"
49 #include "libavutil/opt.h"
53 #include "libavformat/network.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/resource.h>
59 struct SwsContext *sws_opts;
61 AVDictionary *format_opts, *codec_opts;
63 const int this_year = 2012;
65 static FILE *report_file;
71 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
75 swr_opts = swr_alloc();
78 void uninit_opts(void)
81 sws_freeContext(sws_opts);
88 av_dict_free(&format_opts);
89 av_dict_free(&codec_opts);
92 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
94 vfprintf(stdout, fmt, vl);
97 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
101 static int print_prefix = 1;
104 av_log_default_callback(ptr, level, fmt, vl);
105 av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
107 fputs(line, report_file);
111 double parse_number_or_die(const char *context, const char *numstr, int type,
112 double min, double max)
116 double d = av_strtod(numstr, &tail);
118 error = "Expected number for %s but found: %s\n";
119 else if (d < min || d > max)
120 error = "The value for %s was %s which is not within %f - %f\n";
121 else if (type == OPT_INT64 && (int64_t)d != d)
122 error = "Expected int64 for %s but found %s\n";
123 else if (type == OPT_INT && (int)d != d)
124 error = "Expected int for %s but found %s\n";
127 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
132 int64_t parse_time_or_die(const char *context, const char *timestr,
136 if (av_parse_time(&us, timestr, is_duration) < 0) {
137 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
138 is_duration ? "duration" : "date", context, timestr);
144 void show_help_options(const OptionDef *options, const char *msg, int mask,
151 for (po = options; po->name != NULL; po++) {
153 if ((po->flags & mask) == value) {
158 av_strlcpy(buf, po->name, sizeof(buf));
159 if (po->flags & HAS_ARG) {
160 av_strlcat(buf, " ", sizeof(buf));
161 av_strlcat(buf, po->argname, sizeof(buf));
163 printf("-%-17s %s\n", buf, po->help);
168 void show_help_children(const AVClass *class, int flags)
170 const AVClass *child = NULL;
171 av_opt_show2(&class, NULL, flags, 0);
174 while (child = av_opt_child_class_next(class, child))
175 show_help_children(child, flags);
178 static const OptionDef *find_option(const OptionDef *po, const char *name)
180 const char *p = strchr(name, ':');
181 int len = p ? p - name : strlen(name);
183 while (po->name != NULL) {
184 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
191 #if defined(_WIN32) && !defined(__MINGW32CE__)
193 /* Will be leaked on exit */
194 static char** win32_argv_utf8 = NULL;
195 static int win32_argc = 0;
198 * Prepare command line arguments for executable.
199 * For Windows - perform wide-char to UTF-8 conversion.
200 * Input arguments should be main() function arguments.
201 * @param argc_ptr Arguments number (including executable)
202 * @param argv_ptr Arguments list.
204 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
208 int i, buffsize = 0, offset = 0;
210 if (win32_argv_utf8) {
211 *argc_ptr = win32_argc;
212 *argv_ptr = win32_argv_utf8;
217 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
218 if (win32_argc <= 0 || !argv_w)
221 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
222 for (i = 0; i < win32_argc; i++)
223 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
224 NULL, 0, NULL, NULL);
226 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
227 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
228 if (win32_argv_utf8 == NULL) {
233 for (i = 0; i < win32_argc; i++) {
234 win32_argv_utf8[i] = &argstr_flat[offset];
235 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
236 &argstr_flat[offset],
237 buffsize - offset, NULL, NULL);
239 win32_argv_utf8[i] = NULL;
242 *argc_ptr = win32_argc;
243 *argv_ptr = win32_argv_utf8;
246 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
250 #endif /* WIN32 && !__MINGW32CE__ */
252 int parse_option(void *optctx, const char *opt, const char *arg,
253 const OptionDef *options)
260 po = find_option(options, opt);
261 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
262 /* handle 'no' bool option */
263 po = find_option(options, opt + 2);
264 if ((po->name && (po->flags & OPT_BOOL)))
268 po = find_option(options, "default");
270 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
271 return AVERROR(EINVAL);
273 if (po->flags & HAS_ARG && !arg) {
274 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
275 return AVERROR(EINVAL);
278 /* new-style options contain an offset into optctx, old-style address of
280 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
283 if (po->flags & OPT_SPEC) {
284 SpecifierOpt **so = dst;
285 char *p = strchr(opt, ':');
287 dstcount = (int *)(so + 1);
288 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
289 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
290 dst = &(*so)[*dstcount - 1].u;
293 if (po->flags & OPT_STRING) {
295 str = av_strdup(arg);
297 } else if (po->flags & OPT_BOOL) {
298 *(int *)dst = bool_val;
299 } else if (po->flags & OPT_INT) {
300 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
301 } else if (po->flags & OPT_INT64) {
302 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
303 } else if (po->flags & OPT_TIME) {
304 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
305 } else if (po->flags & OPT_FLOAT) {
306 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
307 } else if (po->flags & OPT_DOUBLE) {
308 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
309 } else if (po->u.func_arg) {
310 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
311 : po->u.func_arg(opt, arg);
313 av_log(NULL, AV_LOG_ERROR,
314 "Failed to set value '%s' for option '%s'\n", arg, opt);
318 if (po->flags & OPT_EXIT)
320 return !!(po->flags & HAS_ARG);
323 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
324 void (*parse_arg_function)(void *, const char*))
327 int optindex, handleoptions = 1, ret;
329 /* perform system-dependent conversions for arguments list */
330 prepare_app_arguments(&argc, &argv);
334 while (optindex < argc) {
335 opt = argv[optindex++];
337 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
338 if (opt[1] == '-' && opt[2] == '\0') {
344 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
348 if (parse_arg_function)
349 parse_arg_function(optctx, opt);
354 int locate_option(int argc, char **argv, const OptionDef *options,
360 for (i = 1; i < argc; i++) {
361 const char *cur_opt = argv[i];
363 if (*cur_opt++ != '-')
366 po = find_option(options, cur_opt);
367 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
368 po = find_option(options, cur_opt + 2);
370 if ((!po->name && !strcmp(cur_opt, optname)) ||
371 (po->name && !strcmp(optname, po->name)))
374 if (!po || po->flags & HAS_ARG)
380 static void dump_argument(const char *a)
382 const unsigned char *p;
385 if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
386 *p == '_' || (*p >= 'a' && *p <= 'z')))
389 fputs(a, report_file);
392 fputc('"', report_file);
393 for (p = a; *p; p++) {
394 if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
395 fprintf(report_file, "\\%c", *p);
396 else if (*p < ' ' || *p > '~')
397 fprintf(report_file, "\\x%02x", *p);
399 fputc(*p, report_file);
401 fputc('"', report_file);
404 void parse_loglevel(int argc, char **argv, const OptionDef *options)
406 int idx = locate_option(argc, argv, options, "loglevel");
408 idx = locate_option(argc, argv, options, "v");
409 if (idx && argv[idx + 1])
410 opt_loglevel("loglevel", argv[idx + 1]);
411 idx = locate_option(argc, argv, options, "report");
412 if (idx || getenv("FFREPORT")) {
413 opt_report("report");
416 fprintf(report_file, "Command line:\n");
417 for (i = 0; i < argc; i++) {
418 dump_argument(argv[i]);
419 fputc(i < argc - 1 ? ' ' : '\n', report_file);
426 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
427 int opt_default(const char *opt, const char *arg)
430 char opt_stripped[128];
432 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc, *swr_class;
434 if (!(p = strchr(opt, ':')))
435 p = opt + strlen(opt);
436 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
438 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
439 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
440 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
441 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
442 av_dict_set(&codec_opts, opt, arg, FLAGS);
443 else if ((o = av_opt_find(&fc, opt, NULL, 0,
444 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
445 av_dict_set(&format_opts, opt, arg, FLAGS);
447 sc = sws_get_class();
448 if (!o && (o = av_opt_find(&sc, opt, NULL, 0,
449 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
450 // XXX we only support sws_flags, not arbitrary sws options
451 int ret = av_opt_set(sws_opts, opt, arg, 0);
453 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
458 #if CONFIG_SWRESAMPLE
459 swr_class = swr_get_class();
460 if (!o && (o = av_opt_find(&swr_class, opt, NULL, 0,
461 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
462 int ret = av_opt_set(swr_opts, opt, arg, 0);
464 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
472 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
473 return AVERROR_OPTION_NOT_FOUND;
476 int opt_loglevel(const char *opt, const char *arg)
478 const struct { const char *name; int level; } log_levels[] = {
479 { "quiet" , AV_LOG_QUIET },
480 { "panic" , AV_LOG_PANIC },
481 { "fatal" , AV_LOG_FATAL },
482 { "error" , AV_LOG_ERROR },
483 { "warning", AV_LOG_WARNING },
484 { "info" , AV_LOG_INFO },
485 { "verbose", AV_LOG_VERBOSE },
486 { "debug" , AV_LOG_DEBUG },
492 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
493 if (!strcmp(log_levels[i].name, arg)) {
494 av_log_set_level(log_levels[i].level);
499 level = strtol(arg, &tail, 10);
501 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
502 "Possible levels are numbers or:\n", arg);
503 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
504 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
507 av_log_set_level(level);
511 int opt_report(const char *opt)
517 if (report_file) /* already opened */
520 tm = localtime(&now);
521 snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
523 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
524 tm->tm_hour, tm->tm_min, tm->tm_sec);
525 report_file = fopen(filename, "w");
527 av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
528 filename, strerror(errno));
529 return AVERROR(errno);
531 av_log_set_callback(log_callback_report);
532 av_log(NULL, AV_LOG_INFO,
533 "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
534 "Report written to \"%s\"\n",
536 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
537 tm->tm_hour, tm->tm_min, tm->tm_sec,
539 av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
543 int opt_max_alloc(const char *opt, const char *arg)
548 max = strtol(arg, &tail, 10);
550 av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
557 int opt_cpuflags(const char *opt, const char *arg)
560 unsigned flags = av_get_cpu_flags();
562 if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
565 av_force_cpu_flags(flags);
569 int opt_codec_debug(const char *opt, const char *arg)
571 av_log_set_level(AV_LOG_DEBUG);
572 return opt_default(opt, arg);
575 int opt_timelimit(const char *opt, const char *arg)
578 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
579 struct rlimit rl = { lim, lim + 1 };
580 if (setrlimit(RLIMIT_CPU, &rl))
583 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
588 void print_error(const char *filename, int err)
591 const char *errbuf_ptr = errbuf;
593 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
594 errbuf_ptr = strerror(AVUNERROR(err));
595 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
598 static int warned_cfg = 0;
601 #define SHOW_VERSION 2
602 #define SHOW_CONFIG 4
603 #define SHOW_COPYRIGHT 8
605 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
606 if (CONFIG_##LIBNAME) { \
607 const char *indent = flags & INDENT? " " : ""; \
608 if (flags & SHOW_VERSION) { \
609 unsigned int version = libname##_version(); \
610 av_log(NULL, level, \
611 "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
613 LIB##LIBNAME##_VERSION_MAJOR, \
614 LIB##LIBNAME##_VERSION_MINOR, \
615 LIB##LIBNAME##_VERSION_MICRO, \
616 version >> 16, version >> 8 & 0xff, version & 0xff); \
618 if (flags & SHOW_CONFIG) { \
619 const char *cfg = libname##_configuration(); \
620 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
622 av_log(NULL, level, \
623 "%sWARNING: library configuration mismatch\n", \
627 av_log(NULL, level, "%s%-11s configuration: %s\n", \
628 indent, #libname, cfg); \
633 static void print_all_libs_info(int flags, int level)
635 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
636 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
637 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
638 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
639 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
640 // PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
641 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
642 PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
644 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
648 static void print_program_info(int flags, int level)
650 const char *indent = flags & INDENT? " " : "";
652 av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
653 if (flags & SHOW_COPYRIGHT)
654 av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
655 program_birth_year, this_year);
656 av_log(NULL, level, "\n");
657 av_log(NULL, level, "%sbuilt on %s %s with %s %s\n",
658 indent, __DATE__, __TIME__, CC_TYPE, CC_VERSION);
659 av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
662 void show_banner(int argc, char **argv, const OptionDef *options)
664 int idx = locate_option(argc, argv, options, "version");
668 print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
669 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
670 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
673 int opt_version(const char *opt, const char *arg) {
674 av_log_set_callback(log_callback_help);
675 print_program_info (0 , AV_LOG_INFO);
676 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
680 int opt_license(const char *opt, const char *arg)
684 "This version of %s has nonfree parts compiled in.\n"
685 "Therefore it is not legally redistributable.\n",
688 "%s is free software; you can redistribute it and/or modify\n"
689 "it under the terms of the GNU General Public License as published by\n"
690 "the Free Software Foundation; either version 3 of the License, or\n"
691 "(at your option) any later version.\n"
693 "%s is distributed in the hope that it will be useful,\n"
694 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
695 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
696 "GNU General Public License for more details.\n"
698 "You should have received a copy of the GNU General Public License\n"
699 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
700 program_name, program_name, program_name
702 "%s is free software; you can redistribute it and/or modify\n"
703 "it under the terms of the GNU General Public License as published by\n"
704 "the Free Software Foundation; either version 2 of the License, or\n"
705 "(at your option) any later version.\n"
707 "%s is distributed in the hope that it will be useful,\n"
708 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
709 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
710 "GNU General Public License for more details.\n"
712 "You should have received a copy of the GNU General Public License\n"
713 "along with %s; if not, write to the Free Software\n"
714 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
715 program_name, program_name, program_name
717 "%s is free software; you can redistribute it and/or modify\n"
718 "it under the terms of the GNU Lesser General Public License as published by\n"
719 "the Free Software Foundation; either version 3 of the License, or\n"
720 "(at your option) any later version.\n"
722 "%s is distributed in the hope that it will be useful,\n"
723 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
724 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
725 "GNU Lesser General Public License for more details.\n"
727 "You should have received a copy of the GNU Lesser General Public License\n"
728 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
729 program_name, program_name, program_name
731 "%s is free software; you can redistribute it and/or\n"
732 "modify it under the terms of the GNU Lesser General Public\n"
733 "License as published by the Free Software Foundation; either\n"
734 "version 2.1 of the License, or (at your option) any later version.\n"
736 "%s is distributed in the hope that it will be useful,\n"
737 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
738 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
739 "Lesser General Public License for more details.\n"
741 "You should have received a copy of the GNU Lesser General Public\n"
742 "License along with %s; if not, write to the Free Software\n"
743 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
744 program_name, program_name, program_name
750 int opt_formats(const char *opt, const char *arg)
752 AVInputFormat *ifmt = NULL;
753 AVOutputFormat *ofmt = NULL;
754 const char *last_name;
756 printf("File formats:\n"
757 " D. = Demuxing supported\n"
758 " .E = Muxing supported\n"
764 const char *name = NULL;
765 const char *long_name = NULL;
767 while ((ofmt = av_oformat_next(ofmt))) {
768 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
769 strcmp(ofmt->name, last_name) > 0) {
771 long_name = ofmt->long_name;
775 while ((ifmt = av_iformat_next(ifmt))) {
776 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
777 strcmp(ifmt->name, last_name) > 0) {
779 long_name = ifmt->long_name;
782 if (name && strcmp(ifmt->name, name) == 0)
789 printf(" %s%s %-15s %s\n",
793 long_name ? long_name:" ");
798 static char get_media_type_char(enum AVMediaType type)
800 static const char map[AVMEDIA_TYPE_NB] = {
801 [AVMEDIA_TYPE_VIDEO] = 'V',
802 [AVMEDIA_TYPE_AUDIO] = 'A',
803 [AVMEDIA_TYPE_DATA] = 'D',
804 [AVMEDIA_TYPE_SUBTITLE] = 'S',
805 [AVMEDIA_TYPE_ATTACHMENT] = 'T',
807 return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
810 int opt_codecs(const char *opt, const char *arg)
812 AVCodec *p = NULL, *p2;
813 const char *last_name;
815 " D....... = Decoding supported\n"
816 " .E...... = Encoding supported\n"
817 " ..V..... = Video codec\n"
818 " ..A..... = Audio codec\n"
819 " ..S..... = Subtitle codec\n"
820 " ...S.... = Supports draw_horiz_band\n"
821 " ....D... = Supports direct rendering method 1\n"
822 " .....T.. = Supports weird frame truncation\n"
823 " ......F. = Supports frame-based multi-threaded decoding\n"
824 " ......S. = Supports slice-based multi-threaded decoding\n"
825 " ......B. = Supports both frame-based and slice-based multi-threaded decoding\n"
826 " .......F = Supports frame-based multi-threaded encoding\n"
827 " .......S = Supports slice-based multi-threaded encoding\n"
828 " .......B = Supports both frame-based and slice-based multi-threaded encoding\n"
837 while ((p = av_codec_next(p))) {
838 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
839 strcmp(p->name, last_name) > 0) {
841 decode = encode = cap = 0;
843 if (p2 && strcmp(p->name, p2->name) == 0) {
844 if (av_codec_is_decoder(p))
846 if (av_codec_is_encoder(p))
848 cap |= p->capabilities;
853 last_name = p2->name;
855 printf(" %s%s%c%s%s%s%s%s %-15s %s",
856 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
858 get_media_type_char(p2->type),
859 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
860 cap & CODEC_CAP_DR1 ? "D" : " ",
861 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
863 cap & CODEC_CAP_FRAME_THREADS ? cap & CODEC_CAP_SLICE_THREADS ? "B" : "F" :
864 cap & CODEC_CAP_SLICE_THREADS ? "S" : " "
867 cap & CODEC_CAP_FRAME_THREADS ? cap & CODEC_CAP_SLICE_THREADS ? "B" : "F" :
868 cap & CODEC_CAP_SLICE_THREADS ? "S" : " "
871 p2->long_name ? p2->long_name : "");
873 if (p2->decoder && decode == 0)
874 printf(" use %s for decoding", p2->decoder->name);
879 printf("Note, the names of encoders and decoders do not always match, so there are\n"
880 "several cases where the above table shows encoder only or decoder only entries\n"
881 "even though both encoding and decoding are supported. For example, the h263\n"
882 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
887 int opt_bsfs(const char *opt, const char *arg)
889 AVBitStreamFilter *bsf = NULL;
891 printf("Bitstream filters:\n");
892 while ((bsf = av_bitstream_filter_next(bsf)))
893 printf("%s\n", bsf->name);
898 int opt_protocols(const char *opt, const char *arg)
903 printf("Supported file protocols:\n"
905 while ((name = avio_enum_protocols(&opaque, 0)))
906 printf("%s\n", name);
908 while ((name = avio_enum_protocols(&opaque, 1)))
909 printf("%s\n", name);
913 int opt_filters(const char *opt, const char *arg)
915 AVFilter av_unused(**filter) = NULL;
916 char descr[64], *descr_cur;
918 const AVFilterPad *pad;
920 printf("Filters:\n");
922 while ((filter = av_filter_next(filter)) && *filter) {
924 for (i = 0; i < 2; i++) {
926 *(descr_cur++) = '-';
927 *(descr_cur++) = '>';
929 pad = i ? (*filter)->outputs : (*filter)->inputs;
930 for (j = 0; pad[j].name; j++) {
931 if (descr_cur >= descr + sizeof(descr) - 4)
933 *(descr_cur++) = get_media_type_char(pad[j].type);
936 *(descr_cur++) = '|';
939 printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
945 int opt_pix_fmts(const char *opt, const char *arg)
947 enum PixelFormat pix_fmt;
949 printf("Pixel formats:\n"
950 "I.... = Supported Input format for conversion\n"
951 ".O... = Supported Output format for conversion\n"
952 "..H.. = Hardware accelerated format\n"
953 "...P. = Paletted format\n"
954 "....B = Bitstream format\n"
955 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
959 # define sws_isSupportedInput(x) 0
960 # define sws_isSupportedOutput(x) 0
963 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
964 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
967 printf("%c%c%c%c%c %-16s %d %2d\n",
968 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
969 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
970 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
971 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
972 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
974 pix_desc->nb_components,
975 av_get_bits_per_pixel(pix_desc));
980 int show_sample_fmts(const char *opt, const char *arg)
984 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
985 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
992 int yesno = (toupper(c) == 'Y');
994 while (c != '\n' && c != EOF)
1000 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
1003 FILE *f = fopen(filename, "rb");
1006 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
1008 return AVERROR(errno);
1010 fseek(f, 0, SEEK_END);
1012 fseek(f, 0, SEEK_SET);
1013 *bufptr = av_malloc(*size + 1);
1015 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
1017 return AVERROR(ENOMEM);
1019 ret = fread(*bufptr, 1, *size, f);
1023 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1024 filename, strerror(errno));
1025 ret = AVERROR(errno);
1030 (*bufptr)[*size++] = '\0';
1037 FILE *get_preset_file(char *filename, size_t filename_size,
1038 const char *preset_name, int is_path,
1039 const char *codec_name)
1043 const char *base[3] = { getenv("FFMPEG_DATADIR"),
1048 av_strlcpy(filename, preset_name, filename_size);
1049 f = fopen(filename, "r");
1052 char datadir[MAX_PATH], *ls;
1055 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1057 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1058 if (*ls == '\\') *ls = '/';
1060 if (ls = strrchr(datadir, '/'))
1063 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
1068 for (i = 0; i < 3 && !f; i++) {
1071 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1072 i != 1 ? "" : "/.ffmpeg", preset_name);
1073 f = fopen(filename, "r");
1074 if (!f && codec_name) {
1075 snprintf(filename, filename_size,
1076 "%s%s/%s-%s.ffpreset",
1077 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1079 f = fopen(filename, "r");
1087 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1089 if (*spec <= '9' && *spec >= '0') /* opt:index */
1090 return strtol(spec, NULL, 0) == st->index;
1091 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1092 *spec == 't') { /* opt:[vasdt] */
1093 enum AVMediaType type;
1096 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
1097 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
1098 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
1099 case 'd': type = AVMEDIA_TYPE_DATA; break;
1100 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1101 default: av_assert0(0);
1103 if (type != st->codec->codec_type)
1105 if (*spec++ == ':') { /* possibly followed by :index */
1106 int i, index = strtol(spec, NULL, 0);
1107 for (i = 0; i < s->nb_streams; i++)
1108 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1109 return i == st->index;
1113 } else if (*spec == 'p' && *(spec + 1) == ':') {
1117 prog_id = strtol(spec, &endptr, 0);
1118 for (i = 0; i < s->nb_programs; i++) {
1119 if (s->programs[i]->id != prog_id)
1122 if (*endptr++ == ':') {
1123 int stream_idx = strtol(endptr, NULL, 0);
1124 return stream_idx >= 0 &&
1125 stream_idx < s->programs[i]->nb_stream_indexes &&
1126 st->index == s->programs[i]->stream_index[stream_idx];
1129 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1130 if (st->index == s->programs[i]->stream_index[j])
1134 } else if (*spec == '#') {
1137 sid = strtol(spec + 1, &endptr, 0);
1139 return st->id == sid;
1140 } else if (!*spec) /* empty specifier, matches everything */
1143 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1144 return AVERROR(EINVAL);
1147 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
1148 AVFormatContext *s, AVStream *st, AVCodec *codec)
1150 AVDictionary *ret = NULL;
1151 AVDictionaryEntry *t = NULL;
1152 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1153 : AV_OPT_FLAG_DECODING_PARAM;
1155 const AVClass *cc = avcodec_get_class();
1158 codec = s->oformat ? avcodec_find_encoder(codec_id)
1159 : avcodec_find_decoder(codec_id);
1163 switch (codec->type) {
1164 case AVMEDIA_TYPE_VIDEO:
1166 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1168 case AVMEDIA_TYPE_AUDIO:
1170 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1172 case AVMEDIA_TYPE_SUBTITLE:
1174 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1178 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1179 char *p = strchr(t->key, ':');
1181 /* check stream specification in opt name */
1183 switch (check_stream_specifier(s, st, p + 1)) {
1184 case 1: *p = 0; break;
1186 default: return NULL;
1189 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1190 (codec && codec->priv_class &&
1191 av_opt_find(&codec->priv_class, t->key, NULL, flags,
1192 AV_OPT_SEARCH_FAKE_OBJ)))
1193 av_dict_set(&ret, t->key, t->value, 0);
1194 else if (t->key[0] == prefix &&
1195 av_opt_find(&cc, t->key + 1, NULL, flags,
1196 AV_OPT_SEARCH_FAKE_OBJ))
1197 av_dict_set(&ret, t->key + 1, t->value, 0);
1205 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1206 AVDictionary *codec_opts)
1209 AVDictionary **opts;
1213 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1215 av_log(NULL, AV_LOG_ERROR,
1216 "Could not alloc memory for stream options.\n");
1219 for (i = 0; i < s->nb_streams; i++)
1220 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1221 s, s->streams[i], NULL);
1225 void *grow_array(void *array, int elem_size, int *size, int new_size)
1227 if (new_size >= INT_MAX / elem_size) {
1228 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1231 if (*size < new_size) {
1232 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1234 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1237 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1244 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1246 FrameBuffer *buf = av_mallocz(sizeof(*buf));
1248 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1249 int h_chroma_shift, v_chroma_shift;
1250 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1251 int w = s->width, h = s->height;
1254 return AVERROR(ENOMEM);
1256 avcodec_align_dimensions(s, &w, &h);
1258 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1263 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1264 s->pix_fmt, 32)) < 0) {
1266 av_log(s, AV_LOG_ERROR, "alloc_buffer: av_image_alloc() failed\n");
1269 /* XXX this shouldn't be needed, but some tests break without this line
1270 * those decoders are buggy and need to be fixed.
1271 * the following tests fail:
1272 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1274 memset(buf->base[0], 128, ret);
1276 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1277 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1278 const int h_shift = i==0 ? 0 : h_chroma_shift;
1279 const int v_shift = i==0 ? 0 : v_chroma_shift;
1280 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
1281 buf->data[i] = buf->base[i];
1283 buf->data[i] = buf->base[i] +
1284 FFALIGN((buf->linesize[i]*edge >> v_shift) +
1285 (pixel_size*edge >> h_shift), 32);
1289 buf->pix_fmt = s->pix_fmt;
1296 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1298 FrameBuffer **pool = s->opaque;
1302 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0) {
1303 av_log(s, AV_LOG_ERROR, "codec_get_buffer: image parameters invalid\n");
1307 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1313 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1314 av_freep(&buf->base[0]);
1316 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1319 av_assert0(!buf->refcount);
1322 frame->opaque = buf;
1323 frame->type = FF_BUFFER_TYPE_USER;
1324 frame->extended_data = frame->data;
1325 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1326 frame->width = buf->w;
1327 frame->height = buf->h;
1328 frame->format = buf->pix_fmt;
1329 frame->sample_aspect_ratio = s->sample_aspect_ratio;
1331 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1332 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
1333 frame->data[i] = buf->data[i];
1334 frame->linesize[i] = buf->linesize[i];
1340 static void unref_buffer(FrameBuffer *buf)
1342 FrameBuffer **pool = buf->pool;
1344 av_assert0(buf->refcount > 0);
1346 if (!buf->refcount) {
1348 for(tmp= *pool; tmp; tmp= tmp->next)
1349 av_assert1(tmp != buf);
1356 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1358 FrameBuffer *buf = frame->opaque;
1361 if(frame->type!=FF_BUFFER_TYPE_USER) {
1362 avcodec_default_release_buffer(s, frame);
1366 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1367 frame->data[i] = NULL;
1372 void filter_release_buffer(AVFilterBuffer *fb)
1374 FrameBuffer *buf = fb->priv;
1379 void free_buffer_pool(FrameBuffer **pool)
1381 FrameBuffer *buf = *pool;
1384 av_freep(&buf->base[0]);