Move log_callback_help to cmdutils.[hc], for allowing sharing.
[libav.git] / cmdutils.c
1 /*
2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include <string.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <math.h>
26
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. */
30
31 #include "config.h"
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/pixdesc.h"
39 #include "libavutil/eval.h"
40 #include "libavcodec/opt.h"
41 #include "libavcore/avcore.h"
42 #include "cmdutils.h"
43 #include "version.h"
44 #if CONFIG_NETWORK
45 #include "libavformat/network.h"
46 #endif
47 #if HAVE_SYS_RESOURCE_H
48 #include <sys/resource.h>
49 #endif
50
51 const char **opt_names;
52 static int opt_name_count;
53 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
54 AVFormatContext *avformat_opts;
55 struct SwsContext *sws_opts;
56
57 const int this_year = 2010;
58
59 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
60 {
61 vfprintf(stdout, fmt, vl);
62 }
63
64 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
65 {
66 char *tail;
67 const char *error;
68 double d = av_strtod(numstr, &tail);
69 if (*tail)
70 error= "Expected number for %s but found: %s\n";
71 else if (d < min || d > max)
72 error= "The value for %s was %s which is not within %f - %f\n";
73 else if(type == OPT_INT64 && (int64_t)d != d)
74 error= "Expected int64 for %s but found %s\n";
75 else
76 return d;
77 fprintf(stderr, error, context, numstr, min, max);
78 exit(1);
79 }
80
81 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
82 {
83 int64_t us = parse_date(timestr, is_duration);
84 if (us == INT64_MIN) {
85 fprintf(stderr, "Invalid %s specification for %s: %s\n",
86 is_duration ? "duration" : "date", context, timestr);
87 exit(1);
88 }
89 return us;
90 }
91
92 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
93 {
94 const OptionDef *po;
95 int first;
96
97 first = 1;
98 for(po = options; po->name != NULL; po++) {
99 char buf[64];
100 if ((po->flags & mask) == value) {
101 if (first) {
102 printf("%s", msg);
103 first = 0;
104 }
105 av_strlcpy(buf, po->name, sizeof(buf));
106 if (po->flags & HAS_ARG) {
107 av_strlcat(buf, " ", sizeof(buf));
108 av_strlcat(buf, po->argname, sizeof(buf));
109 }
110 printf("-%-17s %s\n", buf, po->help);
111 }
112 }
113 }
114
115 static const OptionDef* find_option(const OptionDef *po, const char *name){
116 while (po->name != NULL) {
117 if (!strcmp(name, po->name))
118 break;
119 po++;
120 }
121 return po;
122 }
123
124 void parse_options(int argc, char **argv, const OptionDef *options,
125 void (* parse_arg_function)(const char*))
126 {
127 const char *opt, *arg;
128 int optindex, handleoptions=1;
129 const OptionDef *po;
130
131 /* parse options */
132 optindex = 1;
133 while (optindex < argc) {
134 opt = argv[optindex++];
135
136 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
137 int bool_val = 1;
138 if (opt[1] == '-' && opt[2] == '\0') {
139 handleoptions = 0;
140 continue;
141 }
142 opt++;
143 po= find_option(options, opt);
144 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
145 /* handle 'no' bool option */
146 po = find_option(options, opt + 2);
147 if (!(po->name && (po->flags & OPT_BOOL)))
148 goto unknown_opt;
149 bool_val = 0;
150 }
151 if (!po->name)
152 po= find_option(options, "default");
153 if (!po->name) {
154 unknown_opt:
155 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
156 exit(1);
157 }
158 arg = NULL;
159 if (po->flags & HAS_ARG) {
160 arg = argv[optindex++];
161 if (!arg) {
162 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
163 exit(1);
164 }
165 }
166 if (po->flags & OPT_STRING) {
167 char *str;
168 str = av_strdup(arg);
169 *po->u.str_arg = str;
170 } else if (po->flags & OPT_BOOL) {
171 *po->u.int_arg = bool_val;
172 } else if (po->flags & OPT_INT) {
173 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
174 } else if (po->flags & OPT_INT64) {
175 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
176 } else if (po->flags & OPT_FLOAT) {
177 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
178 } else if (po->flags & OPT_FUNC2) {
179 if (po->u.func2_arg(opt, arg) < 0) {
180 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
181 exit(1);
182 }
183 } else {
184 po->u.func_arg(arg);
185 }
186 if(po->flags & OPT_EXIT)
187 exit(0);
188 } else {
189 if (parse_arg_function)
190 parse_arg_function(opt);
191 }
192 }
193 }
194
195 int opt_default(const char *opt, const char *arg){
196 int type;
197 int ret= 0;
198 const AVOption *o= NULL;
199 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
200
201 for(type=0; type<AVMEDIA_TYPE_NB && ret>= 0; type++){
202 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
203 if(o2)
204 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
205 }
206 if(!o)
207 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
208 if(!o && sws_opts)
209 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
210 if(!o){
211 if(opt[0] == 'a')
212 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
213 else if(opt[0] == 'v')
214 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
215 else if(opt[0] == 's')
216 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
217 }
218 if (o && ret < 0) {
219 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
220 exit(1);
221 }
222 if (!o) {
223 fprintf(stderr, "Unrecognized option '%s'\n", opt);
224 exit(1);
225 }
226
227 // 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));
228
229 //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
230 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
231 opt_names[opt_name_count++]= o->name;
232
233 if(avcodec_opts[0]->debug || avformat_opts->debug)
234 av_log_set_level(AV_LOG_DEBUG);
235 return 0;
236 }
237
238 int opt_loglevel(const char *opt, const char *arg)
239 {
240 const struct { const char *name; int level; } log_levels[] = {
241 { "quiet" , AV_LOG_QUIET },
242 { "panic" , AV_LOG_PANIC },
243 { "fatal" , AV_LOG_FATAL },
244 { "error" , AV_LOG_ERROR },
245 { "warning", AV_LOG_WARNING },
246 { "info" , AV_LOG_INFO },
247 { "verbose", AV_LOG_VERBOSE },
248 { "debug" , AV_LOG_DEBUG },
249 };
250 char *tail;
251 int level;
252 int i;
253
254 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
255 if (!strcmp(log_levels[i].name, arg)) {
256 av_log_set_level(log_levels[i].level);
257 return 0;
258 }
259 }
260
261 level = strtol(arg, &tail, 10);
262 if (*tail) {
263 fprintf(stderr, "Invalid loglevel \"%s\". "
264 "Possible levels are numbers or:\n", arg);
265 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
266 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
267 exit(1);
268 }
269 av_log_set_level(level);
270 return 0;
271 }
272
273 int opt_timelimit(const char *opt, const char *arg)
274 {
275 #if HAVE_SETRLIMIT
276 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
277 struct rlimit rl = { lim, lim + 1 };
278 if (setrlimit(RLIMIT_CPU, &rl))
279 perror("setrlimit");
280 #else
281 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
282 #endif
283 return 0;
284 }
285
286 void set_context_opts(void *ctx, void *opts_ctx, int flags)
287 {
288 int i;
289 for(i=0; i<opt_name_count; i++){
290 char buf[256];
291 const AVOption *opt;
292 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
293 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
294 if(str && ((opt->flags & flags) == flags))
295 av_set_string3(ctx, opt_names[i], str, 1, NULL);
296 }
297 }
298
299 void print_error(const char *filename, int err)
300 {
301 char errbuf[128];
302 const char *errbuf_ptr = errbuf;
303
304 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
305 errbuf_ptr = strerror(AVUNERROR(err));
306 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
307 }
308
309 static int warned_cfg = 0;
310
311 #define INDENT 1
312 #define SHOW_VERSION 2
313 #define SHOW_CONFIG 4
314
315 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
316 if (CONFIG_##LIBNAME) { \
317 const char *indent = flags & INDENT? " " : ""; \
318 if (flags & SHOW_VERSION) { \
319 unsigned int version = libname##_version(); \
320 fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
321 indent, #libname, \
322 LIB##LIBNAME##_VERSION_MAJOR, \
323 LIB##LIBNAME##_VERSION_MINOR, \
324 LIB##LIBNAME##_VERSION_MICRO, \
325 version >> 16, version >> 8 & 0xff, version & 0xff); \
326 } \
327 if (flags & SHOW_CONFIG) { \
328 const char *cfg = libname##_configuration(); \
329 if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
330 if (!warned_cfg) { \
331 fprintf(outstream, \
332 "%sWARNING: library configuration mismatch\n", \
333 indent); \
334 warned_cfg = 1; \
335 } \
336 fprintf(stderr, "%s%-11s configuration: %s\n", \
337 indent, #libname, cfg); \
338 } \
339 } \
340 } \
341
342 static void print_all_libs_info(FILE* outstream, int flags)
343 {
344 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
345 PRINT_LIB_INFO(outstream, avcore, AVCORE, flags);
346 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
347 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
348 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
349 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
350 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
351 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
352 }
353
354 void show_banner(void)
355 {
356 fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
357 program_name, program_birth_year, this_year);
358 fprintf(stderr, " built on %s %s with %s %s\n",
359 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
360 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
361 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
362 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
363 }
364
365 void show_version(void) {
366 printf("%s " FFMPEG_VERSION "\n", program_name);
367 print_all_libs_info(stdout, SHOW_VERSION);
368 }
369
370 void show_license(void)
371 {
372 printf(
373 #if CONFIG_NONFREE
374 "This version of %s has nonfree parts compiled in.\n"
375 "Therefore it is not legally redistributable.\n",
376 program_name
377 #elif CONFIG_GPLV3
378 "%s is free software; you can redistribute it and/or modify\n"
379 "it under the terms of the GNU General Public License as published by\n"
380 "the Free Software Foundation; either version 3 of the License, or\n"
381 "(at your option) any later version.\n"
382 "\n"
383 "%s is distributed in the hope that it will be useful,\n"
384 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
385 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
386 "GNU General Public License for more details.\n"
387 "\n"
388 "You should have received a copy of the GNU General Public License\n"
389 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
390 program_name, program_name, program_name
391 #elif CONFIG_GPL
392 "%s is free software; you can redistribute it and/or modify\n"
393 "it under the terms of the GNU General Public License as published by\n"
394 "the Free Software Foundation; either version 2 of the License, or\n"
395 "(at your option) any later version.\n"
396 "\n"
397 "%s is distributed in the hope that it will be useful,\n"
398 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
399 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
400 "GNU General Public License for more details.\n"
401 "\n"
402 "You should have received a copy of the GNU General Public License\n"
403 "along with %s; if not, write to the Free Software\n"
404 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
405 program_name, program_name, program_name
406 #elif CONFIG_LGPLV3
407 "%s is free software; you can redistribute it and/or modify\n"
408 "it under the terms of the GNU Lesser General Public License as published by\n"
409 "the Free Software Foundation; either version 3 of the License, or\n"
410 "(at your option) any later version.\n"
411 "\n"
412 "%s is distributed in the hope that it will be useful,\n"
413 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
414 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
415 "GNU Lesser General Public License for more details.\n"
416 "\n"
417 "You should have received a copy of the GNU Lesser General Public License\n"
418 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
419 program_name, program_name, program_name
420 #else
421 "%s is free software; you can redistribute it and/or\n"
422 "modify it under the terms of the GNU Lesser General Public\n"
423 "License as published by the Free Software Foundation; either\n"
424 "version 2.1 of the License, or (at your option) any later version.\n"
425 "\n"
426 "%s is distributed in the hope that it will be useful,\n"
427 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
428 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
429 "Lesser General Public License for more details.\n"
430 "\n"
431 "You should have received a copy of the GNU Lesser General Public\n"
432 "License along with %s; if not, write to the Free Software\n"
433 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
434 program_name, program_name, program_name
435 #endif
436 );
437 }
438
439 void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
440 {
441 int i;
442 char fmt_str[128];
443 for (i=-1; i < nb_fmts; i++) {
444 get_fmt_string (fmt_str, sizeof(fmt_str), i);
445 fprintf(stdout, "%s\n", fmt_str);
446 }
447 }
448
449 void show_formats(void)
450 {
451 AVInputFormat *ifmt=NULL;
452 AVOutputFormat *ofmt=NULL;
453 const char *last_name;
454
455 printf(
456 "File formats:\n"
457 " D. = Demuxing supported\n"
458 " .E = Muxing supported\n"
459 " --\n");
460 last_name= "000";
461 for(;;){
462 int decode=0;
463 int encode=0;
464 const char *name=NULL;
465 const char *long_name=NULL;
466
467 while((ofmt= av_oformat_next(ofmt))) {
468 if((name == NULL || strcmp(ofmt->name, name)<0) &&
469 strcmp(ofmt->name, last_name)>0){
470 name= ofmt->name;
471 long_name= ofmt->long_name;
472 encode=1;
473 }
474 }
475 while((ifmt= av_iformat_next(ifmt))) {
476 if((name == NULL || strcmp(ifmt->name, name)<0) &&
477 strcmp(ifmt->name, last_name)>0){
478 name= ifmt->name;
479 long_name= ifmt->long_name;
480 encode=0;
481 }
482 if(name && strcmp(ifmt->name, name)==0)
483 decode=1;
484 }
485 if(name==NULL)
486 break;
487 last_name= name;
488
489 printf(
490 " %s%s %-15s %s\n",
491 decode ? "D":" ",
492 encode ? "E":" ",
493 name,
494 long_name ? long_name:" ");
495 }
496 }
497
498 void show_codecs(void)
499 {
500 AVCodec *p=NULL, *p2;
501 const char *last_name;
502 printf(
503 "Codecs:\n"
504 " D..... = Decoding supported\n"
505 " .E.... = Encoding supported\n"
506 " ..V... = Video codec\n"
507 " ..A... = Audio codec\n"
508 " ..S... = Subtitle codec\n"
509 " ...S.. = Supports draw_horiz_band\n"
510 " ....D. = Supports direct rendering method 1\n"
511 " .....T = Supports weird frame truncation\n"
512 " ------\n");
513 last_name= "000";
514 for(;;){
515 int decode=0;
516 int encode=0;
517 int cap=0;
518 const char *type_str;
519
520 p2=NULL;
521 while((p= av_codec_next(p))) {
522 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
523 strcmp(p->name, last_name)>0){
524 p2= p;
525 decode= encode= cap=0;
526 }
527 if(p2 && strcmp(p->name, p2->name)==0){
528 if(p->decode) decode=1;
529 if(p->encode) encode=1;
530 cap |= p->capabilities;
531 }
532 }
533 if(p2==NULL)
534 break;
535 last_name= p2->name;
536
537 switch(p2->type) {
538 case AVMEDIA_TYPE_VIDEO:
539 type_str = "V";
540 break;
541 case AVMEDIA_TYPE_AUDIO:
542 type_str = "A";
543 break;
544 case AVMEDIA_TYPE_SUBTITLE:
545 type_str = "S";
546 break;
547 default:
548 type_str = "?";
549 break;
550 }
551 printf(
552 " %s%s%s%s%s%s %-15s %s",
553 decode ? "D": (/*p2->decoder ? "d":*/" "),
554 encode ? "E":" ",
555 type_str,
556 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
557 cap & CODEC_CAP_DR1 ? "D":" ",
558 cap & CODEC_CAP_TRUNCATED ? "T":" ",
559 p2->name,
560 p2->long_name ? p2->long_name : "");
561 /* if(p2->decoder && decode==0)
562 printf(" use %s for decoding", p2->decoder->name);*/
563 printf("\n");
564 }
565 printf("\n");
566 printf(
567 "Note, the names of encoders and decoders do not always match, so there are\n"
568 "several cases where the above table shows encoder only or decoder only entries\n"
569 "even though both encoding and decoding are supported. For example, the h263\n"
570 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
571 "worse.\n");
572 }
573
574 void show_bsfs(void)
575 {
576 AVBitStreamFilter *bsf=NULL;
577
578 printf("Bitstream filters:\n");
579 while((bsf = av_bitstream_filter_next(bsf)))
580 printf("%s\n", bsf->name);
581 printf("\n");
582 }
583
584 void show_protocols(void)
585 {
586 URLProtocol *up=NULL;
587
588 printf("Supported file protocols:\n"
589 "I.. = Input supported\n"
590 ".O. = Output supported\n"
591 "..S = Seek supported\n"
592 "FLAGS NAME\n"
593 "----- \n");
594 while((up = av_protocol_next(up)))
595 printf("%c%c%c %s\n",
596 up->url_read ? 'I' : '.',
597 up->url_write ? 'O' : '.',
598 up->url_seek ? 'S' : '.',
599 up->name);
600 }
601
602 void show_filters(void)
603 {
604 AVFilter av_unused(**filter) = NULL;
605
606 printf("Filters:\n");
607 #if CONFIG_AVFILTER
608 while ((filter = av_filter_next(filter)) && *filter)
609 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
610 #endif
611 }
612
613 void show_pix_fmts(void)
614 {
615 enum PixelFormat pix_fmt;
616
617 printf(
618 "Pixel formats:\n"
619 "I.... = Supported Input format for conversion\n"
620 ".O... = Supported Output format for conversion\n"
621 "..H.. = Hardware accelerated format\n"
622 "...P. = Paletted format\n"
623 "....B = Bitstream format\n"
624 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
625 "-----\n");
626
627 #if !CONFIG_SWSCALE
628 # define sws_isSupportedInput(x) 0
629 # define sws_isSupportedOutput(x) 0
630 #endif
631
632 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
633 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
634 printf("%c%c%c%c%c %-16s %d %2d\n",
635 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
636 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
637 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
638 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
639 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
640 pix_desc->name,
641 pix_desc->nb_components,
642 av_get_bits_per_pixel(pix_desc));
643 }
644 }
645
646 int read_yesno(void)
647 {
648 int c = getchar();
649 int yesno = (toupper(c) == 'Y');
650
651 while (c != '\n' && c != EOF)
652 c = getchar();
653
654 return yesno;
655 }
656
657 int read_file(const char *filename, char **bufptr, size_t *size)
658 {
659 FILE *f = fopen(filename, "rb");
660
661 if (!f) {
662 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
663 return AVERROR(errno);
664 }
665 fseek(f, 0, SEEK_END);
666 *size = ftell(f);
667 fseek(f, 0, SEEK_SET);
668 *bufptr = av_malloc(*size + 1);
669 if (!*bufptr) {
670 fprintf(stderr, "Could not allocate file buffer\n");
671 fclose(f);
672 return AVERROR(ENOMEM);
673 }
674 fread(*bufptr, 1, *size, f);
675 (*bufptr)[*size++] = '\0';
676
677 fclose(f);
678 return 0;
679 }