Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 72415b2a

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 "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[AVMEDIA_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<AVMEDIA_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[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
206
        else if(opt[0] == 'v')
207
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
208
        else if(opt[0] == 's')
209
            ret = av_set_string3(avcodec_opts[AVMEDIA_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
    char errbuf[128];
295

    
296
    switch(err) {
297
#if CONFIG_NETWORK
298
    case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
299
        fprintf(stderr, "%s: Unsupported network protocol\n", filename);
300
        break;
301
#endif
302
    default:
303
        av_strerror(err, errbuf, sizeof(errbuf));
304
        fprintf(stderr, "%s: %s\n", filename, errbuf);
305
    }
306
}
307

    
308
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent)             \
309
    if (CONFIG_##LIBNAME) {                                             \
310
        unsigned int version = libname##_version();                     \
311
        fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n",    \
312
                indent? "  " : "", #libname,                            \
313
                LIB##LIBNAME##_VERSION_MAJOR,                           \
314
                LIB##LIBNAME##_VERSION_MINOR,                           \
315
                LIB##LIBNAME##_VERSION_MICRO,                           \
316
                version >> 16, version >> 8 & 0xff, version & 0xff);    \
317
    }
318

    
319
static void print_all_lib_versions(FILE* outstream, int indent)
320
{
321
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
322
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
323
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
324
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
325
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
326
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
327
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
328
}
329

    
330
static void maybe_print_config(const char *lib, const char *cfg)
331
{
332
    static int warned_cfg;
333

    
334
    if (strcmp(FFMPEG_CONFIGURATION, cfg)) {
335
        if (!warned_cfg) {
336
            fprintf(stderr, "  WARNING: library configuration mismatch\n");
337
            warned_cfg = 1;
338
        }
339
        fprintf(stderr, "  %-11s configuration: %s\n", lib, cfg);
340
    }
341
}
342

    
343
#define PRINT_LIB_CONFIG(lib, tag, cfg) do {    \
344
        if (CONFIG_##lib)                       \
345
            maybe_print_config(tag, cfg);       \
346
    } while (0)
347

    
348
void show_banner(void)
349
{
350
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
351
            program_name, program_birth_year, this_year);
352
    fprintf(stderr, "  built on %s %s with %s %s\n",
353
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
354
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
355
    PRINT_LIB_CONFIG(AVUTIL,   "libavutil",   avutil_configuration());
356
    PRINT_LIB_CONFIG(AVCODEC,  "libavcodec",  avcodec_configuration());
357
    PRINT_LIB_CONFIG(AVFORMAT, "libavformat", avformat_configuration());
358
    PRINT_LIB_CONFIG(AVDEVICE, "libavdevice", avdevice_configuration());
359
    PRINT_LIB_CONFIG(AVFILTER, "libavfilter", avfilter_configuration());
360
    PRINT_LIB_CONFIG(SWSCALE,  "libswscale",  swscale_configuration());
361
    PRINT_LIB_CONFIG(POSTPROC, "libpostproc", postproc_configuration());
362
    print_all_lib_versions(stderr, 1);
363
}
364

    
365
void show_version(void) {
366
    printf("%s " FFMPEG_VERSION "\n", program_name);
367
    print_all_lib_versions(stdout, 0);
368
}
369

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

    
439
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
440
{
441
    int i;
442
    char fmt_str[128];
443
    for (i=-1; i < nb_fmts; i++) {
444
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
445
        fprintf(stdout, "%s\n", fmt_str);
446
    }
447
}
448

    
449
void show_formats(void)
450
{
451
    AVInputFormat *ifmt=NULL;
452
    AVOutputFormat *ofmt=NULL;
453
    const char *last_name;
454

    
455
    printf(
456
        "File formats:\n"
457
        " D. = Demuxing supported\n"
458
        " .E = Muxing supported\n"
459
        " --\n");
460
    last_name= "000";
461
    for(;;){
462
        int decode=0;
463
        int encode=0;
464
        const char *name=NULL;
465
        const char *long_name=NULL;
466

    
467
        while((ofmt= av_oformat_next(ofmt))) {
468
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
469
                strcmp(ofmt->name, last_name)>0){
470
                name= ofmt->name;
471
                long_name= ofmt->long_name;
472
                encode=1;
473
            }
474
        }
475
        while((ifmt= av_iformat_next(ifmt))) {
476
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
477
                strcmp(ifmt->name, last_name)>0){
478
                name= ifmt->name;
479
                long_name= ifmt->long_name;
480
                encode=0;
481
            }
482
            if(name && strcmp(ifmt->name, name)==0)
483
                decode=1;
484
        }
