Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 20e021c7

History | View | Annotate | Download (22.9 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
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; *avcodec_opts && 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 && avformat_opts)
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 && avcodec_opts[0]->debug) || (avformat_opts && 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
}