Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ d3190644

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

    
51
const char **opt_names;
52
const char **opt_values;
53
static int opt_name_count;
54
AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
55
AVFormatContext *avformat_opts;
56
struct SwsContext *sws_opts;
57

    
58
static const int this_year = 2011;
59

    
60
void init_opts(void)
61
{
62
    int i;
63
    for (i = 0; i < AVMEDIA_TYPE_NB; i++)
64
        avcodec_opts[i] = avcodec_alloc_context2(i);
65
    avformat_opts = avformat_alloc_context();
66
#if CONFIG_SWSCALE
67
    sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
68
#endif
69
}
70

    
71
void uninit_opts(void)
72
{
73
    int i;
74
    for (i = 0; i < AVMEDIA_TYPE_NB; i++)
75
        av_freep(&avcodec_opts[i]);
76
    av_freep(&avformat_opts->key);
77
    av_freep(&avformat_opts);
78
#if CONFIG_SWSCALE
79
    av_freep(&sws_opts);
80
#endif
81
    for (i = 0; i < opt_name_count; i++) {
82
        av_freep(&opt_names[i]);
83
        av_freep(&opt_values[i]);
84
    }
85
    av_freep(&opt_names);
86
    av_freep(&opt_values);
87
}
88

    
89
void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
90
{
91
    vfprintf(stdout, fmt, vl);
92
}
93

    
94
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
95
{
96
    char *tail;
97
    const char *error;
98
    double d = av_strtod(numstr, &tail);
99
    if (*tail)
100
        error= "Expected number for %s but found: %s\n";
101
    else if (d < min || d > max)
102
        error= "The value for %s was %s which is not within %f - %f\n";
103
    else if(type == OPT_INT64 && (int64_t)d != d)
104
        error= "Expected int64 for %s but found %s\n";
105
    else if (type == OPT_INT && (int)d != d)
106
        error= "Expected int for %s but found %s\n";
107
    else
108
        return d;
109
    fprintf(stderr, error, context, numstr, min, max);
110
    exit(1);
111
}
112

    
113
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
114
{
115
    int64_t us;
116
    if (av_parse_time(&us, timestr, is_duration) < 0) {
117
        fprintf(stderr, "Invalid %s specification for %s: %s\n",
118
                is_duration ? "duration" : "date", context, timestr);
119
        exit(1);
120
    }
121
    return us;
122
}
123

    
124
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
125
{
126
    const OptionDef *po;
127
    int first;
128

    
129
    first = 1;
130
    for(po = options; po->name != NULL; po++) {
131
        char buf[64];
132
        if ((po->flags & mask) == value) {
133
            if (first) {
134
                printf("%s", msg);
135
                first = 0;
136
            }
137
            av_strlcpy(buf, po->name, sizeof(buf));
138
            if (po->flags & HAS_ARG) {
139
                av_strlcat(buf, " ", sizeof(buf));
140
                av_strlcat(buf, po->argname, sizeof(buf));
141
            }
142
            printf("-%-17s  %s\n", buf, po->help);
143
        }
144
    }
145
}
146

    
147
static const OptionDef* find_option(const OptionDef *po, const char *name){
148
    while (po->name != NULL) {
149
        if (!strcmp(name, po->name))
150
            break;
151
        po++;
152
    }
153
    return po;
154
}
155

    
156
void parse_options(int argc, char **argv, const OptionDef *options,
157
                   void (* parse_arg_function)(const char*))
