Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 9120e2cd

History | View | Annotate | Download (20.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 "libavcodec/opt.h"
39
#include "cmdutils.h"
40
#include "version.h"
41
#if CONFIG_NETWORK
42
#include "libavformat/network.h"
43
#endif
44
#if HAVE_SYS_RESOURCE_H
45
#include <sys/resource.h>
46
#endif
47

    
48
#undef exit
49

    
50
const char **opt_names;
51
static int opt_name_count;
52
AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
53
AVFormatContext *avformat_opts;
54
struct SwsContext *sws_opts;
55

    
56
const int this_year = 2010;
57

    
58
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
59
{
60
    char *tail;
61
    const char *error;
62
    double d = strtod(numstr, &tail);
63
    if (*tail)
64
        error= "Expected number for %s but found: %s\n";
65
    else if (d < min || d > max)
66
        error= "The value for %s was %s which is not within %f - %f\n";
67
    else if(type == OPT_INT64 && (int64_t)d != d)
68
        error= "Expected int64 for %s but found %s\n";
69
    else
70
        return d;
71
    fprintf(stderr, error, context, numstr, min, max);
72
    exit(1);
73
}
74

    
75
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
76
{
77
    int64_t us = parse_date(timestr, is_duration);
78
    if (us == INT64_MIN) {
79
        fprintf(stderr, "Invalid %s specification for %s: %s\n",
80
                is_duration ? "duration" : "date", context, timestr);
81
        exit(1);
82
    }
83
    return us;
84
}
85

    
86
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
87
{
88
    const OptionDef *po;
89
    int first;
90

    
91
    first = 1;
92
    for(po = options; po->name != NULL; po++) {
93
        char buf[64];
94
        if ((po->flags & mask) == value) {
95
            if (first) {
96
                printf("%s", msg);
97
                first = 0;
98
            }
99
            av_strlcpy(buf, po->name, sizeof(buf));
100
            if (po->flags & HAS_ARG) {
101
                av_strlcat(buf, " ", sizeof(buf));
102
                av_strlcat(buf, po->argname, sizeof(buf));
103
            }
104
            printf("-%-17s  %s\n", buf, po->help);
105
        }
106
    }
107
}
108

    
109
static const OptionDef* find_option(const OptionDef *po, const char *name){
110
    while (po->name != NULL) {
111
        if (!strcmp(name, po->name))
112
            break;
113
        po++;
114
    }
115
    return po;
116
}
117

    
118
void parse_options(int argc, char **argv, const OptionDef *options,
119
                   void (* parse_arg_function)(const char*))
120
{
121
    const char *opt, *arg;
122
    int optindex, handleoptions=1;
123
    const OptionDef *po;
124

    
125
    /* parse options */
126
    optindex = 1;
127
    while (optindex < argc) {
128
        opt = argv[optindex++];
129

    
130
        if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
131
            int bool_val = 1;
132
            if (opt[1] == '-' && opt[2] == '\0') {
133
                handleoptions = 0;
134
                continue;
135
            }
136
            opt++;
137
            po= find_option(options, opt);
138
            if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
139
                /* handle 'no' bool option */
140
                po = find_option(options, opt + 2);
141
                if (!(po->name && (po->flags & OPT_BOOL)))
142
                    goto unknown_opt;
143
                bool_val = 0;
144
            }
145
            if (!po->name)
146
                po= find_option(options, "default");
147
            if (!po->name) {
148
unknown_opt:
149
                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
150
                exit(1);
151
            }
152
            arg = NULL;
153
            if (po->flags & HAS_ARG) {
154
                arg = argv[optindex++];
155
                if (!arg) {
156
                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
157
                    exit(1);
158
                }
159
            }
160
            if (po->flags & OPT_STRING) {
161
                char *str;
162
                str = av_strdup(arg);
163
                *po->u.str_arg = str;
164
            } else if (po->flags & OPT_BOOL) {
165
                *po->u.int_arg = bool_val;
166
            } else if (po->flags & OPT_INT) {
167
                *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
168
            } else if (po->flags & OPT_INT64) {
169
                *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
170
            } else if (po->flags & OPT_FLOAT) {
171
                *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
172
            } else if (po->flags & OPT_FUNC2) {
173
                if(po->u.func2_arg(opt, arg)<0)
174
                    goto unknown_opt;
175
            } else {
176
                po->u.func_arg(arg);
177
            }
178
            if(po->flags & OPT_EXIT)
179
                exit(0);
180
        } else {
181
            if (parse_arg_function)
182
                parse_arg_function(opt);
183
        }
184
    }
185
}
186

    
187
int opt_default(const char *opt, const char *arg){
188
    int type;
189
    int ret= 0;
190
    const AVOption *o= NULL;
191
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
192

    
193
    for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
194
        const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
195
        if(o2)
196
            ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
197
    }
