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 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
53 AVFormatContext *avformat_opts;
54 struct SwsContext *sws_opts;
55 AVDictionary *format_opts, *codec_opts;
57 static const int this_year = 2011;
62 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
63 avcodec_opts[i] = avcodec_alloc_context3(NULL);
64 avformat_opts = avformat_alloc_context();
66 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
70 void uninit_opts(void)
73 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
74 av_freep(&avcodec_opts[i]);
75 av_freep(&avformat_opts->key);
76 av_freep(&avformat_opts);
78 sws_freeContext(sws_opts);
81 av_dict_free(&format_opts);
82 av_dict_free(&codec_opts);
85 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
87 vfprintf(stdout, fmt, vl);
90 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
94 double d = av_strtod(numstr, &tail);
96 error= "Expected number for %s but found: %s\n";
97 else if (d < min || d > max)
98 error= "The value for %s was %s which is not within %f - %f\n";
99 else if(type == OPT_INT64 && (int64_t)d != d)
100 error= "Expected int64 for %s but found %s\n";
101 else if (type == OPT_INT && (int)d != d)
102 error= "Expected int for %s but found %s\n";
105 fprintf(stderr, error, context, numstr, min, max);
109 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
112 if (av_parse_time(&us, timestr, is_duration) < 0) {
113 fprintf(stderr, "Invalid %s specification for %s: %s\n",
114 is_duration ? "duration" : "date", context, timestr);
120 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
126 for(po = options; po->name != NULL; po++) {
128 if ((po->flags & mask) == value) {
133 av_strlcpy(buf, po->name, sizeof(buf));
134 if (po->flags & HAS_ARG) {
135 av_strlcat(buf, " ", sizeof(buf));
136 av_strlcat(buf, po->argname, sizeof(buf));
138 printf("-%-17s %s\n", buf, po->help);
143 static const OptionDef* find_option(const OptionDef *po, const char *name){
144 while (po->name != NULL) {
145 if (!strcmp(name, po->name))
152 #if defined(_WIN32) && !defined(__MINGW32CE__)
154 /* Will be leaked on exit */
155 static char** win32_argv_utf8 = NULL;
156 static int win32_argc = 0;
159 * Prepare command line arguments for executable.
160 * For Windows - perform wide-char to UTF-8 conversion.
161 * Input arguments should be main() function arguments.
162 * @param argc_ptr Arguments number (including executable)
163 * @param argv_ptr Arguments list.
165 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
169 int i, buffsize = 0, offset = 0;
171 if (win32_argv_utf8) {
172 *argc_ptr = win32_argc;
173 *argv_ptr = win32_argv_utf8;
178 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
179 if (win32_argc <= 0 || !argv_w)
182 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
183 for (i = 0; i < win32_argc; i++)
184 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
185 NULL, 0, NULL, NULL);
187 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
188 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
189 if (win32_argv_utf8 == NULL) {
194 for (i = 0; i < win32_argc; i++) {
195 win32_argv_utf8[i] = &argstr_flat[offset];
196 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
197 &argstr_flat[offset],
198 buffsize - offset, NULL, NULL);
200 win32_argv_utf8[i] = NULL;
203 *argc_ptr = win32_argc;
204 *argv_ptr = win32_argv_utf8;
207 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
211 #endif /* WIN32 && !__MINGW32CE__ */
213 void parse_options(int argc, char **argv, const OptionDef *options,
214 int (* parse_arg_function)(const char *opt, const char *arg))
216 const char *opt, *arg;
217 int optindex, handleoptions=1;
220 /* perform system-dependent conversions for arguments list */
221 prepare_app_arguments(&argc, &argv);
225 while (optindex < argc) {
226 opt = argv[optindex++];
228 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
230 if (opt[1] == '-' && opt[2] == '\0') {
235 po= find_option(options, opt);
236 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
237 /* handle 'no' bool option */
238 po = find_option(options, opt + 2);
239 if (!(po->name && (po->flags & OPT_BOOL)))
244 po= find_option(options, "default");
247 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
251 if (po->flags & HAS_ARG) {
252 arg = argv[optindex++];
254 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
258 if (po->flags & OPT_STRING) {
260 str = av_strdup(arg);
261 *po->u.str_arg = str;
262 } else if (po->flags & OPT_BOOL) {
263 *po->u.int_arg = bool_val;
264 } else if (po->flags & OPT_INT) {
265 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
266 } else if (po->flags & OPT_INT64) {
267 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
268 } else if (po->flags & OPT_FLOAT) {
269 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
270 } else if (po->u.func_arg) {
271 if (po->u.func_arg(opt, arg) < 0) {
272 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg ? arg : "[null]", opt);
276 if(po->flags & OPT_EXIT)
279 if (parse_arg_function) {
280 if (parse_arg_function(NULL, opt) < 0)
287 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
288 int opt_default(const char *opt, const char *arg)
291 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)) ||
292 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
293 (o = av_opt_find(avcodec_opts[0], opt+1, NULL, 0, 0))))
294 av_dict_set(&codec_opts, opt, arg, FLAGS);
295 else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
296 av_dict_set(&format_opts, opt, arg, FLAGS);
297 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
298 // XXX we only support sws_flags, not arbitrary sws options
299 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
301 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
308 fprintf(stderr, "Unrecognized option '%s'\n", opt);
309 return AVERROR_OPTION_NOT_FOUND;
313 int opt_default(const char *opt, const char *arg){
316 const AVOption *o= NULL;
317 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
319 AVOutputFormat *oformat = NULL;
320 AVInputFormat *iformat = NULL;
322 while ((p = av_codec_next(p))) {
323 const AVClass *c = p->priv_class;
324 if (c && av_find_opt(&c, opt, NULL, 0, 0))
329 while ((oformat = av_oformat_next(oformat))) {
330 const AVClass *c = oformat->priv_class;
331 if (c && av_find_opt(&c, opt, NULL, 0, 0))
336 while ((iformat = av_iformat_next(iformat))) {
337 const AVClass *c = iformat->priv_class;
338 if (c && av_find_opt(&c, opt, NULL, 0, 0))
344 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
345 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
347 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
349 if(!o && avformat_opts)
350 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
352 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
354 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
355 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
356 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
357 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
358 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
359 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
364 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
368 fprintf(stderr, "Unrecognized option '%s'\n", opt);
373 if ((ret = opt_default2(opt, arg)) < 0)
376 // 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));
378 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
379 opt_values[opt_name_count] = av_strdup(arg);
380 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
381 opt_names[opt_name_count++] = av_strdup(opt);
383 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
384 av_log_set_level(AV_LOG_DEBUG);
388 ||||||| merged common ancestors
389 int opt_default(const char *opt, const char *arg){
392 const AVOption *o= NULL;
393 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
395 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
396 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
398 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
400 if(!o && avformat_opts)
401 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
403 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
405 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
406 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
407 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
408 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
409 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
410 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
413 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
418 AVOutputFormat *oformat = NULL;
419 while ((p=av_codec_next(p))){
420 const AVClass *c = p->priv_class;
421 if(c && av_opt_find(&c, opt, NULL, 0, 0))
425 while ((oformat = av_oformat_next(oformat))) {
426 const AVClass *c = oformat->priv_class;
427 if (c && av_opt_find(&c, opt, NULL, 0, 0))
433 if ((ret = opt_default2(opt, arg)) < 0)
436 // 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));
438 //FIXME we should always use avcodec_opts, ... for storing options so there will not be any need to keep track of what i set over this
439 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
440 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
441 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
442 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
444 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
445 av_log_set_level(AV_LOG_DEBUG);
452 int opt_loglevel(const char *opt, const char *arg)
454 const struct { const char *name; int level; } log_levels[] = {
455 { "quiet" , AV_LOG_QUIET },
456 { "panic" , AV_LOG_PANIC },
457 { "fatal" , AV_LOG_FATAL },
458 { "error" , AV_LOG_ERROR },
459 { "warning", AV_LOG_WARNING },
460 { "info" , AV_LOG_INFO },
461 { "verbose", AV_LOG_VERBOSE },
462 { "debug" , AV_LOG_DEBUG },
468 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
469 if (!strcmp(log_levels[i].name, arg)) {
470 av_log_set_level(log_levels[i].level);
475 level = strtol(arg, &tail, 10);
477 fprintf(stderr, "Invalid loglevel \"%s\". "
478 "Possible levels are numbers or:\n", arg);
479 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
480 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
483 av_log_set_level(level);
487 int opt_timelimit(const char *opt, const char *arg)
490 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
491 struct rlimit rl = { lim, lim + 1 };
492 if (setrlimit(RLIMIT_CPU, &rl))
495 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
500 void print_error(const char *filename, int err)
503 const char *errbuf_ptr = errbuf;
505 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
506 errbuf_ptr = strerror(AVUNERROR(err));
507 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
510 static int warned_cfg = 0;
513 #define SHOW_VERSION 2
514 #define SHOW_CONFIG 4
516 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
517 if (CONFIG_##LIBNAME) { \
518 const char *indent = flags & INDENT? " " : ""; \
519 if (flags & SHOW_VERSION) { \
520 unsigned int version = libname##_version(); \
521 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
523 LIB##LIBNAME##_VERSION_MAJOR, \
524 LIB##LIBNAME##_VERSION_MINOR, \
525 LIB##LIBNAME##_VERSION_MICRO, \
526 version >> 16, version >> 8 & 0xff, version & 0xff); \
528 if (flags & SHOW_CONFIG) { \
529 const char *cfg = libname##_configuration(); \
530 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
533 "%sWARNING: library configuration mismatch\n", \
537 fprintf(stderr, "%s%-11s configuration: %s\n", \
538 indent, #libname, cfg); \
543 static void print_all_libs_info(FILE* outstream, int flags)
545 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
546 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
547 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
548 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
549 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
550 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
551 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
554 void show_banner(void)
556 fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
557 program_name, program_birth_year, this_year);
558 fprintf(stderr, " built on %s %s with %s %s\n",
559 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
560 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
561 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
562 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
565 int opt_version(const char *opt, const char *arg) {
566 printf("%s " FFMPEG_VERSION "\n", program_name);
567 print_all_libs_info(stdout, SHOW_VERSION);
571 int opt_license(const char *opt, const char *arg)
575 "This version of %s has nonfree parts compiled in.\n"
576 "Therefore it is not legally redistributable.\n",
579 "%s is free software; you can redistribute it and/or modify\n"
580 "it under the terms of the GNU General Public License as published by\n"
581 "the Free Software Foundation; either version 3 of the License, or\n"
582 "(at your option) any later version.\n"
584 "%s is distributed in the hope that it will be useful,\n"
585 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
586 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
587 "GNU General Public License for more details.\n"
589 "You should have received a copy of the GNU General Public License\n"
590 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
591 program_name, program_name, program_name
593 "%s is free software; you can redistribute it and/or modify\n"
594 "it under the terms of the GNU General Public License as published by\n"
595 "the Free Software Foundation; either version 2 of the License, or\n"
596 "(at your option) any later version.\n"
598 "%s is distributed in the hope that it will be useful,\n"
599 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
600 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
601 "GNU General Public License for more details.\n"
603 "You should have received a copy of the GNU General Public License\n"
604 "along with %s; if not, write to the Free Software\n"
605 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
606 program_name, program_name, program_name
608 "%s is free software; you can redistribute it and/or modify\n"
609 "it under the terms of the GNU Lesser General Public License as published by\n"
610 "the Free Software Foundation; either version 3 of the License, or\n"
611 "(at your option) any later version.\n"
613 "%s is distributed in the hope that it will be useful,\n"
614 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
615 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
616 "GNU Lesser General Public License for more details.\n"
618 "You should have received a copy of the GNU Lesser General Public License\n"
619 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
620 program_name, program_name, program_name
622 "%s is free software; you can redistribute it and/or\n"
623 "modify it under the terms of the GNU Lesser General Public\n"
624 "License as published by the Free Software Foundation; either\n"
625 "version 2.1 of the License, or (at your option) any later version.\n"
627 "%s is distributed in the hope that it will be useful,\n"
628 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
629 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
630 "Lesser General Public License for more details.\n"
632 "You should have received a copy of the GNU Lesser General Public\n"
633 "License along with %s; if not, write to the Free Software\n"
634 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
635 program_name, program_name, program_name
641 int opt_formats(const char *opt, const char *arg)
643 AVInputFormat *ifmt=NULL;
644 AVOutputFormat *ofmt=NULL;
645 const char *last_name;
649 " D. = Demuxing supported\n"
650 " .E = Muxing supported\n"
656 const char *name=NULL;
657 const char *long_name=NULL;
659 while((ofmt= av_oformat_next(ofmt))) {
660 if((name == NULL || strcmp(ofmt->name, name)<0) &&
661 strcmp(ofmt->name, last_name)>0){
663 long_name= ofmt->long_name;
667 while((ifmt= av_iformat_next(ifmt))) {
668 if((name == NULL || strcmp(ifmt->name, name)<0) &&
669 strcmp(ifmt->name, last_name)>0){
671 long_name= ifmt->long_name;
674 if(name && strcmp(ifmt->name, name)==0)
686 long_name ? long_name:" ");
691 int opt_codecs(const char *opt, const char *arg)
693 AVCodec *p=NULL, *p2;
694 const char *last_name;
697 " D..... = Decoding supported\n"
698 " .E.... = Encoding supported\n"
699 " ..V... = Video codec\n"
700 " ..A... = Audio codec\n"
701 " ..S... = Subtitle codec\n"
702 " ...S.. = Supports draw_horiz_band\n"
703 " ....D. = Supports direct rendering method 1\n"
704 " .....T = Supports weird frame truncation\n"
711 const char *type_str;
714 while((p= av_codec_next(p))) {
715 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
716 strcmp(p->name, last_name)>0){
718 decode= encode= cap=0;
720 if(p2 && strcmp(p->name, p2->name)==0){
721 if(p->decode) decode=1;
722 if(p->encode) encode=1;
723 cap |= p->capabilities;
731 case AVMEDIA_TYPE_VIDEO:
734 case AVMEDIA_TYPE_AUDIO:
737 case AVMEDIA_TYPE_SUBTITLE:
745 " %s%s%s%s%s%s %-15s %s",
746 decode ? "D": (/*p2->decoder ? "d":*/" "),
749 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
750 cap & CODEC_CAP_DR1 ? "D":" ",
751 cap & CODEC_CAP_TRUNCATED ? "T":" ",
753 p2->long_name ? p2->long_name : "");
754 /* if(p2->decoder && decode==0)
755 printf(" use %s for decoding", p2->decoder->name);*/
760 "Note, the names of encoders and decoders do not always match, so there are\n"
761 "several cases where the above table shows encoder only or decoder only entries\n"
762 "even though both encoding and decoding are supported. For example, the h263\n"
763 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
768 int opt_bsfs(const char *opt, const char *arg)
770 AVBitStreamFilter *bsf=NULL;
772 printf("Bitstream filters:\n");
773 while((bsf = av_bitstream_filter_next(bsf)))
774 printf("%s\n", bsf->name);
779 int opt_protocols(const char *opt, const char *arg)
781 URLProtocol *up=NULL;
783 printf("Supported file protocols:\n"
784 "I.. = Input supported\n"
785 ".O. = Output supported\n"
786 "..S = Seek supported\n"
789 while((up = av_protocol_next(up)))
790 printf("%c%c%c %s\n",
791 up->url_read ? 'I' : '.',
792 up->url_write ? 'O' : '.',
793 up->url_seek ? 'S' : '.',
798 int opt_filters(const char *opt, const char *arg)
800 AVFilter av_unused(**filter) = NULL;
802 printf("Filters:\n");
804 while ((filter = av_filter_next(filter)) && *filter)
805 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
810 int opt_pix_fmts(const char *opt, const char *arg)
812 enum PixelFormat pix_fmt;
816 "I.... = Supported Input format for conversion\n"
817 ".O... = Supported Output format for conversion\n"
818 "..H.. = Hardware accelerated format\n"
819 "...P. = Paletted format\n"
820 "....B = Bitstream format\n"
821 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
825 # define sws_isSupportedInput(x) 0
826 # define sws_isSupportedOutput(x) 0
829 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
830 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
831 printf("%c%c%c%c%c %-16s %d %2d\n",
832 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
833 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
834 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
835 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
836 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
838 pix_desc->nb_components,
839 av_get_bits_per_pixel(pix_desc));
847 int yesno = (toupper(c) == 'Y');
849 while (c != '\n' && c != EOF)
855 int read_file(const char *filename, char **bufptr, size_t *size)
857 FILE *f = fopen(filename, "rb");
860 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
861 return AVERROR(errno);
863 fseek(f, 0, SEEK_END);
865 fseek(f, 0, SEEK_SET);
866 *bufptr = av_malloc(*size + 1);
868 fprintf(stderr, "Could not allocate file buffer\n");
870 return AVERROR(ENOMEM);
872 fread(*bufptr, 1, *size, f);
873 (*bufptr)[*size++] = '\0';
879 FILE *get_preset_file(char *filename, size_t filename_size,
880 const char *preset_name, int is_path, const char *codec_name)
884 const char *base[3]= { getenv("FFMPEG_DATADIR"),
890 av_strlcpy(filename, preset_name, filename_size);
891 f = fopen(filename, "r");
894 char datadir[MAX_PATH], *ls;
897 if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
899 for (ls = datadir; ls < datadir + strlen(datadir); ls++)
900 if (*ls == '\\') *ls = '/';
902 if (ls = strrchr(datadir, '/'))
905 strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
910 for (i = 0; i < 3 && !f; i++) {
913 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
914 f = fopen(filename, "r");
915 if (!f && codec_name) {
916 snprintf(filename, filename_size,
917 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
918 f = fopen(filename, "r");
926 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, int encoder)
928 AVDictionary *ret = NULL;
929 AVDictionaryEntry *t = NULL;
930 AVCodec *codec = encoder ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
931 int flags = encoder ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
937 switch (codec->type) {
938 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
939 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
940 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
943 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
944 if (av_opt_find(avcodec_opts[0], t->key, NULL, flags, 0) ||
945 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, 0)))
946 av_dict_set(&ret, t->key, t->value, 0);
947 else if (t->key[0] == prefix && av_opt_find(avcodec_opts[0], t->key+1, NULL, flags, 0))
948 av_dict_set(&ret, t->key+1, t->value, 0);
953 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s)
960 opts = av_mallocz(s->nb_streams * sizeof(*opts));
962 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
965 for (i = 0; i < s->nb_streams; i++)
966 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, 0);