2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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 //opt_values are only stored for codec-specific options in which case
86 //both the name and value are dup'd
88 av_freep(&opt_names[i]);
89 av_freep(&opt_values[i]);
93 av_freep(&opt_values);
95 av_dict_free(&format_opts);
96 av_dict_free(&video_opts);
97 av_dict_free(&audio_opts);
98 av_dict_free(&sub_opts);
101 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
103 vfprintf(stdout, fmt, vl);
106 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
110 double d = av_strtod(numstr, &tail);
112 error= "Expected number for %s but found: %s\n";
113 else if (d < min || d > max)
114 error= "The value for %s was %s which is not within %f - %f\n";
115 else if(type == OPT_INT64 && (int64_t)d != d)
116 error= "Expected int64 for %s but found %s\n";
117 else if (type == OPT_INT && (int)d != d)
118 error= "Expected int for %s but found %s\n";
121 fprintf(stderr, error, context, numstr, min, max);
125 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
128 if (av_parse_time(&us, timestr, is_duration) < 0) {
129 fprintf(stderr, "Invalid %s specification for %s: %s\n",
130 is_duration ? "duration" : "date", context, timestr);
136 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
142 for(po = options; po->name != NULL; po++) {
144 if ((po->flags & mask) == value) {
149 av_strlcpy(buf, po->name, sizeof(buf));
150 if (po->flags & HAS_ARG) {
151 av_strlcat(buf, " ", sizeof(buf));
152 av_strlcat(buf, po->argname, sizeof(buf));
154 printf("-%-17s %s\n", buf, po->help);
159 static const OptionDef* find_option(const OptionDef *po, const char *name){
160 while (po->name != NULL) {
161 if (!strcmp(name, po->name))
168 #if defined(_WIN32) && !defined(__MINGW32CE__)
170 /* Will be leaked on exit */
171 static char** win32_argv_utf8 = NULL;
172 static int win32_argc = 0;
175 * Prepare command line arguments for executable.
176 * For Windows - perform wide-char to UTF-8 conversion.
177 * Input arguments should be main() function arguments.
178 * @param argc_ptr Arguments number (including executable)
179 * @param argv_ptr Arguments list.
181 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
185 int i, buffsize = 0, offset = 0;
187 if (win32_argv_utf8) {
188 *argc_ptr = win32_argc;
189 *argv_ptr = win32_argv_utf8;
194 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
195 if (win32_argc <= 0 || !argv_w)
198 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
199 for (i = 0; i < win32_argc; i++)
200 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201 NULL, 0, NULL, NULL);
203 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
204 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
205 if (win32_argv_utf8 == NULL) {
210 for (i = 0; i < win32_argc; i++) {
211 win32_argv_utf8[i] = &argstr_flat[offset];
212 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
213 &argstr_flat[offset],
214 buffsize - offset, NULL, NULL);
216 win32_argv_utf8[i] = NULL;
219 *argc_ptr = win32_argc;
220 *argv_ptr = win32_argv_utf8;
223 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
227 #endif /* WIN32 && !__MINGW32CE__ */
229 void parse_options(int argc, char **argv, const OptionDef *options,
230 void (* parse_arg_function)(const char*))
232 const char *opt, *arg;
233 int optindex, handleoptions=1;
236 /* perform system-dependent conversions for arguments list */
237 prepare_app_arguments(&argc, &argv);
241 while (optindex < argc) {
242 opt = argv[optindex++];
244 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
246 if (opt[1] == '-' && opt[2] == '\0') {
251 po= find_option(options, opt);
252 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
253 /* handle 'no' bool option */
254 po = find_option(options, opt + 2);
255 if (!(po->name && (po->flags & OPT_BOOL)))
260 po= find_option(options, "default");
263 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
267 if (po->flags & HAS_ARG) {
268 arg = argv[optindex++];
270 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
274 if (po->flags & OPT_STRING) {
276 str = av_strdup(arg);
277 *po->u.str_arg = str;
278 } else if (po->flags & OPT_BOOL) {
279 *po->u.int_arg = bool_val;
280 } else if (po->flags & OPT_INT) {
281 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
282 } else if (po->flags & OPT_INT64) {
283 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
284 } else if (po->flags & OPT_FLOAT) {
285 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
286 } else if (po->u.func_arg) {
287 if (po->u.func_arg(opt, arg) < 0) {
288 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
292 if(po->flags & OPT_EXIT)
295 if (parse_arg_function)
296 parse_arg_function(opt);
301 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
302 #define SET_PREFIXED_OPTS(ch, flag, output) \
303 if (opt[0] == ch && avcodec_opts[0] && (o = av_opt_find(avcodec_opts[0], opt+1, NULL, flag, 0)))\
304 av_dict_set(&output, opt+1, arg, FLAGS);
305 static int opt_default2(const char *opt, const char *arg)
308 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
309 if (o->flags & AV_OPT_FLAG_VIDEO_PARAM)
310 av_dict_set(&video_opts, opt, arg, FLAGS);
311 if (o->flags & AV_OPT_FLAG_AUDIO_PARAM)
312 av_dict_set(&audio_opts, opt, arg, FLAGS);
313 if (o->flags & AV_OPT_FLAG_SUBTITLE_PARAM)
314 av_dict_set(&sub_opts, opt, arg, FLAGS);
315 } else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
316 av_dict_set(&format_opts, opt, arg, FLAGS);
317 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
318 // XXX we only support sws_flags, not arbitrary sws options
319 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
321 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
327 SET_PREFIXED_OPTS('v', AV_OPT_FLAG_VIDEO_PARAM, video_opts)
328 SET_PREFIXED_OPTS('a', AV_OPT_FLAG_AUDIO_PARAM, audio_opts)
329 SET_PREFIXED_OPTS('s', AV_OPT_FLAG_SUBTITLE_PARAM, sub_opts)
334 fprintf(stderr, "Unrecognized option '%s'\n", opt);
335 return AVERROR_OPTION_NOT_FOUND;
338 int opt_default(const char *opt, const char *arg){
341 const AVOption *o= NULL;
342 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 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);
362 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
367 AVOutputFormat *oformat = NULL;
368 while ((p=av_codec_next(p))){
369 const AVClass *c = p->priv_class;
370 if(c && av_opt_find(&c, opt, NULL, 0, 0))
374 while ((oformat = av_oformat_next(oformat))) {
375 const AVClass *c = oformat->priv_class;
376 if (c && av_opt_find(&c, opt, NULL, 0, 0))
382 if ((ret = opt_default2(opt, arg)) < 0)
385 // 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));
387 //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
388 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
389 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
390 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
391 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
393 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
394 av_log_set_level(AV_LOG_DEBUG);
398 int opt_loglevel(const char *opt, const char *arg)
400 const struct { const char *name; int level; } log_levels[] = {
401 { "quiet" , AV_LOG_QUIET },
402 { "panic" , AV_LOG_PANIC },
403 { "fatal" , AV_LOG_FATAL },
404 { "error" , AV_LOG_ERROR },
405 { "warning", AV_LOG_WARNING },
406 { "info" , AV_LOG_INFO },
407 { "verbose", AV_LOG_VERBOSE },
408 { "debug" , AV_LOG_DEBUG },
414 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
415 if (!strcmp(log_levels[i].name, arg)) {
416 av_log_set_level(log_levels[i].level);
421 level = strtol(arg, &tail, 10);
423 fprintf(stderr, "Invalid loglevel \"%s\". "
424 "Possible levels are numbers or:\n", arg);
425 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
426 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
429 av_log_set_level(level);
433 int opt_timelimit(const char *opt, const char *arg)
436 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
437 struct rlimit rl = { lim, lim + 1 };
438 if (setrlimit(RLIMIT_CPU, &rl))
441 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
446 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
450 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
451 AVCodecContext *avctx= ctx;
452 if(codec && codec->priv_class && avctx->priv_data){
453 priv_ctx= avctx->priv_data;
455 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
456 AVFormatContext *avctx = ctx;
457 if (avctx->oformat && avctx->oformat->priv_class) {
458 priv_ctx = avctx->priv_data;
462 for(i=0; i<opt_name_count; i++){
465 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
466 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
467 if(str && ((opt->flags & flags) == flags))
468 av_set_string3(ctx, opt_names[i], str, 1, NULL);
469 /* We need to use a differnt system to pass options to the private context because
470 it is not known which codec and thus context kind that will be when parsing options
471 we thus use opt_values directly instead of opts_ctx */
472 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
473 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
478 void print_error(const char *filename, int err)
481 const char *errbuf_ptr = errbuf;
483 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
484 errbuf_ptr = strerror(AVUNERROR(err));
485 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
488 static int warned_cfg = 0;
491 #define SHOW_VERSION 2
492 #define SHOW_CONFIG 4
494 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
495 if (CONFIG_##LIBNAME) { \
496 const char *indent = flags & INDENT? " " : ""; \
497 if (flags & SHOW_VERSION) { \
498 unsigned int version = libname##_version(); \
499 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
501 LIB##LIBNAME##_VERSION_MAJOR, \
502 LIB##LIBNAME##_VERSION_MINOR, \
503 LIB##LIBNAME##_VERSION_MICRO, \
504 version >> 16, version >> 8 & 0xff, version & 0xff); \
506 if (flags & SHOW_CONFIG) { \
507 const char *cfg = libname##_configuration(); \
508 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
511 "%sWARNING: library configuration mismatch\n", \
515 fprintf(stderr, "%s%-11s configuration: %s\n", \
516 indent, #libname, cfg); \
521 static void print_all_libs_info(FILE* outstream, int flags)
523 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
524 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
525 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
526 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
527 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
528 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
529 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
532 void show_banner(void)
534 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
535 program_name, program_birth_year, this_year);
536 fprintf(stderr, " built on %s %s with %s %s\n",
537 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
538 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
539 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
540 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
543 void show_version(void) {
544 printf("%s " LIBAV_VERSION "\n", program_name);
545 print_all_libs_info(stdout, SHOW_VERSION);
548 void show_license(void)
552 "This version of %s has nonfree parts compiled in.\n"
553 "Therefore it is not legally redistributable.\n",
556 "%s is free software; you can redistribute it and/or modify\n"
557 "it under the terms of the GNU General Public License as published by\n"
558 "the Free Software Foundation; either version 3 of the License, or\n"
559 "(at your option) any later version.\n"
561 "%s is distributed in the hope that it will be useful,\n"
562 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
563 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
564 "GNU General Public License for more details.\n"
566 "You should have received a copy of the GNU General Public License\n"
567 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
568 program_name, program_name, program_name
570 "%s is free software; you can redistribute it and/or modify\n"
571 "it under the terms of the GNU General Public License as published by\n"
572 "the Free Software Foundation; either version 2 of the License, or\n"
573 "(at your option) any later version.\n"
575 "%s is distributed in the hope that it will be useful,\n"
576 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
577 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
578 "GNU General Public License for more details.\n"
580 "You should have received a copy of the GNU General Public License\n"
581 "along with %s; if not, write to the Free Software\n"
582 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
583 program_name, program_name, program_name
585 "%s is free software; you can redistribute it and/or modify\n"
586 "it under the terms of the GNU Lesser General Public License as published by\n"
587 "the Free Software Foundation; either version 3 of the License, or\n"
588 "(at your option) any later version.\n"
590 "%s is distributed in the hope that it will be useful,\n"
591 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
592 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
593 "GNU Lesser General Public License for more details.\n"
595 "You should have received a copy of the GNU Lesser General Public License\n"
596 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
597 program_name, program_name, program_name
599 "%s is free software; you can redistribute it and/or\n"
600 "modify it under the terms of the GNU Lesser General Public\n"
601 "License as published by the Free Software Foundation; either\n"
602 "version 2.1 of the License, or (at your option) any later version.\n"
604 "%s is distributed in the hope that it will be useful,\n"
605 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
606 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
607 "Lesser General Public License for more details.\n"
609 "You should have received a copy of the GNU Lesser General Public\n"
610 "License along with %s; if not, write to the Free Software\n"
611 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
612 program_name, program_name, program_name
617 void show_formats(void)
619 AVInputFormat *ifmt=NULL;
620 AVOutputFormat *ofmt=NULL;
621 const char *last_name;
625 " D. = Demuxing supported\n"
626 " .E = Muxing supported\n"
632 const char *name=NULL;
633 const char *long_name=NULL;
635 while((ofmt= av_oformat_next(ofmt))) {
636 if((name == NULL || strcmp(ofmt->name, name)<0) &&
637 strcmp(ofmt->name, last_name)>0){
639 long_name= ofmt->long_name;
643 while((ifmt= av_iformat_next(ifmt))) {
644 if((name == NULL || strcmp(ifmt->name, name)<0) &&
645 strcmp(ifmt->name, last_name)>0){
647 long_name= ifmt->long_name;
650 if(name && strcmp(ifmt->name, name)==0)
662 long_name ? long_name:" ");
666 void show_codecs(void)
668 AVCodec *p=NULL, *p2;
669 const char *last_name;
672 " D..... = Decoding supported\n"
673 " .E.... = Encoding supported\n"
674 " ..V... = Video codec\n"
675 " ..A... = Audio codec\n"
676 " ..S... = Subtitle codec\n"
677 " ...S.. = Supports draw_horiz_band\n"
678 " ....D. = Supports direct rendering method 1\n"
679 " .....T = Supports weird frame truncation\n"
686 const char *type_str;
689 while((p= av_codec_next(p))) {
690 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
691 strcmp(p->name, last_name)>0){
693 decode= encode= cap=0;
695 if(p2 && strcmp(p->name, p2->name)==0){
696 if(p->decode) decode=1;
697 if(p->encode) encode=1;
698 cap |= p->capabilities;
706 case AVMEDIA_TYPE_VIDEO:
709 case AVMEDIA_TYPE_AUDIO:
712 case AVMEDIA_TYPE_SUBTITLE:
720 " %s%s%s%s%s%s %-15s %s",
721 decode ? "D": (/*p2->decoder ? "d":*/" "),
724 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
725 cap & CODEC_CAP_DR1 ? "D":" ",
726 cap & CODEC_CAP_TRUNCATED ? "T":" ",
728 p2->long_name ? p2->long_name : "");
729 /* if(p2->decoder && decode==0)
730 printf(" use %s for decoding", p2->decoder->name);*/
735 "Note, the names of encoders and decoders do not always match, so there are\n"
736 "several cases where the above table shows encoder only or decoder only entries\n"
737 "even though both encoding and decoding are supported. For example, the h263\n"
738 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
744 AVBitStreamFilter *bsf=NULL;
746 printf("Bitstream filters:\n");
747 while((bsf = av_bitstream_filter_next(bsf)))
748 printf("%s\n", bsf->name);
752 void show_protocols(void)
757 printf("Supported file protocols:\n"
759 while ((name = avio_enum_protocols(&opaque, 0)))
760 printf("%s\n", name);
762 while ((name = avio_enum_protocols(&opaque, 1)))
763 printf("%s\n", name);
766 void show_filters(void)
768 AVFilter av_unused(**filter) = NULL;
770 printf("Filters:\n");
772 while ((filter = av_filter_next(filter)) && *filter)
773 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
777 void show_pix_fmts(void)
779 enum PixelFormat pix_fmt;
783 "I.... = Supported Input format for conversion\n"
784 ".O... = Supported Output format for conversion\n"
785 "..H.. = Hardware accelerated format\n"
786 "...P. = Paletted format\n"
787 "....B = Bitstream format\n"
788 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
792 # define sws_isSupportedInput(x) 0
793 # define sws_isSupportedOutput(x) 0
796 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
797 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
798 printf("%c%c%c%c%c %-16s %d %2d\n",
799 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
800 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
801 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
802 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
803 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
805 pix_desc->nb_components,
806 av_get_bits_per_pixel(pix_desc));
813 int yesno = (toupper(c) == 'Y');
815 while (c != '\n' && c != EOF)
821 int read_file(const char *filename, char **bufptr, size_t *size)
823 FILE *f = fopen(filename, "rb");
826 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
827 return AVERROR(errno);
829 fseek(f, 0, SEEK_END);
831 fseek(f, 0, SEEK_SET);
832 *bufptr = av_malloc(*size + 1);
834 fprintf(stderr, "Could not allocate file buffer\n");
836 return AVERROR(ENOMEM);
838 fread(*bufptr, 1, *size, f);
839 (*bufptr)[*size++] = '\0';
845 void init_pts_correction(PtsCorrectionContext *ctx)
847 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
848 ctx->last_pts = ctx->last_dts = INT64_MIN;
851 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
853 int64_t pts = AV_NOPTS_VALUE;
855 if (dts != AV_NOPTS_VALUE) {
856 ctx->num_faulty_dts += dts <= ctx->last_dts;
859 if (reordered_pts != AV_NOPTS_VALUE) {
860 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
861 ctx->last_pts = reordered_pts;
863 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
864 && reordered_pts != AV_NOPTS_VALUE)
872 FILE *get_preset_file(char *filename, size_t filename_size,
873 const char *preset_name, int is_path, const char *codec_name)
877 const char *base[3]= { getenv("FFMPEG_DATADIR"),
883 av_strlcpy(filename, preset_name, filename_size);
884 f = fopen(filename, "r");
886 for (i = 0; i < 3 && !f; i++) {
889 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
890 f = fopen(filename, "r");
891 if (!f && codec_name) {
892 snprintf(filename, filename_size,
893 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
894 f = fopen(filename, "r");
904 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
906 FFSinkContext *priv = ctx->priv;
909 return AVERROR(EINVAL);
910 *priv = *(FFSinkContext *)opaque;
915 static void null_end_frame(AVFilterLink *inlink) { }
917 static int ffsink_query_formats(AVFilterContext *ctx)
919 FFSinkContext *priv = ctx->priv;
920 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
922 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
928 .priv_size = sizeof(FFSinkContext),
931 .query_formats = ffsink_query_formats,
933 .inputs = (AVFilterPad[]) {{ .name = "default",
934 .type = AVMEDIA_TYPE_VIDEO,
935 .end_frame = null_end_frame,
936 .min_perms = AV_PERM_READ, },
938 .outputs = (AVFilterPad[]) {{ .name = NULL }},
941 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
942 AVFilterBufferRef **picref_ptr, AVRational *tb)
945 AVFilterBufferRef *picref;
947 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
949 if (!(picref = ctx->inputs[0]->cur_buf))
950 return AVERROR(ENOENT);
951 *picref_ptr = picref;
952 ctx->inputs[0]->cur_buf = NULL;
953 *tb = ctx->inputs[0]->time_base;
955 memcpy(frame->data, picref->data, sizeof(frame->data));
956 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
957 frame->interlaced_frame = picref->video->interlaced;
958 frame->top_field_first = picref->video->top_field_first;
959 frame->key_frame = picref->video->key_frame;
960 frame->pict_type = picref->video->pict_type;
965 #endif /* CONFIG_AVFILTER */