Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 0c55c6d3

History | View | Annotate | Download (28 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
        //opt_values are only stored for codec-specific options in which case
83
        //both the name and value are dup'd
84
        if (opt_values[i]) {
85
            av_freep(&opt_names[i]);
86
            av_freep(&opt_values[i]);
87
        }
88
    }
89
    av_freep(&opt_names);
90
    av_freep(&opt_values);
91
}
92

    
93
void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
94
{
95
    vfprintf(stdout, fmt, vl);
96
}
97

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

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

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

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

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

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

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

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

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

    
237
    for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
238
        const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
239
        if(o2)
240
            ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
241
    }
242
    if(!o && avformat_opts)
243
        ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
244
    if(!o && sws_opts)
245
        ret = av_set_string3(sws_opts, opt, arg, 1, &o);
246
    if(!o){
247
        if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
248
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
249
        else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
250
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
251
        else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
252
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
253
    }
254
    if (o && ret < 0) {
255
        fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
256
        exit(1);
257
    }
258
    if (!o) {
259
        AVCodec *p = NULL;
260
        AVOutputFormat *oformat = NULL;
261
        while ((p=av_codec_next(p))){
262
            AVClass *c= p->priv_class;
263
            if(c && av_find_opt(&c, opt, NULL, 0, 0))
264
                break;
265
        }
266
        if (!p) {
267
            while ((oformat = av_oformat_next(oformat))) {
268
                const AVClass *c = oformat->priv_class;
269
                if (c && av_find_opt(&c, opt, NULL, 0, 0))
270
                    break;
271
            }
272
        }
273
        if(!p && !oformat){
274
            fprintf(stderr, "Unrecognized option '%s'\n", opt);
275
            exit(1);
276
        }
277
    }
278

    
279
//    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));
280

    
281
    //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
282
    opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
283
    opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
284
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
285
    opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
286

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

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

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

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

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

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

    
356
    for(i=0; i<opt_name_count; i++){
357
        char buf[256];
358
        const AVOption *opt;
359
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
360
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
361
        if(str && ((opt->flags & flags) == flags))
362
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
363
        /* We need to use a differnt system to pass options to the private context because
364
           it is not known which codec and thus context kind that will be when parsing options
365
           we thus use opt_values directly instead of opts_ctx */
366
        if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
367
            av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
368
        }
369
    }
370
}
371

    
372
void print_error(const char *filename, int err)
373
{
374
    char errbuf[128];
375
    const char *errbuf_ptr = errbuf;
376

    
377
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
378
        errbuf_ptr = strerror(AVUNERROR(err));
379
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
380
}
381

    
382
static int warned_cfg = 0;
383

    
384
#define INDENT        1
385
#define SHOW_VERSION  2
386
#define SHOW_CONFIG   4
387

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

    
415
static void print_all_libs_info(FILE* outstream, int flags)
416
{
417
    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
418
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
419
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
420
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
421
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
422
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
423
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
424
}
425

    
426
void show_banner(void)
427
{
428
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
429
            program_name, program_birth_year, this_year);
430
    fprintf(stderr, "  built on %s %s with %s %s\n",
431
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
432
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
433
    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
434
    print_all_libs_info(stderr, INDENT|SHOW_VERSION);
435
}
436

    
437
void show_version(void) {
438
    printf("%s " FFMPEG_VERSION "\n", program_name);
439
    print_all_libs_info(stdout, SHOW_VERSION);
440
}
441

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

    
511
void show_formats(void)
512
{
513
    AVInputFormat *ifmt=NULL;
514
    AVOutputFormat *ofmt=NULL;
515
    const char *last_name;
516

    
517
    printf(
518
        "File formats:\n"
519
        " D. = Demuxing supported\n"
520
        " .E = Muxing supported\n"
521
        " --\n");
522
    last_name= "000";
523
    for(;;){
524
        int decode=0;
525
        int encode=0;
526
        const char *name=NULL;
527
        const char *long_name=NULL;
528

    
529
        while((ofmt= av_oformat_next(ofmt))) {
530
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
531
                strcmp(ofmt->name, last_name)>0){
532
                name= ofmt->name;
533
                long_name= ofmt->long_name;
534
                encode=1;
535
            }
536
        }
537
        while((ifmt= av_iformat_next(ifmt))) {
538
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
539
                strcmp(ifmt->name, last_name)>0){
540
                name= ifmt->name;
541
                long_name= ifmt->long_name;
542
                encode=0;
543
            }
544
            if(name && strcmp(ifmt->name, name)==0)
545
                decode=1;
546
        }
547
        if(name==NULL)
548
            break;
549
        last_name= name;
550

    
551
        printf(
552
            " %s%s %-15s %s\n",
553
            decode ? "D":" ",
554
            encode ? "E":" ",
555
            name,
556
            long_name ? long_name:" ");
557
    }
558
}
559

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

    
582
        p2=NULL;
583
        while((p= av_codec_next(p))) {
584
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
585
                strcmp(p->name, last_name)>0){
586
                p2= p;
587
                decode= encode= cap=0;
588
            }
589
            if(p2 && strcmp(p->name, p2->name)==0){
590
                if(p->decode) decode=1;
591
                if(p->encode) encode=1;
592
                cap |= p->capabilities;
593
            }
594
        }
595
        if(p2==NULL)
596
            break;
597
        last_name= p2->name;