198
    if(!o)
199
        ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
200
    if(!o)
201
        ret = av_set_string3(sws_opts, opt, arg, 1, &o);
202
    if(!o){
203
        if(opt[0] == 'a')
204
            ret = av_set_string3(avcodec_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
205
        else if(opt[0] == 'v')
206
            ret = av_set_string3(avcodec_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
207
        else if(opt[0] == 's')
208
            ret = av_set_string3(avcodec_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
209
    }
210
    if (o && ret < 0) {
211
        fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
212
        exit(1);
213
    }
214
    if(!o)
215
        return -1;
216

    
217
//    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));
218

    
219
    //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
220
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
221
    opt_names[opt_name_count++]= o->name;
222

    
223
    if(avcodec_opts[0]->debug || avformat_opts->debug)
224
        av_log_set_level(AV_LOG_DEBUG);
225
    return 0;
226
}
227

    
228
int opt_loglevel(const char *opt, const char *arg)
229
{
230
    const struct { const char *name; int level; } log_levels[] = {
231
        { "quiet"  , AV_LOG_QUIET   },
232
        { "panic"  , AV_LOG_PANIC   },
233
        { "fatal"  , AV_LOG_FATAL   },
234
        { "error"  , AV_LOG_ERROR   },
235
        { "warning", AV_LOG_WARNING },
236
        { "info"   , AV_LOG_INFO    },
237
        { "verbose", AV_LOG_VERBOSE },
238
        { "debug"  , AV_LOG_DEBUG   },
239
    };
240
    char *tail;
241
    int level;
242
    int i;
243

    
244
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
245
        if (!strcmp(log_levels[i].name, arg)) {
246
            av_log_set_level(log_levels[i].level);
247
            return 0;
248
        }
249
    }
250

    
251
    level = strtol(arg, &tail, 10);
252
    if (*tail) {
253
        fprintf(stderr, "Invalid loglevel \"%s\". "
254
                        "Possible levels are numbers or:\n", arg);
255
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
256
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
257
        exit(1);
258
    }
259
    av_log_set_level(level);
260
    return 0;
261
}
262

    
263
int opt_timelimit(const char *opt, const char *arg)
264
{
265
#if HAVE_SYS_RESOURCE_H
266
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
267
    struct rlimit rl = { lim, lim + 1 };
268
    if (setrlimit(RLIMIT_CPU, &rl))
269
        perror("setrlimit");
270
#else
271
    fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
272
#endif
273
    return 0;
274
}
275

    
276
void set_context_opts(void *ctx, void *opts_ctx, int flags)
277
{
278
    int i;
279
    for(i=0; i<opt_name_count; i++){
280
        char buf[256];
281
        const AVOption *opt;
282
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
283
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
284
        if(str && ((opt->flags & flags) == flags))
285
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
286
    }
287
}
288

    
289
void print_error(const char *filename, int err)
290
{
291
    switch(err) {
292
    case AVERROR_NUMEXPECTED:
293
        fprintf(stderr, "%s: Incorrect image filename syntax.\n"
294
                "Use '%%d' to specify the image number:\n"
295
                "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
296
                "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
297
                filename);
298
        break;
299
    case AVERROR_INVALIDDATA:
300
        fprintf(stderr, "%s: Error while parsing header\n", filename);
301
        break;
302
    case AVERROR_NOFMT:
303
        fprintf(stderr, "%s: Unknown format\n", filename);
304
        break;
305
    case AVERROR(EIO):
306
        fprintf(stderr, "%s: I/O error occurred\n"
307
                "Usually that means that input file is truncated and/or corrupted.\n",
308
                filename);
309
        break;
310
    case AVERROR(ENOMEM):
311
        fprintf(stderr, "%s: memory allocation error occurred\n", filename);
312
        break;
313
    case AVERROR(ENOENT):
314
        fprintf(stderr, "%s: no such file or directory\n", filename);
315
        break;
316
#if CONFIG_NETWORK
317
    case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
318
        fprintf(stderr, "%s: Unsupported network protocol\n", filename);
319
        break;
320
#endif
321
    default:
322
        fprintf(stderr, "%s: Error while opening file\n", filename);
323
        break;
324
    }
325
}
326

    
327
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
328
    version= libname##_version(); \
329
    fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
330
            LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
331
            version >> 16, version >> 8 & 0xff, version & 0xff);
