Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 9e94bd3e

History | View | Annotate | Download (21.8 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: failed to set 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
    const char *errbuf_ptr = errbuf;
296

    
297
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
298
        errbuf_ptr = strerror(AVUNERROR(err));
299
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
300
}
301

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

    
313
static void print_all_lib_versions(FILE* outstream, int indent)
314
{
315
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
316
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
317
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
318
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
319
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
320
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
321
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
322
}
323

    
324
static void maybe_print_config(const char *lib, const char *cfg)
325
{
326
    static int warned_cfg;
327

    
328
    if (strcmp(FFMPEG_CONFIGURATION, cfg)) {
329
        if (!warned_cfg) {
330
            fprintf(stderr, "  WARNING: library configuration mismatch\n");
331
            warned_cfg = 1;
332
        }
333
        fprintf(stderr, "  %-11s configuration: %s\n", lib, cfg);
334
    }
335
}
336

    
337
#define PRINT_LIB_CONFIG(lib, tag, cfg) do {    \
338
        if (CONFIG_##lib)                       \
339
            maybe_print_config(tag, cfg);       \
340
    } while (0)
341

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

    
359
void show_version(void) {
360
    printf("%s " FFMPEG_VERSION "\n", program_name);
361
    print_all_lib_versions(stdout, 0);
362
}
363

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

    
433
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
434
{
435
    int i;
436
    char fmt_str[128];
437
    for (i=-1; i < nb_fmts; i++) {
438
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
439
        fprintf(stdout, "%s\n", fmt_str);
440
    }
441
}
442

    
443
void show_formats(void)
444
{
445
    AVInputFormat *ifmt=NULL;
446
    AVOutputFormat *ofmt=NULL;
447
    const char *last_name;
448

    
449
    printf(
450
        "File formats:\n"
451
        " D. = Demuxing supported\n"
452
        " .E = Muxing supported\n"
453
        " --\n");
454
    last_name= "000";
455
    for(;;){
456
        int decode=0;
457
        int encode=0;
458
        const char *name=NULL;
459
        const char *long_name=NULL;
460

    
461
        while((ofmt= av_oformat_next(ofmt))) {
462
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
463
                strcmp(ofmt->name, last_name)>0){
464
                name= ofmt->name;
465
                long_name= ofmt->long_name;
466
                encode=1;
467
            }
468
        }
469
        while((ifmt= av_iformat_next(ifmt))) {
470
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
471
                strcmp(ifmt->name, last_name)>0){
472
                name= ifmt->name;
473
                long_name= ifmt->long_name;
474
                encode=0;
475
            }
476
            if(name && strcmp(ifmt->name, name)==0)
477
                decode=1;
478
        }
479
        if(name==NULL)
480
            break;
481
        last_name= name;
482

    
483
        printf(
484
            " %s%s %-15s %s\n",
485
            decode ? "D":" ",
486
            encode ? "E":" ",
487
            name,
488
            long_name ? long_name:" ");
489
    }
490
}
491

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

    
514
        p2=NULL;
515
        while((p= av_codec_next(p))) {
516
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
517
                strcmp(p->name, last_name)>0){
518
                p2= p;
519
                decode= encode= cap=0;
520
            }
521
            if(p2 && strcmp(p->name, p2->name)==0){
522
                if(p->decode) decode=1;
523
                if(p->encode) encode=1;
524
                cap |= p->capabilities;
525
            }
526
        }
527
        if(p2==NULL)
528
            break;
529
        last_name= p2->name;
530

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

    
568
void show_bsfs(void)
569
{
570
    AVBitStreamFilter *bsf=NULL;
571

    
572
    printf("Bitstream filters:\n");
573
    while((bsf = av_bitstream_filter_next(bsf)))
574
        printf("%s\n", bsf->name);
575
    printf("\n");
576
}
577

    
578
void show_protocols(void)
579
{
580
    URLProtocol *up=NULL;
581

    
582
    printf("Supported file protocols:\n");
583
    while((up = av_protocol_next(up)))
584
        printf("%s\n", up->name);
585
}
586

    
587
void show_filters(void)
588
{
589
    AVFilter av_unused(**filter) = NULL;
590

    
591
    printf("Filters:\n");
592
#if CONFIG_AVFILTER
593
    while ((filter = av_filter_next(filter)) && *filter)
594
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
595
#endif
596
}
597

    
598
void show_pix_fmts(void)
599
{
600
    enum PixelFormat pix_fmt;
601

    
602
    printf(
603
        "Pixel formats:\n"
604
        "I.... = Supported Input  format for conversion\n"
605
        ".O... = Supported Output format for conversion\n"
606
        "..H.. = Hardware accelerated format\n"
607
        "...P. = Paletted format\n"
608
        "....B = Bitstream format\n"
609
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
610
        "-----\n");
611

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

    
626
int read_yesno(void)
627
{
628
    int c = getchar();
629
    int yesno = (toupper(c) == 'Y');
630

    
631
    while (c != '\n' && c != EOF)
632
        c = getchar();
633

    
634
    return yesno;
635
}
636

    
637
int read_file(const char *filename, char **bufptr, size_t *size)
638
{
639
    FILE *f = fopen(filename, "r");
640

    
641
    if (!f) {
642
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
643
        return AVERROR(errno);
644
    }
645
    fseek(f, 0, SEEK_END);
646
    *size = ftell(f);
647
    fseek(f, 0, SEEK_SET);
648
    *bufptr = av_malloc(*size + 1);
649
    if (!*bufptr) {
650
        fprintf(stderr, "Could not allocate file buffer\n");
651
        fclose(f);
652
        return AVERROR(ENOMEM);
653
    }
654
    fread(*bufptr, 1, *size, f);
655
    (*bufptr)[*size++] = '\0';
656

    
657
    fclose(f);
658
    return 0;
659
}