485
        if(name==NULL)
486
            break;
487
        last_name= name;
488

    
489
        printf(
490
            " %s%s %-15s %s\n",
491
            decode ? "D":" ",
492
            encode ? "E":" ",
493
            name,
494
            long_name ? long_name:" ");
495
    }
496
}
497

    
498
void show_codecs(void)
499
{
500
    AVCodec *p=NULL, *p2;
501
    const char *last_name;
502
    printf(
503
        "Codecs:\n"
504
        " D..... = Decoding supported\n"
505
        " .E.... = Encoding supported\n"
506
        " ..V... = Video codec\n"
507
        " ..A... = Audio codec\n"
508
        " ..S... = Subtitle codec\n"
509
        " ...S.. = Supports draw_horiz_band\n"
510
        " ....D. = Supports direct rendering method 1\n"
511
        " .....T = Supports weird frame truncation\n"
512
        " ------\n");
513
    last_name= "000";
514
    for(;;){
515
        int decode=0;
516
        int encode=0;
517
        int cap=0;
518
        const char *type_str;
519

    
520
        p2=NULL;
521
        while((p= av_codec_next(p))) {
522
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
523
                strcmp(p->name, last_name)>0){
524
                p2= p;
525
                decode= encode= cap=0;
526
            }
527
            if(p2 && strcmp(p->name, p2->name)==0){
528
                if(p->decode) decode=1;
529
                if(p->encode) encode=1;
530
                cap |= p->capabilities;
531
            }
532
        }
533
        if(p2==NULL)
534
            break;
535
        last_name= p2->name;
536

    
537
        switch(p2->type) {
538
        case AVMEDIA_TYPE_VIDEO:
539
            type_str = "V";
540
            break;
541
        case AVMEDIA_TYPE_AUDIO:
542
            type_str = "A";
543
            break;
544
        case AVMEDIA_TYPE_SUBTITLE:
545
            type_str = "S";
546
            break;
547
        default:
548
            type_str = "?";
549
            break;
550
        }
551
        printf(
552
            " %s%s%s%s%s%s %-15s %s",
553
            decode ? "D": (/*p2->decoder ? "d":*/" "),
554
            encode ? "E":" ",
555
            type_str,
556
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
557
            cap & CODEC_CAP_DR1 ? "D":" ",
558
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
559
            p2->name,
560
            p2->long_name ? p2->long_name : "");
561
       /* if(p2->decoder && decode==0)
562
            printf(" use %s for decoding", p2->decoder->name);*/
563
        printf("\n");
564
    }
565
    printf("\n");
566
    printf(
567
"Note, the names of encoders and decoders do not always match, so there are\n"
568
"several cases where the above table shows encoder only or decoder only entries\n"
569
"even though both encoding and decoding are supported. For example, the h263\n"
570
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
571
"worse.\n");
572
}
573

    
574
void show_bsfs(void)
575
{
576
    AVBitStreamFilter *bsf=NULL;
577

    
578
    printf("Bitstream filters:\n");
579
    while((bsf = av_bitstream_filter_next(bsf)))
580
        printf("%s\n", bsf->name);
581
    printf("\n");
582
}
583

    
584
void show_protocols(void)
585
{
586
    URLProtocol *up=NULL;
587

    
588
    printf("Supported file protocols:\n");
589
    while((up = av_protocol_next(up)))
590
        printf("%s\n", up->name);
591
}
592

    
593
void show_filters(void)
594
{
595
    AVFilter av_unused(**filter) = NULL;
596

    
597
    printf("Filters:\n");
598
#if CONFIG_AVFILTER
599
    while ((filter = av_filter_next(filter)) && *filter)
600
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
601
#endif
602
}
603

    
604
void show_pix_fmts(void)
605
{
606
    enum PixelFormat pix_fmt;
607

    
608
    printf(
609
        "Pixel formats:\n"
610
        "I.... = Supported Input  format for conversion\n"
611
        ".O... = Supported Output format for conversion\n"
612
        "..H.. = Hardware accelerated format\n"
613
        "...P. = Paletted format\n"
614
        "....B = Bitstream format\n"
615
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
616
        "-----\n");
617

    
618
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
619
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
620
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
621
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
622
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
623
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
624
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
625
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
626
               pix_desc->name,
627
               pix_desc->nb_components,
628
               av_get_bits_per_pixel(pix_desc));
629
    }
630
}
631

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

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

    
640
    return yesno;
641
}