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