332

    
333
static void print_all_lib_versions(FILE* outstream, int indent)
334
{
335
    unsigned int version;
336
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
337
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
338
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
339
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
340
#if CONFIG_AVFILTER
341
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
342
#endif
343
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
344
#if CONFIG_POSTPROC
345
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
346
#endif
347
}
348

    
349
static void maybe_print_config(const char *lib, const char *cfg)
350
{
351
    static int warned_cfg;
352

    
353
    if (strcmp(FFMPEG_CONFIGURATION, cfg)) {
354
        if (!warned_cfg) {
355
            fprintf(stderr, "  WARNING: library configuration mismatch\n");
356
            warned_cfg = 1;
357
        }
358
        fprintf(stderr, "  %-11s configuration: %s\n", lib, cfg);
359
    }
360
}
361

    
362
void show_banner(void)
363
{
364
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
365
            program_name, program_birth_year, this_year);
366
    fprintf(stderr, "  built on %s %s with %s %s\n",
367
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
368
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
369
    maybe_print_config("libavutil",   avutil_configuration());
370
    maybe_print_config("libavcodec",  avcodec_configuration());
371
    maybe_print_config("libavformat", avformat_configuration());
372
    maybe_print_config("libavdevice", avdevice_configuration());
373
#if CONFIG_AVFILTER
374
    maybe_print_config("libavfilter", avfilter_configuration());
375
#endif
376
    maybe_print_config("libswscale",  swscale_configuration());
377
#if CONFIG_POSTPROC
378
    maybe_print_config("libpostproc", postproc_configuration());
379
#endif
380
    print_all_lib_versions(stderr, 1);
381
}
382

    
383
void show_version(void) {
384
    printf("%s " FFMPEG_VERSION "\n", program_name);
385
    print_all_lib_versions(stdout, 0);
386
}
387

    
388
void show_license(void)
389
{
390
    printf(
391
#if CONFIG_NONFREE
392
    "This version of %s has nonfree parts compiled in.\n"
393
    "Therefore it is not legally redistributable.\n",
394
    program_name
395
#elif CONFIG_GPLV3
396
    "%s is free software; you can redistribute it and/or modify\n"
397
    "it under the terms of the GNU General Public License as published by\n"
398
    "the Free Software Foundation; either version 3 of the License, or\n"
399
    "(at your option) any later version.\n"
400
    "\n"
401
    "%s is distributed in the hope that it will be useful,\n"
402
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
403
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
404
    "GNU General Public License for more details.\n"
405
    "\n"
406
    "You should have received a copy of the GNU General Public License\n"
407
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
408
    program_name, program_name, program_name
409
#elif CONFIG_GPL
410
    "%s is free software; you can redistribute it and/or modify\n"
411
    "it under the terms of the GNU General Public License as published by\n"
412
    "the Free Software Foundation; either version 2 of the License, or\n"
413
    "(at your option) any later version.\n"
414
    "\n"
415
    "%s is distributed in the hope that it will be useful,\n"
416
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
417
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
418
    "GNU General Public License for more details.\n"
419
    "\n"
420
    "You should have received a copy of the GNU General Public License\n"
421
    "along with %s; if not, write to the Free Software\n"
422
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
423
    program_name, program_name, program_name
424
#elif CONFIG_LGPLV3
425
    "%s is free software; you can redistribute it and/or modify\n"
426
    "it under the terms of the GNU Lesser General Public License as published by\n"
427
    "the Free Software Foundation; either version 3 of the License, or\n"
428
    "(at your option) any later version.\n"
429
    "\n"
430
    "%s is distributed in the hope that it will be useful,\n"
431
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
432
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
433
    "GNU Lesser General Public License for more details.\n"
434
    "\n"
435
    "You should have received a copy of the GNU Lesser General Public License\n"
436
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
437
    program_name, program_name, program_name
438
#else
439
    "%s is free software; you can redistribute it and/or\n"
440
    "modify it under the terms of the GNU Lesser General Public\n"
441
    "License as published by the Free Software Foundation; either\n"
442
    "version 2.1 of the License, or (at your option) any later version.\n"
443
    "\n"
444
    "%s is distributed in the hope that it will be useful,\n"
445
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
446
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
447
    "Lesser General Public License for more details.\n"
448
    "\n"
449
    "You should have received a copy of the GNU Lesser General Public\n"
450
    "License along with %s; if not, write to the Free Software\n"
451
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
452
    program_name, program_name, program_name
453
#endif
454
    );
455
}
456

    
457
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
458
{
459
    int i;
460
    char fmt_str[128];
461
    for (i=-1; i < nb_fmts; i++) {
462
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
463
        fprintf(stdout, "%s\n", fmt_str);
464
    }
465
}
466

    
467
void show_formats(void)
468
{
469
    AVInputFormat *ifmt=NULL;
470
    AVOutputFormat *ofmt=NULL;
471
    const char *last_name;
472

    
473
    printf(
474
        "File formats:\n"
475
        " D. = Demuxing supported\n"
476
        " .E = Muxing supported\n"
477
        " --\n");
478
    last_name= "000";
479
    for(;;){
480
        int decode=0;
481
        int encode=0;
482
        const char *name=NULL;
483
        const char *long_name=NULL;
484

    
485
        while((ofmt= av_oformat_next(ofmt))) {
486
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
487
                strcmp(ofmt->name, last_name)>0){
488
                name= ofmt->name;
489
                long_name= ofmt->long_name;
490
                encode=1;
491
            }
492
        }
493
        while((ifmt= av_iformat_next(ifmt))) {
494
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
495
                strcmp(ifmt->name, last_name)>0){
496
                name= ifmt->name;
497
                long_name= ifmt->long_name;
498
                encode=0;
499
            }
500
            if(name && strcmp(ifmt->name, name)==0)
501
                decode=1;
502
        }
