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 "libpostproc/postprocess.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/eval.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/opt.h"
46 #include "libavformat/network.h"
48 #if HAVE_SYS_RESOURCE_H
49 #include <sys/resource.h>
52 const char **opt_names;
53 const char **opt_values;
54 static int opt_name_count;
55 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
56 AVFormatContext *avformat_opts;
57 struct SwsContext *sws_opts;
58 AVDictionary *format_opts, *video_opts, *audio_opts, *sub_opts;
60 static const int this_year = 2011;
65 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
66 avcodec_opts[i] = avcodec_alloc_context2(i);
67 avformat_opts = avformat_alloc_context();
69 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
73 void uninit_opts(void)
76 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
77 av_freep(&avcodec_opts[i]);
78 av_freep(&avformat_opts->key);
79 av_freep(&avformat_opts);
81 sws_freeContext(sws_opts);
84 for (i = 0; i < opt_name_count; i++) {
85 av_freep(&opt_names[i]);
86 av_freep(&opt_values[i]);
89 av_freep(&opt_values);
91 av_dict_free(&format_opts);
92 av_dict_free(&video_opts);
93 av_dict_free(&audio_opts);
94 av_dict_free(&sub_opts);
97 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
99 vfprintf(stdout, fmt, vl);
102 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
106 double d = av_strtod(numstr, &tail);
108 error= "Expected number for %s but found: %s\n";
109 else if (d < min || d > max)
110 error= "The value for %s was %s which is not within %f - %f\n";
111 else if(type == OPT_INT64 && (int64_t)d != d)
112 error= "Expected int64 for %s but found %s\n";
113 else if (type == OPT_INT && (int)d != d)
114 error= "Expected int for %s but found %s\n";
117 fprintf(stderr, error, context, numstr, min, max);
121 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
124 if (av_parse_time(&us, timestr, is_duration) < 0) {
125 fprintf(stderr, "Invalid %s specification for %s: %s\n",
126 is_duration ? "duration" : "date", context, timestr);
132 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
138 for(po = options; po->name != NULL; po++) {
140 if ((po->flags & mask) == value) {
145 av_strlcpy(buf, po->name, sizeof(buf));
146 if (po->flags & HAS_ARG) {
147 av_strlcat(buf, " ", sizeof(buf));
148 av_strlcat(buf, po->argname, sizeof(buf));
150 printf("-%-17s %s\n", buf, po->help);
155 static const OptionDef* find_option(const OptionDef *po, const char *name){
156 while (po->name != NULL) {
157 if (!strcmp(name, po->name))
164 #if defined(_WIN32) && !defined(__MINGW32CE__)
166 /* Will be leaked on exit */
167 static char** win32_argv_utf8 = NULL;
168 static int win32_argc = 0;
171 * Prepare command line arguments for executable.
172 * For Windows - perform wide-char to UTF-8 conversion.
173 * Input arguments should be main() function arguments.
174 * @param argc_ptr Arguments number (including executable)
175 * @param argv_ptr Arguments list.
177 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
181 int i, buffsize = 0, offset = 0;
183 if (win32_argv_utf8) {
184 *argc_ptr = win32_argc;
185 *argv_ptr = win32_argv_utf8;
190 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
191 if (win32_argc <= 0 || !argv_w)
194 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
195 for (i = 0; i < win32_argc; i++)
196 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
197 NULL, 0, NULL, NULL);
199 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
200 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
201 if (win32_argv_utf8 == NULL) {
206 for (i = 0; i < win32_argc; i++) {
207 win32_argv_utf8[i] = &argstr_flat[offset];
208 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
209 &argstr_flat[offset],
210 buffsize - offset, NULL, NULL);
212 win32_argv_utf8[i] = NULL;
215 *argc_ptr = win32_argc;
216 *argv_ptr = win32_argv_utf8;
219 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
223 #endif /* WIN32 && !__MINGW32CE__ */
225 void parse_options(int argc, char **argv, const OptionDef *options,
226 int (* parse_arg_function)(const char *opt, const char *arg))
228 const char *opt, *arg;
229 int optindex, handleoptions=1;
232 /* perform system-dependent conversions for arguments list */
233 prepare_app_arguments(&argc, &argv);
237 while (optindex < argc) {
238 opt = argv[optindex++];
240 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
242 if (opt[1] == '-' && opt[2] == '\0') {
247 po= find_option(options, opt);
248 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
249 /* handle 'no' bool option */
250 po = find_option(options, opt + 2);
251 if (!(po->name && (po->flags & OPT_BOOL)))
256 po= find_option(options, "default");
259 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
263 if (po->flags & HAS_ARG) {
264 arg = argv[optindex++];
266 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
270 if (po->flags & OPT_STRING) {
272 str = av_strdup(arg);
273 *po->u.str_arg = str;
274 } else if (po->flags & OPT_BOOL) {
275 *po->u.int_arg = bool_val;
276 } else if (po->flags & OPT_INT) {
277 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
278 } else if (po->flags & OPT_INT64) {
279 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
280 } else if (po->flags & OPT_FLOAT) {
281 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
282 } else if (po->u.func_arg) {
283 if (po->u.func_arg(opt, arg) < 0) {
284 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg ? arg : "[null]", opt);
288 if(po->flags & OPT_EXIT)
291 if (parse_arg_function) {
292 if (parse_arg_function(NULL, opt) < 0)
299 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
300 #define SET_PREFIXED_OPTS(ch, flag, output) \
301 if (opt[0] == ch && avcodec_opts[0] && (o = av_opt_find(avcodec_opts[0], opt+1, NULL, flag, 0)))\
302 av_dict_set(&output, opt+1, arg, FLAGS);
303 static int opt_default2(const char *opt, const char *arg)
306 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
307 if (o->flags & AV_OPT_FLAG_VIDEO_PARAM)
308 av_dict_set(&video_opts, opt, arg, FLAGS);
309 if (o->flags & AV_OPT_FLAG_AUDIO_PARAM)
310 av_dict_set(&audio_opts, opt, arg, FLAGS);
311 if (o->flags & AV_OPT_FLAG_SUBTITLE_PARAM)
312 av_dict_set(&sub_opts, opt, arg, FLAGS);
313 } else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
314 av_dict_set(&format_opts, opt, arg, FLAGS);
315 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
316 // XXX we only support sws_flags, not arbitrary sws options
317 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
319 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
325 SET_PREFIXED_OPTS('v', AV_OPT_FLAG_VIDEO_PARAM, video_opts)
326 SET_PREFIXED_OPTS('a', AV_OPT_FLAG_AUDIO_PARAM, audio_opts)
327 SET_PREFIXED_OPTS('s', AV_OPT_FLAG_SUBTITLE_PARAM, sub_opts)
332 fprintf(stderr, "Unrecognized option '%s'\n", opt);
333 return AVERROR_OPTION_NOT_FOUND;
336 int opt_default(const char *opt, const char *arg){
339 const AVOption *o= NULL;
340 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
342 AVOutputFormat *oformat = NULL;
343 AVInputFormat *iformat = NULL;
345 while ((p = av_codec_next(p))) {
346 const AVClass *c = p->priv_class;
347 if (c && av_find_opt(&c, opt, NULL, 0, 0))
352 while ((oformat = av_oformat_next(oformat))) {
353 const AVClass *c = oformat->priv_class;
354 if (c && av_find_opt(&c, opt, NULL, 0, 0))
359 while ((iformat = av_iformat_next(iformat))) {
360 const AVClass *c = iformat->priv_class;
361 if (c && av_find_opt(&c, opt, NULL, 0, 0))
367 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
368 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
370 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
372 if(!o && avformat_opts)
373 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
375 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
377 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
378 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
379 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
380 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
381 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
382 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
387 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
391 fprintf(stderr, "Unrecognized option '%s'\n", opt);
396 if ((ret = opt_default2(opt, arg)) < 0)
399 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
401 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
402 opt_values[opt_name_count] = av_strdup(arg);
403 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
404 opt_names[opt_name_count++] = av_strdup(opt);
406 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
407 av_log_set_level(AV_LOG_DEBUG);
411 int opt_loglevel(const char *opt, const char *arg)
413 const struct { const char *name; int level; } log_levels[] = {
414 { "quiet" , AV_LOG_QUIET },
415 { "panic" , AV_LOG_PANIC },
416 { "fatal" , AV_LOG_FATAL },
417 { "error" , AV_LOG_ERROR },
418 { "warning", AV_LOG_WARNING },
419 { "info" , AV_LOG_INFO },
420 { "verbose", AV_LOG_VERBOSE },
421 { "debug" , AV_LOG_DEBUG },
427 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
428 if (!strcmp(log_levels[i].name, arg)) {
429 av_log_set_level(log_levels[i].level);
434 level = strtol(arg, &tail, 10);
436 fprintf(stderr, "Invalid loglevel \"%s\". "
437 "Possible levels are numbers or:\n", arg);
438 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
439 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
442 av_log_set_level(level);
446 int opt_timelimit(const char *opt, const char *arg)
449 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
450 struct rlimit rl = { lim, lim + 1 };
451 if (setrlimit(RLIMIT_CPU, &rl))
454 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
459 static void *alloc_priv_context(int size, const AVClass *class)
461 void *p = av_mallocz(size);
463 *(const AVClass **)p = class;
464 av_opt_set_defaults(p);
469 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
473 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
474 AVCodecContext *avctx= ctx;
475 if(codec && codec->priv_class){
476 if(!avctx->priv_data && codec->priv_data_size)
477 avctx->priv_data= alloc_priv_context(codec->priv_data_size, codec->priv_class);
478 priv_ctx= avctx->priv_data;
480 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
481 AVFormatContext *avctx = ctx;
482 if (avctx->oformat && avctx->oformat->priv_class) {
483 priv_ctx = avctx->priv_data;
484 } else if (avctx->iformat && avctx->iformat->priv_class) {
485 priv_ctx = avctx->priv_data;
489 for(i=0; i<opt_name_count; i++){
494 if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
495 if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL) < 0) {
496 fprintf(stderr, "Invalid value '%s' for option '%s'\n",
497 opt_names[i], opt_values[i]);
504 str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
505 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
506 if (str && ((opt->flags & flags) == flags))
507 av_set_string3(ctx, opt_names[i], str, 1, NULL);
512 void print_error(const char *filename, int err)
515 const char *errbuf_ptr = errbuf;
517 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
518 errbuf_ptr = strerror(AVUNERROR(err));
519 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
522 static int warned_cfg = 0;
525 #define SHOW_VERSION 2
526 #define SHOW_CONFIG 4
528 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
529 if (CONFIG_##LIBNAME) { \
530 const char *indent = flags & INDENT? " " : ""; \
531 if (flags & SHOW_VERSION) { \
532 unsigned int version = libname##_version(); \
533 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
535 LIB##LIBNAME##_VERSION_MAJOR, \
536 LIB##LIBNAME##_VERSION_MINOR, \
537 LIB##LIBNAME##_VERSION_MICRO, \
538 version >> 16, version >> 8 & 0xff, version & 0xff); \
540 if (flags & SHOW_CONFIG) { \
541 const char *cfg = libname##_configuration(); \
542 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
545 "%sWARNING: library configuration mismatch\n", \
549 fprintf(stderr, "%s%-11s configuration: %s\n", \
550 indent, #libname, cfg); \
555 static void print_all_libs_info(FILE* outstream, int flags)
557 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
558 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
559 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
560 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
561 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
562 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
563 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
566 void show_banner(void)
568 fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
569 program_name, program_birth_year, this_year);
570 fprintf(stderr, " built on %s %s with %s %s\n",
571 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
572 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
573 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
574 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
577 void show_version(void) {
578 printf("%s " FFMPEG_VERSION "\n", program_name);
579 print_all_libs_info(stdout, SHOW_VERSION);
582 void show_license(void)
586 "This version of %s has nonfree parts compiled in.\n"
587 "Therefore it is not legally redistributable.\n",
590 "%s is free software; you can redistribute it and/or modify\n"
591 "it under the terms of the GNU General Public License as published by\n"
592 "the Free Software Foundation; either version 3 of the License, or\n"
593 "(at your option) any later version.\n"
595 "%s is distributed in the hope that it will be useful,\n"
596 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
597 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
598 "GNU General Public License for more details.\n"
600 "You should have received a copy of the GNU General Public License\n"
601 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
602 program_name, program_name, program_name
604 "%s is free software; you can redistribute it and/or modify\n"
605 "it under the terms of the GNU General Public License as published by\n"
606 "the Free Software Foundation; either version 2 of the License, or\n"
607 "(at your option) any later version.\n"
609 "%s is distributed in the hope that it will be useful,\n"
610 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
611 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
612 "GNU General Public License for more details.\n"
614 "You should have received a copy of the GNU General Public License\n"
615 "along with %s; if not, write to the Free Software\n"
616 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
617 program_name, program_name, program_name
619 "%s is free software; you can redistribute it and/or modify\n"
620 "it under the terms of the GNU Lesser General Public License as published by\n"
621 "the Free Software Foundation; either version 3 of the License, or\n"
622 "(at your option) any later version.\n"
624 "%s is distributed in the hope that it will be useful,\n"
625 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
626 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
627 "GNU Lesser General Public License for more details.\n"
629 "You should have received a copy of the GNU Lesser General Public License\n"
630 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
631 program_name, program_name, program_name
633 "%s is free software; you can redistribute it and/or\n"
634 "modify it under the terms of the GNU Lesser General Public\n"
635 "License as published by the Free Software Foundation; either\n"
636 "version 2.1 of the License, or (at your option) any later version.\n"
638 "%s is distributed in the hope that it will be useful,\n"
639 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
640 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
641 "Lesser General Public License for more details.\n"
643 "You should have received a copy of the GNU Lesser General Public\n"
644 "License along with %s; if not, write to the Free Software\n"
645 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
646 program_name, program_name, program_name
651 void show_formats(void)
653 AVInputFormat *ifmt=NULL;
654 AVOutputFormat *ofmt=NULL;
655 const char *last_name;
659 " D. = Demuxing supported\n"
660 " .E = Muxing supported\n"
666 const char *name=NULL;
667 const char *long_name=NULL;
669 while((ofmt= av_oformat_next(ofmt))) {
670 if((name == NULL || strcmp(ofmt->name, name)<0) &&
671 strcmp(ofmt->name, last_name)>0){
673 long_name= ofmt->long_name;
677 while((ifmt= av_iformat_next(ifmt))) {
678 if((name == NULL || strcmp(ifmt->name, name)<0) &&
679 strcmp(ifmt->name, last_name)>0){
681 long_name= ifmt->long_name;
684 if(name && strcmp(ifmt->name, name)==0)
696 long_name ? long_name:" ");
700 void show_codecs(void)
702 AVCodec *p=NULL, *p2;
703 const char *last_name;
706 " D..... = Decoding supported\n"
707 " .E.... = Encoding supported\n"
708 " ..V... = Video codec\n"
709 " ..A... = Audio codec\n"
710 " ..S... = Subtitle codec\n"
711 " ...S.. = Supports draw_horiz_band\n"
712 " ....D. = Supports direct rendering method 1\n"
713 " .....T = Supports weird frame truncation\n"
720 const char *type_str;
723 while((p= av_codec_next(p))) {
724 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
725 strcmp(p->name, last_name)>0){
727 decode= encode= cap=0;
729 if(p2 && strcmp(p->name, p2->name)==0){
730 if(p->decode) decode=1;
731 if(p->encode) encode=1;
732 cap |= p->capabilities;
740 case AVMEDIA_TYPE_VIDEO:
743 case AVMEDIA_TYPE_AUDIO:
746 case AVMEDIA_TYPE_SUBTITLE:
754 " %s%s%s%s%s%s %-15s %s",
755 decode ? "D": (/*p2->decoder ? "d":*/" "),
758 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
759 cap & CODEC_CAP_DR1 ? "D":" ",
760 cap & CODEC_CAP_TRUNCATED ? "T":" ",
762 p2->long_name ? p2->long_name : "");
763 /* if(p2->decoder && decode==0)
764 printf(" use %s for decoding", p2->decoder->name);*/
769 "Note, the names of encoders and decoders do not always match, so there are\n"
770 "several cases where the above table shows encoder only or decoder only entries\n"
771 "even though both encoding and decoding are supported. For example, the h263\n"
772 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
778 AVBitStreamFilter *bsf=NULL;
780 printf("Bitstream filters:\n");
781 while((bsf = av_bitstream_filter_next(bsf)))
782 printf("%s\n", bsf->name);
786 void show_protocols(void)
788 URLProtocol *up=NULL;
790 printf("Supported file protocols:\n"
791 "I.. = Input supported\n"
792 ".O. = Output supported\n"
793 "..S = Seek supported\n"
796 while((up = av_protocol_next(up)))
797 printf("%c%c%c %s\n",
798 up->url_read ? 'I' : '.',
799 up->url_write ? 'O' : '.',
800 up->url_seek ? 'S' : '.',
804 void show_filters(void)
806 AVFilter av_unused(**filter) = NULL;
808 printf("Filters:\n");
810 while ((filter = av_filter_next(filter)) && *filter)
811 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
815 void show_pix_fmts(void)
817 enum PixelFormat pix_fmt;
821 "I.... = Supported Input format for conversion\n"
822 ".O... = Supported Output format for conversion\n"
823 "..H.. = Hardware accelerated format\n"
824 "...P. = Paletted format\n"
825 "....B = Bitstream format\n"
826 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
830 # define sws_isSupportedInput(x) 0
831 # define sws_isSupportedOutput(x) 0
834 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
835 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
836 printf("%c%c%c%c%c %-16s %d %2d\n",
837 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
838 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
839 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
840 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
841 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
843 pix_desc->nb_components,
844 av_get_bits_per_pixel(pix_desc));
851 int yesno = (toupper(c) == 'Y');
853 while (c != '\n' && c != EOF)
859 int read_file(const char *filename, char **bufptr, size_t *size)
861 FILE *f = fopen(filename, "rb");
864 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
865 return AVERROR(errno);
867 fseek(f, 0, SEEK_END);
869 fseek(f, 0, SEEK_SET);
870 *bufptr = av_malloc(*size + 1);
872 fprintf(stderr, "Could not allocate file buffer\n");
874 return AVERROR(ENOMEM);
876 fread(*bufptr, 1, *size, f);
877 (*bufptr)[*size++] = '\0';
883 FILE *get_preset_file(char *filename, size_t filename_size,
884 const char *preset_name, int is_path, const char *codec_name)
888 const char *base[3]= { getenv("FFMPEG_DATADIR"),
894 av_strlcpy(filename, preset_name, filename_size);
895 f = fopen(filename, "r");
898 char datadir[MAX_PATH], *ls;
901 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
903 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
904 if (*ls == '\\') *ls = '/';
906 if (ls = strrchr(datadir, '/'))
909 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
914 for (i = 0; i < 3 && !f; i++) {
917 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
918 f = fopen(filename, "r");
919 if (!f && codec_name) {
920 snprintf(filename, filename_size,
921 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
922 f = fopen(filename, "r");