158
{
159
    const char *opt, *arg;
160
    int optindex, handleoptions=1;
161
    const OptionDef *po;
162

    
163
    /* parse options */
164
    optindex = 1;
165
    while (optindex < argc) {
166
        opt = argv[optindex++];
167

    
168
        if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
169
            int bool_val = 1;
170
            if (opt[1] == '-' && opt[2] == '\0') {
171
                handleoptions = 0;
172
                continue;
173
            }
174
            opt++;
175
            po= find_option(options, opt);
176
            if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
177
                /* handle 'no' bool option */
178
                po = find_option(options, opt + 2);
179
                if (!(po->name && (po->flags & OPT_BOOL)))
180
                    goto unknown_opt;
181
                bool_val = 0;
182
            }
183
            if (!po->name)
184
                po= find_option(options, "default");
185
            if (!po->name) {
186
unknown_opt:
187
                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
188
                exit(1);
189
            }
190
            arg = NULL;
191
            if (po->flags & HAS_ARG) {
192
                arg = argv[optindex++];
193
                if (!arg) {
194
                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
195
                    exit(1);
196
                }
197
            }
198
            if (po->flags & OPT_STRING) {
199
                char *str;
200
                str = av_strdup(arg);
201
                *po->u.str_arg = str;
202
            } else if (po->flags & OPT_BOOL) {
203
                *po->u.int_arg = bool_val;
204
            } else if (po->flags & OPT_INT) {
205
                *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
206
            } else if (po->flags & OPT_INT64) {
207
                *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
208
            } else if (po->flags & OPT_FLOAT) {
209
                *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
210
            } else if (po->flags & OPT_FUNC2) {
211
                if (po->u.func2_arg(opt, arg) < 0) {
212
                    fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
213
                    exit(1);
214
                }
215
            } else if (po->flags & OPT_DUMMY) {
216
                /* Do nothing for this option */
217
            } else {
218
                po->u.func_arg(arg);
219
            }
220
            if(po->flags & OPT_EXIT)
221
                exit(0);
222
        } else {
223
            if (parse_arg_function)
224
                parse_arg_function(opt);
225
        }
226
    }
227
}
228

    
229
int opt_default(const char *opt, const char *arg){
230
    int type;
231
    int ret= 0;
232
    const AVOption *o= NULL;
233
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
234
    AVCodec *p = NULL;
235
    AVOutputFormat *oformat = NULL;
236

    
237
    while ((p = av_codec_next(p))) {
238
        AVClass *c = p->priv_class;
239
        if (c && av_find_opt(&c, opt, NULL, 0, 0))
240
            break;
241
    }
242
    if (p)
243
        goto out;
244
    while ((oformat = av_oformat_next(oformat))) {
245
        const AVClass *c = oformat->priv_class;
246
        if (c && av_find_opt(&c, opt, NULL, 0, 0))
247
            break;
248
    }
249
    if (oformat)
250
        goto out;
251

    
252
    for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
253
        const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
254
        if(o2)
255
            ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
256
    }
257
    if(!o && avformat_opts)
258
        ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
259
    if(!o && sws_opts)
260
        ret = av_set_string3(sws_opts, opt, arg, 1, &o);
261
    if(!o){
262
        if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
263
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
264
        else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
265
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
266
        else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
267
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
268
        if (ret >= 0)
269
            opt += 1;
270
    }
271
    if (o && ret < 0) {
272
        fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
273
        exit(1);
274
    }
275
    if (!o) {
276
        fprintf(stderr, "Unrecognized option '%s'\n", opt);
277
        exit(1);
278
    }
279

    
280
 out:
281
//    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));
282

    
283
    opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
284
    opt_values[opt_name_count] = av_strdup(arg);
285
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
286
    opt_names[opt_name_count++] = av_strdup(opt);
287

    
288
    if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
289
        av_log_set_level(AV_LOG_DEBUG);
290
    return 0;
291
}
292

    
293
int opt_loglevel(const char *opt, const char *arg)
294
{
295
    const struct { const char *name; int level; } log_levels[] = {
296
        { "quiet"  , AV_LOG_QUIET   },
297
        { "panic"  , AV_LOG_PANIC   },
298
        { "fatal"  , AV_LOG_FATAL   },
299
        { "error"  , AV_LOG_ERROR   },
300
        { "warning", AV_LOG_WARNING },
301
        { "info"   , AV_LOG_INFO    },
302
        { "verbose", AV_LOG_VERBOSE },
303
        { "debug"  , AV_LOG_DEBUG   },
304
    };
305
    char *tail;
306
    int level;
307
    int i;
308

    
309
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
310
        if (!strcmp(log_levels[i].name, arg)) {
311
            av_log_set_level(log_levels[i].level);
312
            return 0;
313
        }
314
    }
315

    
316
    level = strtol(arg, &tail, 10);