503
        if(name==NULL)
504
            break;
505
        last_name= name;
506

    
507
        printf(
508
            " %s%s %-15s %s\n",
509
            decode ? "D":" ",
510
            encode ? "E":" ",
511
            name,
512
            long_name ? long_name:" ");
513
    }
514
}
515

    
516
void show_codecs(void)
517
{
518
    AVCodec *p=NULL, *p2;
519
    const char *last_name;
520
    printf(
521
        "Codecs:\n"
522
        " D..... = Decoding supported\n"
523
        " .E.... = Encoding supported\n"
524
        " ..V... = Video codec\n"
525
        " ..A... = Audio codec\n"
526
        " ..S... = Subtitle codec\n"
527
        " ...S.. = Supports draw_horiz_band\n"
528
        " ....D. = Supports direct rendering method 1\n"
529
        " .....T = Supports weird frame truncation\n"
530
        " ------\n");
531
    last_name= "000";
532
    for(;;){
533
        int decode=0;
534
        int encode=0;
535
        int cap=0;
536
        const char *type_str;
537

    
538
        p2=NULL;
539
        while((p= av_codec_next(p))) {
540
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
541
                strcmp(p->name, last_name)>0){
542
                p2= p;
543
                decode= encode= cap=0;
544
            }
545
            if(p2 && strcmp(p->name, p2->name)==0){
546
                if(p->decode) decode=1;
547
                if(p->encode) encode=1;
548
                cap |= p->capabilities;
549
            }
550
        }
551
        if(p2==NULL)
552
            break;
553
        last_name= p2->name;
554

    
555
        switch(p2->type) {
556
        case CODEC_TYPE_VIDEO:
557
            type_str = "V";
558
            break;
559
        case CODEC_TYPE_AUDIO:
560
            type_str = "A";
561
            break;
562
        case CODEC_TYPE_SUBTITLE:
563
            type_str = "S";
564
            break;
565
        default:
566
            type_str = "?";
567
            break;
568
        }
569
        printf(
570
            " %s%s%s%s%s%s %-15s %s",
571
            decode ? "D": (/*p2->decoder ? "d":*/" "),
572
            encode ? "E":" ",
573
            type_str,
574
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
575
            cap & CODEC_CAP_DR1 ? "D":" ",
576
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
577
            p2->name,
578
            p2->long_name ? p2->long_name : "");
579
       /* if(p2->decoder && decode==0)
580
            printf(" use %s for decoding", p2->decoder->name);*/
581
        printf("\n");
582
    }
583
    printf("\n");
584
    printf(
585
"Note, the names of encoders and decoders do not always match, so there are\n"
586
"several cases where the above table shows encoder only or decoder only entries\n"
587
"even though both encoding and decoding are supported. For example, the h263\n"
588
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
589
"worse.\n");
590
}
591

    
592
void show_bsfs(void)
593
{
594
    AVBitStreamFilter *bsf=NULL;
595

    
596
    printf("Bitstream filters:\n");
597
    while((bsf = av_bitstream_filter_next(bsf)))
598
        printf("%s\n", bsf->name);
599
    printf("\n");
600
}
601

    
602
void show_protocols(void)
603
{
604
    URLProtocol *up=NULL;
605

    
606
    printf("Supported file protocols:\n");
607
    while((up = av_protocol_next(up)))
608
        printf("%s\n", up->name);
609
    printf("\n");
610

    
611
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
612
}
613

    
614
void show_filters(void)
615
{
616
    AVFilter av_unused(**filter) = NULL;
617

    
618
    printf("Filters:\n");
619
#if CONFIG_AVFILTER
620
    while ((filter = av_filter_next(filter)) && *filter)
621
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
622
#endif
623
}
624

    
625
void show_pix_fmts(void)
626
{
627
    list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
628
}
629

    
630
int read_yesno(void)
631
{
632
    int c = getchar();
633
    int yesno = (toupper(c) == 'Y');
634

    
635
    while (c != '\n' && c != EOF)
636
        c = getchar();
637

    
638
    return yesno;
639
}