598

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

    
636
void show_bsfs(void)
637
{
638
    AVBitStreamFilter *bsf=NULL;
639

    
640
    printf("Bitstream filters:\n");
641
    while((bsf = av_bitstream_filter_next(bsf)))
642
        printf("%s\n", bsf->name);
643
    printf("\n");
644
}
645

    
646
void show_protocols(void)
647
{
648
    URLProtocol *up=NULL;
649

    
650
    printf("Supported file protocols:\n"
651
           "I.. = Input  supported\n"
652
           ".O. = Output supported\n"
653
           "..S = Seek   supported\n"
654
           "FLAGS NAME\n"
655
           "----- \n");
656
    while((up = av_protocol_next(up)))
657
        printf("%c%c%c   %s\n",
658
               up->url_read  ? 'I' : '.',
659
               up->url_write ? 'O' : '.',
660
               up->url_seek  ? 'S' : '.',
661
               up->name);
662
}
663

    
664
void show_filters(void)
665
{
666
    AVFilter av_unused(**filter) = NULL;
667

    
668
    printf("Filters:\n");
669
#if CONFIG_AVFILTER
670
    while ((filter = av_filter_next(filter)) && *filter)
671
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
672
#endif
673
}
674

    
675
void show_pix_fmts(void)
676
{
677
    enum PixelFormat pix_fmt;
678

    
679
    printf(
680
        "Pixel formats:\n"
681
        "I.... = Supported Input  format for conversion\n"
682
        ".O... = Supported Output format for conversion\n"
683
        "..H.. = Hardware accelerated format\n"
684
        "...P. = Paletted format\n"
685
        "....B = Bitstream format\n"
686
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
687
        "-----\n");
688

    
689
#if !CONFIG_SWSCALE
690
#   define sws_isSupportedInput(x)  0
691
#   define sws_isSupportedOutput(x) 0
692
#endif
693

    
694
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
695
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
696
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
697
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
698
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
699
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
700
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
701
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
702
               pix_desc->name,
703
               pix_desc->nb_components,
704
               av_get_bits_per_pixel(pix_desc));
705
    }
706
}
707

    
708
int read_yesno(void)
709
{
710
    int c = getchar();
711
    int yesno = (toupper(c) == 'Y');
712

    
713
    while (c != '\n' && c != EOF)
714
        c = getchar();
715

    
716
    return yesno;
717
}
718

    
719
int read_file(const char *filename, char **bufptr, size_t *size)
720
{
721
    FILE *f = fopen(filename, "rb");
722

    
723
    if (!f) {
724
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
725
        return AVERROR(errno);
726
    }
727
    fseek(f, 0, SEEK_END);
728
    *size = ftell(f);
729
    fseek(f, 0, SEEK_SET);
730
    *bufptr = av_malloc(*size + 1);
731
    if (!*bufptr) {
732
        fprintf(stderr, "Could not allocate file buffer\n");
733
        fclose(f);
734
        return AVERROR(ENOMEM);
735
    }
736
    fread(*bufptr, 1, *size, f);
737
    (*bufptr)[*size++] = '\0';
738

    
739
    fclose(f);
740
    return 0;
741
}
742

    
743
FILE *get_preset_file(char *filename, size_t filename_size,
744
                      const char *preset_name, int is_path, const char *codec_name)
745
{
746
    FILE *f = NULL;
747
    int i;
748
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
749
                           getenv("HOME"),
750
                           FFMPEG_DATADIR,
751
                         };
752

    
753
    if (is_path) {
754
        av_strlcpy(filename, preset_name, filename_size);
755
        f = fopen(filename, "r");
756
    } else {
757
        for (i = 0; i < 3 && !f; i++) {
758
            if (!base[i])
759
                continue;
760
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
761
            f = fopen(filename, "r");
762
            if (!f && codec_name) {
763
                snprintf(filename, filename_size,
764
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
765
                f = fopen(filename, "r");
766
            }
767
        }
768
    }
769

    
770
    return f;
771
}
772

    
773
#if CONFIG_AVFILTER
774

    
775
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
776
{
777
    FFSinkContext *priv = ctx->priv;
778

    
779
    if (!opaque)
780
        return AVERROR(EINVAL);
781
    *priv = *(FFSinkContext *)opaque;
782

    
783
    return 0;
784
}
785

    
786
static void null_end_frame(AVFilterLink *inlink) { }
787

    
788
static int ffsink_query_formats(AVFilterContext *ctx)
789
{
790
    FFSinkContext *priv = ctx->priv;
791
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
792

    
793
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
794
    return 0;
795
}
796

    
797
AVFilter ffsink = {
798
    .name      = "ffsink",
799
    .priv_size = sizeof(FFSinkContext),
800
    .init      = ffsink_init,
801

    
802
    .query_formats = ffsink_query_formats,
803

    
804
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
805
                                    .type          = AVMEDIA_TYPE_VIDEO,
806
                                    .end_frame     = null_end_frame,
807
                                    .min_perms     = AV_PERM_READ, },
808
                                  { .name = NULL }},
809
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
810
};
811

    
812
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
813
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
814
{
815
    int ret;
816
    AVFilterBufferRef *picref;
817

    
818
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
819
        return ret;
820
    if (!(picref = ctx->inputs[0]->cur_buf))
821
        return AVERROR(ENOENT);
822
    *picref_ptr = picref;
823
    ctx->inputs[0]->cur_buf = NULL;
824
    *tb = ctx->inputs[0]->time_base;
825

    
826
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
827
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
828
    frame->interlaced_frame = picref->video->interlaced;
829
    frame->top_field_first  = picref->video->top_field_first;
830

    
831
    return 1;
832
}
833

    
834
#endif /* CONFIG_AVFILTER */