317
    if (*tail) {
318
        fprintf(stderr, "Invalid loglevel \"%s\". "
319
                        "Possible levels are numbers or:\n", arg);
320
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
321
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
322
        exit(1);
323
    }
324
    av_log_set_level(level);
325
    return 0;
326
}
327

    
328
int opt_timelimit(const char *opt, const char *arg)
329
{
330
#if HAVE_SETRLIMIT
331
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
332
    struct rlimit rl = { lim, lim + 1 };
333
    if (setrlimit(RLIMIT_CPU, &rl))
334
        perror("setrlimit");
335
#else
336
    fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
337
#endif
338
    return 0;
339
}
340

    
341
void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
342
{
343
    int i;
344
    void *priv_ctx=NULL;
345
    if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
346
        AVCodecContext *avctx= ctx;
347
        if(codec && codec->priv_class && avctx->priv_data){
348
            priv_ctx= avctx->priv_data;
349
        }
350
    } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
351
        AVFormatContext *avctx = ctx;
352
        if (avctx->oformat && avctx->oformat->priv_class) {
353
            priv_ctx = avctx->priv_data;
354
        }
355
    }
356

    
357
    for(i=0; i<opt_name_count; i++){
358
        char buf[256];
359
        const AVOption *opt;
360
        const char *str;
361
        if (priv_ctx) {
362
            if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
363
                if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 0, NULL) < 0) {
364
                    fprintf(stderr, "Invalid value '%s' for option '%s'\n",
365
                            opt_names[i], opt_values[i]);
366
                    exit(1);
367
                }
368
            } else
369
                goto global;
370
        } else {
371
        global:
372
            str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
373
            /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
374
            if (str && ((opt->flags & flags) == flags))
375
                av_set_string3(ctx, opt_names[i], str, 1, NULL);
376
        }
377
    }
378
}
379

    
380
void print_error(const char *filename, int err)
381
{
382
    char errbuf[128];
383
    const char *errbuf_ptr = errbuf;
384

    
385
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
386
        errbuf_ptr = strerror(AVUNERROR(err));
387
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
388
}
389

    
390
static int warned_cfg = 0;
391

    
392
#define INDENT        1
393
#define SHOW_VERSION  2
394
#define SHOW_CONFIG   4
395

    
396
#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
397
    if (CONFIG_##LIBNAME) {                                             \
398
        const char *indent = flags & INDENT? "  " : "";                 \
399
        if (flags & SHOW_VERSION) {                                     \
400
            unsigned int version = libname##_version();                 \
401
            fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
402
                    indent, #libname,                                   \
403
                    LIB##LIBNAME##_VERSION_MAJOR,                       \
404
                    LIB##LIBNAME##_VERSION_MINOR,                       \
405
                    LIB##LIBNAME##_VERSION_MICRO,                       \
406
                    version >> 16, version >> 8 & 0xff, version & 0xff); \
407
        }                                                               \
408
        if (flags & SHOW_CONFIG) {                                      \
409
            const char *cfg = libname##_configuration();                \
410
            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
411
                if (!warned_cfg) {                                      \
412
                    fprintf(outstream,                                  \
413
                            "%sWARNING: library configuration mismatch\n", \
414
                            indent);                                    \
415
                    warned_cfg = 1;                                     \
416
                }                                                       \
417
                fprintf(stderr, "%s%-11s configuration: %s\n",          \
418
                        indent, #libname, cfg);                         \
419
            }                                                           \
420
        }                                                               \
421
    }                                                                   \
422

    
423
static void print_all_libs_info(FILE* outstream, int flags)
424
{
425
    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
426
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
427
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
428
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
429
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
430
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
431
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
432
}
433

    
434
void show_banner(void)
435
{
436
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
437
            program_name, program_birth_year, this_year);
