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/opt.h"
45 #include "libavformat/network.h"
47 #if HAVE_SYS_RESOURCE_H
48 #include <sys/resource.h>
51 const char **opt_names;
52 const char **opt_values;
53 static int opt_name_count;
54 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
55 AVFormatContext *avformat_opts;
56 struct SwsContext *sws_opts;
58 static const int this_year = 2011;
63 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
64 avcodec_opts[i] = avcodec_alloc_context2(i);
65 avformat_opts = avformat_alloc_context();
67 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
71 void uninit_opts(void)
74 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
75 av_freep(&avcodec_opts[i]);
76 av_freep(&avformat_opts->key);
77 av_freep(&avformat_opts);
81 for (i = 0; i < opt_name_count; i++) {
82 //opt_values are only stored for codec-specific options in which case
83 //both the name and value are dup'd
85 av_freep(&opt_names[i]);
86 av_freep(&opt_values[i]);
90 av_freep(&opt_values);
93 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
95 vfprintf(stdout, fmt, vl);
98 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
102 double d = av_strtod(numstr, &tail);
104 error= "Expected number for %s but found: %s\n";
105 else if (d < min || d > max)
106 error= "The value for %s was %s which is not within %f - %f\n";
107 else if(type == OPT_INT64 && (int64_t)d != d)
108 error= "Expected int64 for %s but found %s\n";
111 fprintf(stderr, error, context, numstr, min, max);
115 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
118 if (av_parse_time(&us, timestr, is_duration) < 0) {
119 fprintf(stderr, "Invalid %s specification for %s: %s\n",
120 is_duration ? "duration" : "date", context, timestr);
126 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
132 for(po = options; po->name != NULL; po++) {
134 if ((po->flags & mask) == value) {
139 av_strlcpy(buf, po->name, sizeof(buf));
140 if (po->flags & HAS_ARG) {
141 av_strlcat(buf, " ", sizeof(buf));
142 av_strlcat(buf, po->argname, sizeof(buf));
144 printf("-%-17s %s\n", buf, po->help);
149 static const OptionDef* find_option(const OptionDef *po, const char *name){
150 while (po->name != NULL) {
151 if (!strcmp(name, po->name))
158 #if defined(_WIN32) && !defined(__MINGW32CE__)
160 /* Will be leaked on exit */
161 static char** win32_argv_utf8 = NULL;
162 static int win32_argc = 0;
165 * Prepare command line arguments for executable.
166 * For Windows - perform wide-char to UTF-8 conversion.
167 * Input arguments should be main() function arguments.
168 * @param argc_ptr Arguments number (including executable)
169 * @param argv_ptr Arguments list.
171 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
175 int i, buffsize = 0, offset = 0;
177 if (win32_argv_utf8) {
178 *argc_ptr = win32_argc;
179 *argv_ptr = win32_argv_utf8;
184 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
185 if (win32_argc <= 0 || !argv_w)
188 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
189 for (i = 0; i < win32_argc; i++)
190 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
191 NULL, 0, NULL, NULL);
193 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
194 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
195 if (win32_argv_utf8 == NULL) {
200 for (i = 0; i < win32_argc; i++) {
201 win32_argv_utf8[i] = &argstr_flat[offset];
202 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
203 &argstr_flat[offset],
204 buffsize - offset, NULL, NULL);
206 win32_argv_utf8[i] = NULL;
209 *argc_ptr = win32_argc;
210 *argv_ptr = win32_argv_utf8;
213 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
217 #endif /* WIN32 && !__MINGW32CE__ */
219 void parse_options(int argc, char **argv, const OptionDef *options,
220 void (* parse_arg_function)(const char*))
222 const char *opt, *arg;
223 int optindex, handleoptions=1;
226 /* perform system-dependent conversions for arguments list */
227 prepare_app_arguments(&argc, &argv);
231 while (optindex < argc) {
232 opt = argv[optindex++];
234 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
236 if (opt[1] == '-' && opt[2] == '\0') {
241 po= find_option(options, opt);
242 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
243 /* handle 'no' bool option */
244 po = find_option(options, opt + 2);
245 if (!(po->name && (po->flags & OPT_BOOL)))
250 po= find_option(options, "default");
253 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
257 if (po->flags & HAS_ARG) {
258 arg = argv[optindex++];
260 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
264 if (po->flags & OPT_STRING) {
266 str = av_strdup(arg);
267 *po->u.str_arg = str;
268 } else if (po->flags & OPT_BOOL) {
269 *po->u.int_arg = bool_val;
270 } else if (po->flags & OPT_INT) {
271 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
272 } else if (po->flags & OPT_INT64) {
273 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
274 } else if (po->flags & OPT_FLOAT) {
275 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
276 } else if (po->flags & OPT_FUNC2) {
277 if (po->u.func2_arg(opt, arg) < 0) {
278 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
284 if(po->flags & OPT_EXIT)
287 if (parse_arg_function)
288 parse_arg_function(opt);
293 int opt_default(const char *opt, const char *arg){
296 const AVOption *o= NULL;
297 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
299 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
300 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
302 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
304 if(!o && avformat_opts)
305 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
307 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
309 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
310 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
311 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
312 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
313 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
314 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
317 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
322 AVOutputFormat *oformat = NULL;
323 while ((p=av_codec_next(p))){
324 AVClass *c= p->priv_class;
325 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 fprintf(stderr, "Unrecognized option '%s'\n", opt);
341 // 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));
343 //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
344 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
345 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
346 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
347 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
349 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
350 av_log_set_level(AV_LOG_DEBUG);
354 int opt_loglevel(const char *opt, const char *arg)
356 const struct { const char *name; int level; } log_levels[] = {
357 { "quiet" , AV_LOG_QUIET },
358 { "panic" , AV_LOG_PANIC },
359 { "fatal" , AV_LOG_FATAL },
360 { "error" , AV_LOG_ERROR },
361 { "warning", AV_LOG_WARNING },
362 { "info" , AV_LOG_INFO },
363 { "verbose", AV_LOG_VERBOSE },
364 { "debug" , AV_LOG_DEBUG },
370 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
371 if (!strcmp(log_levels[i].name, arg)) {
372 av_log_set_level(log_levels[i].level);
377 level = strtol(arg, &tail, 10);
379 fprintf(stderr, "Invalid loglevel \"%s\". "
380 "Possible levels are numbers or:\n", arg);
381 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
382 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
385 av_log_set_level(level);
389 int opt_timelimit(const char *opt, const char *arg)
392 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
393 struct rlimit rl = { lim, lim + 1 };
394 if (setrlimit(RLIMIT_CPU, &rl))
397 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
402 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
406 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
407 AVCodecContext *avctx= ctx;
408 if(codec && codec->priv_class && avctx->priv_data){
409 priv_ctx= avctx->priv_data;
411 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
412 AVFormatContext *avctx = ctx;
413 if (avctx->oformat && avctx->oformat->priv_class) {
414 priv_ctx = avctx->priv_data;
418 for(i=0; i<opt_name_count; i++){
421 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
422 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
423 if(str && ((opt->flags & flags) == flags))
424 av_set_string3(ctx, opt_names[i], str, 1, NULL);
425 /* We need to use a differnt system to pass options to the private context because
426 it is not known which codec and thus context kind that will be when parsing options
427 we thus use opt_values directly instead of opts_ctx */
428 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
429 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
434 void print_error(const char *filename, int err)
437 const char *errbuf_ptr = errbuf;
439 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
440 errbuf_ptr = strerror(AVUNERROR(err));
441 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
444 static int warned_cfg = 0;
447 #define SHOW_VERSION 2
448 #define SHOW_CONFIG 4
450 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
451 if (CONFIG_##LIBNAME) { \
452 const char *indent = flags & INDENT? " " : ""; \
453 if (flags & SHOW_VERSION) { \
454 unsigned int version = libname##_version(); \
455 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
457 LIB##LIBNAME##_VERSION_MAJOR, \
458 LIB##LIBNAME##_VERSION_MINOR, \
459 LIB##LIBNAME##_VERSION_MICRO, \
460 version >> 16, version >> 8 & 0xff, version & 0xff); \
462 if (flags & SHOW_CONFIG) { \
463 const char *cfg = libname##_configuration(); \
464 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
467 "%sWARNING: library configuration mismatch\n", \
471 fprintf(stderr, "%s%-11s configuration: %s\n", \
472 indent, #libname, cfg); \
477 static void print_all_libs_info(FILE* outstream, int flags)
479 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
480 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
481 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
482 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
483 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
484 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
485 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
488 void show_banner(void)
490 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
491 program_name, program_birth_year, this_year);
492 fprintf(stderr, " built on %s %s with %s %s\n",
493 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
494 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
495 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
496 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
499 void show_version(void) {
500 printf("%s " LIBAV_VERSION "\n", program_name);
501 print_all_libs_info(stdout, SHOW_VERSION);
504 void show_license(void)
508 "This version of %s has nonfree parts compiled in.\n"
509 "Therefore it is not legally redistributable.\n",
512 "%s is free software; you can redistribute it and/or modify\n"
513 "it under the terms of the GNU General Public License as published by\n"
514 "the Free Software Foundation; either version 3 of the License, or\n"
515 "(at your option) any later version.\n"
517 "%s is distributed in the hope that it will be useful,\n"
518 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
519 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
520 "GNU General Public License for more details.\n"
522 "You should have received a copy of the GNU General Public License\n"
523 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
524 program_name, program_name, program_name
526 "%s is free software; you can redistribute it and/or modify\n"
527 "it under the terms of the GNU General Public License as published by\n"
528 "the Free Software Foundation; either version 2 of the License, or\n"
529 "(at your option) any later version.\n"
531 "%s is distributed in the hope that it will be useful,\n"
532 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
533 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
534 "GNU General Public License for more details.\n"
536 "You should have received a copy of the GNU General Public License\n"
537 "along with %s; if not, write to the Free Software\n"
538 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
539 program_name, program_name, program_name
541 "%s is free software; you can redistribute it and/or modify\n"
542 "it under the terms of the GNU Lesser General Public License as published by\n"
543 "the Free Software Foundation; either version 3 of the License, or\n"
544 "(at your option) any later version.\n"
546 "%s is distributed in the hope that it will be useful,\n"
547 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
548 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
549 "GNU Lesser General Public License for more details.\n"
551 "You should have received a copy of the GNU Lesser General Public License\n"
552 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
553 program_name, program_name, program_name
555 "%s is free software; you can redistribute it and/or\n"
556 "modify it under the terms of the GNU Lesser General Public\n"
557 "License as published by the Free Software Foundation; either\n"
558 "version 2.1 of the License, or (at your option) any later version.\n"
560 "%s is distributed in the hope that it will be useful,\n"
561 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
562 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
563 "Lesser General Public License for more details.\n"
565 "You should have received a copy of the GNU Lesser General Public\n"
566 "License along with %s; if not, write to the Free Software\n"
567 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
568 program_name, program_name, program_name
573 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
577 for (i=-1; i < nb_fmts; i++) {
578 get_fmt_string (fmt_str, sizeof(fmt_str), i);
579 fprintf(stdout, "%s\n", fmt_str);
583 void show_formats(void)
585 AVInputFormat *ifmt=NULL;
586 AVOutputFormat *ofmt=NULL;
587 const char *last_name;
591 " D. = Demuxing supported\n"
592 " .E = Muxing supported\n"
598 const char *name=NULL;
599 const char *long_name=NULL;
601 while((ofmt= av_oformat_next(ofmt))) {
602 if((name == NULL || strcmp(ofmt->name, name)<0) &&
603 strcmp(ofmt->name, last_name)>0){
605 long_name= ofmt->long_name;
609 while((ifmt= av_iformat_next(ifmt))) {
610 if((name == NULL || strcmp(ifmt->name, name)<0) &&
611 strcmp(ifmt->name, last_name)>0){
613 long_name= ifmt->long_name;
616 if(name && strcmp(ifmt->name, name)==0)
628 long_name ? long_name:" ");
632 void show_codecs(void)
634 AVCodec *p=NULL, *p2;
635 const char *last_name;
638 " D..... = Decoding supported\n"
639 " .E.... = Encoding supported\n"
640 " ..V... = Video codec\n"
641 " ..A... = Audio codec\n"
642 " ..S... = Subtitle codec\n"
643 " ...S.. = Supports draw_horiz_band\n"
644 " ....D. = Supports direct rendering method 1\n"
645 " .....T = Supports weird frame truncation\n"
652 const char *type_str;
655 while((p= av_codec_next(p))) {
656 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
657 strcmp(p->name, last_name)>0){
659 decode= encode= cap=0;
661 if(p2 && strcmp(p->name, p2->name)==0){
662 if(p->decode) decode=1;
663 if(p->encode) encode=1;
664 cap |= p->capabilities;
672 case AVMEDIA_TYPE_VIDEO:
675 case AVMEDIA_TYPE_AUDIO:
678 case AVMEDIA_TYPE_SUBTITLE:
686 " %s%s%s%s%s%s %-15s %s",
687 decode ? "D": (/*p2->decoder ? "d":*/" "),
690 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
691 cap & CODEC_CAP_DR1 ? "D":" ",
692 cap & CODEC_CAP_TRUNCATED ? "T":" ",
694 p2->long_name ? p2->long_name : "");
695 /* if(p2->decoder && decode==0)
696 printf(" use %s for decoding", p2->decoder->name);*/
701 "Note, the names of encoders and decoders do not always match, so there are\n"
702 "several cases where the above table shows encoder only or decoder only entries\n"
703 "even though both encoding and decoding are supported. For example, the h263\n"
704 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
710 AVBitStreamFilter *bsf=NULL;
712 printf("Bitstream filters:\n");
713 while((bsf = av_bitstream_filter_next(bsf)))
714 printf("%s\n", bsf->name);
718 void show_protocols(void)
723 printf("Supported file protocols:\n"
725 while ((name = avio_enum_protocols(&opaque, 0)))
726 printf("%s\n", name);
728 while ((name = avio_enum_protocols(&opaque, 1)))
729 printf("%s\n", name);
732 void show_filters(void)
734 AVFilter av_unused(**filter) = NULL;
736 printf("Filters:\n");
738 while ((filter = av_filter_next(filter)) && *filter)
739 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
743 void show_pix_fmts(void)
745 enum PixelFormat pix_fmt;
749 "I.... = Supported Input format for conversion\n"
750 ".O... = Supported Output format for conversion\n"
751 "..H.. = Hardware accelerated format\n"
752 "...P. = Paletted format\n"
753 "....B = Bitstream format\n"
754 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
758 # define sws_isSupportedInput(x) 0
759 # define sws_isSupportedOutput(x) 0
762 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
763 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
764 printf("%c%c%c%c%c %-16s %d %2d\n",
765 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
766 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
767 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
768 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
769 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
771 pix_desc->nb_components,
772 av_get_bits_per_pixel(pix_desc));
779 int yesno = (toupper(c) == 'Y');
781 while (c != '\n' && c != EOF)
787 int read_file(const char *filename, char **bufptr, size_t *size)
789 FILE *f = fopen(filename, "rb");
792 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
793 return AVERROR(errno);
795 fseek(f, 0, SEEK_END);
797 fseek(f, 0, SEEK_SET);
798 *bufptr = av_malloc(*size + 1);
800 fprintf(stderr, "Could not allocate file buffer\n");
802 return AVERROR(ENOMEM);
804 fread(*bufptr, 1, *size, f);
805 (*bufptr)[*size++] = '\0';
811 void init_pts_correction(PtsCorrectionContext *ctx)
813 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
814 ctx->last_pts = ctx->last_dts = INT64_MIN;
817 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
819 int64_t pts = AV_NOPTS_VALUE;
821 if (dts != AV_NOPTS_VALUE) {
822 ctx->num_faulty_dts += dts <= ctx->last_dts;
825 if (reordered_pts != AV_NOPTS_VALUE) {
826 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
827 ctx->last_pts = reordered_pts;
829 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
830 && reordered_pts != AV_NOPTS_VALUE)
838 FILE *get_preset_file(char *filename, size_t filename_size,
839 const char *preset_name, int is_path, const char *codec_name)
843 const char *base[3]= { getenv("FFMPEG_DATADIR"),
849 av_strlcpy(filename, preset_name, filename_size);
850 f = fopen(filename, "r");
852 for (i = 0; i < 3 && !f; i++) {
855 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
856 f = fopen(filename, "r");
857 if (!f && codec_name) {
858 snprintf(filename, filename_size,
859 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
860 f = fopen(filename, "r");
870 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
872 FFSinkContext *priv = ctx->priv;
875 return AVERROR(EINVAL);
876 *priv = *(FFSinkContext *)opaque;
881 static void null_end_frame(AVFilterLink *inlink) { }
883 static int ffsink_query_formats(AVFilterContext *ctx)
885 FFSinkContext *priv = ctx->priv;
886 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
888 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
894 .priv_size = sizeof(FFSinkContext),
897 .query_formats = ffsink_query_formats,
899 .inputs = (AVFilterPad[]) {{ .name = "default",
900 .type = AVMEDIA_TYPE_VIDEO,
901 .end_frame = null_end_frame,
902 .min_perms = AV_PERM_READ, },
904 .outputs = (AVFilterPad[]) {{ .name = NULL }},
907 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
908 AVFilterBufferRef **picref_ptr, AVRational *tb)
911 AVFilterBufferRef *picref;
913 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
915 if (!(picref = ctx->inputs[0]->cur_buf))
916 return AVERROR(ENOENT);
917 *picref_ptr = picref;
918 ctx->inputs[0]->cur_buf = NULL;
919 *tb = ctx->inputs[0]->time_base;
921 memcpy(frame->data, picref->data, sizeof(frame->data));
922 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
923 frame->interlaced_frame = picref->video->interlaced;
924 frame->top_field_first = picref->video->top_field_first;
929 #endif /* CONFIG_AVFILTER */