Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 6580d5e3

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

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

    
55
const int this_year = 2010;
56

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
629
void show_pix_fmts(void)
630
{
631
    enum PixelFormat pix_fmt;
632

    
633
    printf(
634
        "Pixel formats:\n"
635
        "I.... = Supported Input  format for conversion\n"
636
        ".O... = Supported Output format for conversion\n"
637
        "..H.. = Hardware accelerated format\n"
638
        "...P. = Paletted format\n"
639
        "....B = Bitstream format\n"
640
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
641
        "-----\n");
642

    
643
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
644
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
645
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
646
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
647
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
648
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
649
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
650
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
651
               pix_desc->name,
652
               pix_desc->nb_components,
653
               av_get_bits_per_pixel(pix_desc));
654
    }
655
}
656

    
657
int read_yesno(void)
658
{
659
    int c = getchar();
660
    int yesno = (toupper(c) == 'Y');
661

    
662
    while (c != '\n' && c != EOF)
663
        c = getchar();
664

    
665
    return yesno;
666
}