438
    fprintf(stderr, "  built on %s %s with %s %s\n",
439
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
440
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
441
    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
442
    print_all_libs_info(stderr, INDENT|SHOW_VERSION);
443
}
444

    
445
void show_version(void) {
446
    printf("%s " FFMPEG_VERSION "\n", program_name);
447
    print_all_libs_info(stdout, SHOW_VERSION);
448
}
449

    
450
void show_license(void)
451
{
452
    printf(
453
#if CONFIG_NONFREE
454
    "This version of %s has nonfree parts compiled in.\n"
455
    "Therefore it is not legally redistributable.\n",
456
    program_name
457
#elif CONFIG_GPLV3
458
    "%s is free software; you can redistribute it and/or modify\n"
459
    "it under the terms of the GNU General Public License as published by\n"
460
    "the Free Software Foundation; either version 3 of the License, or\n"
461
    "(at your option) any later version.\n"
462
    "\n"
463
    "%s is distributed in the hope that it will be useful,\n"
464
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
465
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
466
    "GNU General Public License for more details.\n"
467
    "\n"
468
    "You should have received a copy of the GNU General Public License\n"
469
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
470
    program_name, program_name, program_name
471
#elif CONFIG_GPL
472
    "%s is free software; you can redistribute it and/or modify\n"
473
    "it under the terms of the GNU General Public License as published by\n"
474
    "the Free Software Foundation; either version 2 of the License, or\n"
475
    "(at your option) any later version.\n"
476
    "\n"
477
    "%s is distributed in the hope that it will be useful,\n"
478
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
479
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
480
    "GNU General Public License for more details.\n"
481
    "\n"
482
    "You should have received a copy of the GNU General Public License\n"
483
    "along with %s; if not, write to the Free Software\n"
484
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
485
    program_name, program_name, program_name
486
#elif CONFIG_LGPLV3
487
    "%s is free software; you can redistribute it and/or modify\n"
488
    "it under the terms of the GNU Lesser General Public License as published by\n"
489
    "the Free Software Foundation; either version 3 of the License, or\n"
490
    "(at your option) any later version.\n"
491
    "\n"
492
    "%s is distributed in the hope that it will be useful,\n"
493
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
494
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
495
    "GNU Lesser General Public License for more details.\n"
496
    "\n"
497
    "You should have received a copy of the GNU Lesser General Public License\n"
498
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
499
    program_name, program_name, program_name
500
#else
501
    "%s is free software; you can redistribute it and/or\n"
502
    "modify it under the terms of the GNU Lesser General Public\n"
503
    "License as published by the Free Software Foundation; either\n"
504
    "version 2.1 of the License, or (at your option) any later version.\n"
505
    "\n"
506
    "%s is distributed in the hope that it will be useful,\n"
507
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
508
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
509
    "Lesser General Public License for more details.\n"
510
    "\n"
511
    "You should have received a copy of the GNU Lesser General Public\n"
512
    "License along with %s; if not, write to the Free Software\n"
513
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
514
    program_name, program_name, program_name
515
#endif
516
    );
517
}
518

    
519
void show_formats(void)
520
{
521
    AVInputFormat *ifmt=NULL;
522
    AVOutputFormat *ofmt=NULL;
523
    const char *last_name;
524

    
525
    printf(
526
        "File formats:\n"
527
        " D. = Demuxing supported\n"
528
        " .E = Muxing supported\n"
529
        " --\n");
530
    last_name= "000";
531
    for(;;){
532
        int decode=0;
533
        int encode=0;
534
        const char *name=NULL;
535
        const char *long_name=NULL;
536

    
537
        while((ofmt= av_oformat_next(ofmt))) {
538
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
539
                strcmp(ofmt->name, last_name)>0){
540
                name= ofmt->name;
541
                long_name= ofmt->long_name;
542
                encode=1;
543
            }
544
        }
545
        while((ifmt= av_iformat_next(ifmt))) {
546
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
547
                strcmp(ifmt->name, last_name)>0){
548
                name= ifmt->name;
549
                long_name= ifmt->long_name;
550
                encode=0;
551
            }
552
            if(name && strcmp(ifmt->name, name)==0)
553
                decode=1;
554
        }
555
        if(name==NULL)
556
            break;
557
        last_name= name;
558

    
559
        printf(
560
            " %s%s %-15s %s\n",
561
            decode ? "D":" ",
562
            encode ? "E":" ",
563
            name,
564
            long_name ? long_name:" ");
565
    }
