Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 58fe804a

History | View | Annotate | Download (21 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
    if (CONFIG_##LIBNAME) { \
329
    version= libname##_version(); \
330
    fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
331
            LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
332
            version >> 16, version >> 8 & 0xff, version & 0xff); \
333
    }
334

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

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

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

    
360
#define PRINT_LIB_CONFIG(lib, tag, cfg) do {    \
361
        if (CONFIG_##lib)                       \
362
            maybe_print_config(tag, cfg);       \
363
    } while (0)
364

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
637
    return yesno;
638
}