Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 9e5381a2

History | View | Annotate | Download (21.4 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
                    fprintf(stderr, "%s: invalid value '%s' for option '%s'\n", argv[0], arg, opt);
175
                    exit(1);
176
                }
177
            } else {
178
                po->u.func_arg(arg);
179
            }
180
            if(po->flags & OPT_EXIT)
181
                exit(0);
182
        } else {
183
            if (parse_arg_function)
184
                parse_arg_function(opt);
185
        }
186
    }
187
}
188

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

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

    
219
//    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));
220

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

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

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

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

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

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

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

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

    
329
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent)             \
330
    if (CONFIG_##LIBNAME) {                                             \
331
        unsigned int version = libname##_version();                     \
332
        fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n",    \
333
                indent? "  " : "", #libname,                            \
334
                LIB##LIBNAME##_VERSION_MAJOR,                           \
335
                LIB##LIBNAME##_VERSION_MINOR,                           \
336
                LIB##LIBNAME##_VERSION_MICRO,                           \
337
                version >> 16, version >> 8 & 0xff, version & 0xff);    \
338
    }
339

    
340
static void print_all_lib_versions(FILE* outstream, int indent)
341
{
342
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
343
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
344
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
345
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
346
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
347
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
348
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
349
}
350

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

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

    
364
#define PRINT_LIB_CONFIG(lib, tag, cfg) do {    \
365
        if (CONFIG_##lib)                       \
366
            maybe_print_config(tag, cfg);       \
367
    } while (0)
368

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

    
386
void show_version(void) {
387
    printf("%s " FFMPEG_VERSION "\n", program_name);
388
    print_all_lib_versions(stdout, 0);
389
}
390

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

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

    
470
void show_formats(void)
471
{
472
    AVInputFormat *ifmt=NULL;
473
    AVOutputFormat *ofmt=NULL;
474
    const char *last_name;
475

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

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

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

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

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

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

    
595
void show_bsfs(void)
596
{
597
    AVBitStreamFilter *bsf=NULL;
598

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

    
605
void show_protocols(void)
606
{
607
    URLProtocol *up=NULL;
608

    
609
    printf("Supported file protocols:\n");
610
    while((up = av_protocol_next(up)))
611
        printf("%s\n", up->name);
612
    printf("\n");
613

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

    
617
void show_filters(void)
618
{
619
    AVFilter av_unused(**filter) = NULL;
620

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

    
628
void show_pix_fmts(void)
629
{
630
    list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
631
}
632

    
633
int read_yesno(void)
634
{
635
    int c = getchar();
636
    int yesno = (toupper(c) == 'Y');
637

    
638
    while (c != '\n' && c != EOF)
639
        c = getchar();
640

    
641
    return yesno;
642
}