566
}
567

    
568
void show_codecs(void)
569
{
570
    AVCodec *p=NULL, *p2;
571
    const char *last_name;
572
    printf(
573
        "Codecs:\n"
574
        " D..... = Decoding supported\n"
575
        " .E.... = Encoding supported\n"
576
        " ..V... = Video codec\n"
577
        " ..A... = Audio codec\n"
578
        " ..S... = Subtitle codec\n"
579
        " ...S.. = Supports draw_horiz_band\n"
580
        " ....D. = Supports direct rendering method 1\n"
581
        " .....T = Supports weird frame truncation\n"
582
        " ------\n");
583
    last_name= "000";
584
    for(;;){
585
        int decode=0;
586
        int encode=0;
587
        int cap=0;
588
        const char *type_str;
589

    
590
        p2=NULL;
591
        while((p= av_codec_next(p))) {
592
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
593
                strcmp(p->name, last_name)>0){
594
                p2= p;
595
                decode= encode= cap=0;
596
            }
597
            if(p2 && strcmp(p->name, p2->name)==0){
598
                if(p->decode) decode=1;
599
                if(p->encode) encode=1;
600
                cap |= p->capabilities;
601
            }
602
        }
603
        if(p2==NULL)
604
            break;
605
        last_name= p2->name;
606

    
607
        switch(p2->type) {
608
        case AVMEDIA_TYPE_VIDEO:
609
            type_str = "V";
610
            break;
611
        case AVMEDIA_TYPE_AUDIO:
612
            type_str = "A";
613
            break;
614
        case AVMEDIA_TYPE_SUBTITLE:
615
            type_str = "S";
616
            break;
617
        default:
618
            type_str = "?";
619
            break;
620
        }
621
        printf(
622
            " %s%s%s%s%s%s %-15s %s",
623
            decode ? "D": (/*p2->decoder ? "d":*/" "),
624
            encode ? "E":" ",
625
            type_str,
626
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
627
            cap & CODEC_CAP_DR1 ? "D":" ",
628
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
629
            p2->name,
630
            p2->long_name ? p2->long_name : "");
631
       /* if(p2->decoder && decode==0)
632
            printf(" use %s for decoding", p2->decoder->name);*/
633
        printf("\n");
634
    }
635
    printf("\n");
636
    printf(
637
"Note, the names of encoders and decoders do not always match, so there are\n"
638
"several cases where the above table shows encoder only or decoder only entries\n"
639
"even though both encoding and decoding are supported. For example, the h263\n"
640
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
641
"worse.\n");
642
}
643

    
644
void show_bsfs(void)
645
{
646
    AVBitStreamFilter *bsf=NULL;
647

    
648
    printf("Bitstream filters:\n");
649
    while((bsf = av_bitstream_filter_next(bsf)))
650
        printf("%s\n", bsf->name);
651
    printf("\n");
652
}
653

    
654
void show_protocols(void)
655
{
656
    URLProtocol *up=NULL;
657

    
658
    printf("Supported file protocols:\n"
659
           "I.. = Input  supported\n"
660
           ".O. = Output supported\n"
661
           "..S = Seek   supported\n"
662
           "FLAGS NAME\n"
663
           "----- \n");
664
    while((up = av_protocol_next(up)))
665
        printf("%c%c%c   %s\n",
666
               up->url_read  ? 'I' : '.',
667
               up->url_write ? 'O' : '.',
668
               up->url_seek  ? 'S' : '.',
669
               up->name);
670
}
671

    
672
void show_filters(void)
673
{
674
    AVFilter av_unused(**filter) = NULL;
675

    
676
    printf("Filters:\n");
677
#if CONFIG_AVFILTER
678
    while ((filter = av_filter_next(filter)) && *filter)
679
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
680
#endif
681
}
682

    
683
void show_pix_fmts(void)
684
{
685
    enum PixelFormat pix_fmt;
686

    
687
    printf(
688
        "Pixel formats:\n"
689
        "I.... = Supported Input  format for conversion\n"
690
        ".O... = Supported Output format for conversion\n"
691
        "..H.. = Hardware accelerated format\n"
692
        "...P. = Paletted format\n"
693
        "....B = Bitstream format\n"
694
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
695
        "-----\n");
696

    
697
#if !CONFIG_SWSCALE
698
#   define sws_isSupportedInput(x)  0
699
#   define sws_isSupportedOutput(x) 0
700
#endif
701

    
702
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
703
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
704
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
705
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
706
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
707
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
708
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
709
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
710
               pix_desc->name,
711
               pix_desc->nb_components,
712
               av_get_bits_per_pixel(pix_desc));
