Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 2ee5c789

History | View | Annotate | Download (22.7 KB)

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
           "I.. = Input  supported\n"
585
           ".O. = Output supported\n"
586
           "..S = Seek   supported\n"
587
           "FLAGS NAME\n"
588
           "----- \n");
589
    while((up = av_protocol_next(up)))
590
        printf("%c%c%c   %s\n",
591
               up->url_read  ? 'I' : '.',
592
               up->url_write ? 'O' : '.',
593
               up->url_seek  ? 'S' : '.',
594
               up->name);
595
}
596

    
597
void show_filters(void)
598
{
599
    AVFilter av_unused(**filter) = NULL;
600

    
601
    printf("Filters:\n");
602
#if CONFIG_AVFILTER
603
    while ((filter = av_filter_next(filter)) && *filter)
604
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
605
#endif
606
}
607

    
608
void show_pix_fmts(void)
609
{
610
    enum PixelFormat pix_fmt;
611

    
612
    printf(
613
        "Pixel formats:\n"
614
        "I.... = Supported Input  format for conversion\n"
615
        ".O... = Supported Output format for conversion\n"
616
        "..H.. = Hardware accelerated format\n"
617
        "...P. = Paletted format\n"
618
        "....B = Bitstream format\n"
619
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
620
        "-----\n");
621

    
622
#if !CONFIG_SWSCALE
623
#   define sws_isSupportedInput(x)  0
624
#   define sws_isSupportedOutput(x) 0
625
#endif
626

    
627
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
628
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
629
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
630
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
631
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
632
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
633
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
634
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
635
               pix_desc->name,
636
               pix_desc->nb_components,
637
               av_get_bits_per_pixel(pix_desc));
638
    }
639
}
640

    
641
int read_yesno(void)
642
{
643
    int c = getchar();
644
    int yesno = (toupper(c) == 'Y');
645

    
646
    while (c != '\n' && c != EOF)
647
        c = getchar();
648

    
649
    return yesno;
650
}
651

    
652
int read_file(const char *filename, char **bufptr, size_t *size)
653
{
654
    FILE *f = fopen(filename, "rb");
655

    
656
    if (!f) {
657
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
658
        return AVERROR(errno);
659
    }
660
    fseek(f, 0, SEEK_END);
661
    *size = ftell(f);
662
    fseek(f, 0, SEEK_SET);
663
    *bufptr = av_malloc(*size + 1);
664
    if (!*bufptr) {
665
        fprintf(stderr, "Could not allocate file buffer\n");
666
        fclose(f);
667
        return AVERROR(ENOMEM);
668
    }
669
    fread(*bufptr, 1, *size, f);
670
    (*bufptr)[*size++] = '\0';
671

    
672
    fclose(f);
673
    return 0;
674
}