713
    }
714
}
715

    
716
int read_yesno(void)
717
{
718
    int c = getchar();
719
    int yesno = (toupper(c) == 'Y');
720

    
721
    while (c != '\n' && c != EOF)
722
        c = getchar();
723

    
724
    return yesno;
725
}
726

    
727
int read_file(const char *filename, char **bufptr, size_t *size)
728
{
729
    FILE *f = fopen(filename, "rb");
730

    
731
    if (!f) {
732
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
733
        return AVERROR(errno);
734
    }
735
    fseek(f, 0, SEEK_END);
736
    *size = ftell(f);
737
    fseek(f, 0, SEEK_SET);
738
    *bufptr = av_malloc(*size + 1);
739
    if (!*bufptr) {
740
        fprintf(stderr, "Could not allocate file buffer\n");
741
        fclose(f);
742
        return AVERROR(ENOMEM);
743
    }
744
    fread(*bufptr, 1, *size, f);
745
    (*bufptr)[*size++] = '\0';
746

    
747
    fclose(f);
748
    return 0;
749
}
750

    
751
FILE *get_preset_file(char *filename, size_t filename_size,
752
                      const char *preset_name, int is_path, const char *codec_name)
753
{
754
    FILE *f = NULL;
755
    int i;
756
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
757
                           getenv("HOME"),
758
                           FFMPEG_DATADIR,
759
                         };
760

    
761
    if (is_path) {
762
        av_strlcpy(filename, preset_name, filename_size);
763
        f = fopen(filename, "r");
764
    } else {
765
        for (i = 0; i < 3 && !f; i++) {
766
            if (!base[i])
767
                continue;
768
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
769
            f = fopen(filename, "r");
770
            if (!f && codec_name) {
771
                snprintf(filename, filename_size,
772
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
773
                f = fopen(filename, "r");
774
            }
775
        }
776
    }
777

    
778
    return f;
779
}
780

    
781
#if CONFIG_AVFILTER
782

    
783
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
784
{
785
    FFSinkContext *priv = ctx->priv;
786

    
787
    if (!opaque)
788
        return AVERROR(EINVAL);
789
    *priv = *(FFSinkContext *)opaque;
790

    
791
    return 0;
792
}
793

    
794
static void null_end_frame(AVFilterLink *inlink) { }
795

    
796
static int ffsink_query_formats(AVFilterContext *ctx)
797
{
798
    FFSinkContext *priv = ctx->priv;
799
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
800

    
801
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
802
    return 0;
803
}
804

    
805
AVFilter ffsink = {
806
    .name      = "ffsink",
807
    .priv_size = sizeof(FFSinkContext),
808
    .init      = ffsink_init,
809

    
810
    .query_formats = ffsink_query_formats,
811

    
812
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
813
                                    .type          = AVMEDIA_TYPE_VIDEO,
814
                                    .end_frame     = null_end_frame,
815
                                    .min_perms     = AV_PERM_READ, },
816
                                  { .name = NULL }},
817
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
818
};
819

    
820
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
821
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
822
{
823
    int ret;
824
    AVFilterBufferRef *picref;
825

    
826
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
827
        return ret;
828
    if (!(picref = ctx->inputs[0]->cur_buf))
829
        return AVERROR(ENOENT);
830
    *picref_ptr = picref;
831
    ctx->inputs[0]->cur_buf = NULL;
832
    *tb = ctx->inputs[0]->time_base;
833

    
834
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
835
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
836
    frame->interlaced_frame = picref->video->interlaced;
837
    frame->top_field_first  = picref->video->top_field_first;
838
    frame->key_frame        = picref->video->key_frame;
839
    frame->pict_type        = picref->video->pict_type;
840

    
841
    return 1;
842
}
843

    
844
#endif /* CONFIG_AVFILTER */