Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 324e7ee2

History | View | Annotate | Download (28.6 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 "libavutil/eval.h"
40
#include "libavcodec/opt.h"
41
#include "libavcore/avcore.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
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
}
82

    
83
void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
84
{
85
    vfprintf(stdout, fmt, vl);
86
}
87

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

    
105
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
106
{
107
    int64_t us = parse_date(timestr, is_duration);
108
    if (us == INT64_MIN) {
109
        fprintf(stderr, "Invalid %s specification for %s: %s\n",
110
                is_duration ? "duration" : "date", context, timestr);
111
        exit(1);
112
    }
113
    return us;
114
}
115

    
116
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
117
{
118
    const OptionDef *po;
119
    int first;
120

    
121
    first = 1;
122
    for(po = options; po->name != NULL; po++) {
123
        char buf[64];
124
        if ((po->flags & mask) == value) {
125
            if (first) {
126
                printf("%s", msg);
127
                first = 0;
128
            }
129
            av_strlcpy(buf, po->name, sizeof(buf));
130
            if (po->flags & HAS_ARG) {
131
                av_strlcat(buf, " ", sizeof(buf));
132
                av_strlcat(buf, po->argname, sizeof(buf));
133
            }
134
            printf("-%-17s  %s\n", buf, po->help);
135
        }
136
    }
137
}
138

    
139
static const OptionDef* find_option(const OptionDef *po, const char *name){
140
    while (po->name != NULL) {
141
        if (!strcmp(name, po->name))
142
            break;
143
        po++;
144
    }
145
    return po;
146
}
147

    
148
void parse_options(int argc, char **argv, const OptionDef *options,
149
                   void (* parse_arg_function)(const char*))
150
{
151
    const char *opt, *arg;
152
    int optindex, handleoptions=1;
153
    const OptionDef *po;
154

    
155
    /* parse options */
156
    optindex = 1;
157
    while (optindex < argc) {
158
        opt = argv[optindex++];
159

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

    
219
int opt_default(const char *opt, const char *arg){
220
    int type;
221
    int ret= 0;
222
    const AVOption *o= NULL;
223
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
224

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

    
267
//    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));
268

    
269
    //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
270
    opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
271
    opt_values[opt_name_count]= o ? NULL : arg;
272
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
273
    opt_names[opt_name_count++]= o ? o->name : opt;
274

    
275
    if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
276
        av_log_set_level(AV_LOG_DEBUG);
277
    return 0;
278
}
279

    
280
int opt_loglevel(const char *opt, const char *arg)
281
{
282
    const struct { const char *name; int level; } log_levels[] = {
283
        { "quiet"  , AV_LOG_QUIET   },
284
        { "panic"  , AV_LOG_PANIC   },
285
        { "fatal"  , AV_LOG_FATAL   },
286
        { "error"  , AV_LOG_ERROR   },
287
        { "warning", AV_LOG_WARNING },
288
        { "info"   , AV_LOG_INFO    },
289
        { "verbose", AV_LOG_VERBOSE },
290
        { "debug"  , AV_LOG_DEBUG   },
291
    };
292
    char *tail;
293
    int level;
294
    int i;
295

    
296
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
297
        if (!strcmp(log_levels[i].name, arg)) {
298
            av_log_set_level(log_levels[i].level);
299
            return 0;
300
        }
301
    }
302

    
303
    level = strtol(arg, &tail, 10);
304
    if (*tail) {
305
        fprintf(stderr, "Invalid loglevel \"%s\". "
306
                        "Possible levels are numbers or:\n", arg);
307
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
308
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
309
        exit(1);
310
    }
311
    av_log_set_level(level);
312
    return 0;
313
}
314

    
315
int opt_timelimit(const char *opt, const char *arg)
316
{
317
#if HAVE_SETRLIMIT
318
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
319
    struct rlimit rl = { lim, lim + 1 };
320
    if (setrlimit(RLIMIT_CPU, &rl))
321
        perror("setrlimit");
322
#else
323
    fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
324
#endif
325
    return 0;
326
}
327

    
328
void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
329
{
330
    int i;
331
    void *priv_ctx=NULL;
332
    if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
333
        AVCodecContext *avctx= ctx;
334
        if(codec && codec->priv_class && avctx->priv_data){
335
            priv_ctx= avctx->priv_data;
336
        }
337
    } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
338
        AVFormatContext *avctx = ctx;
339
        if (avctx->oformat && avctx->oformat->priv_class) {
340
            priv_ctx = avctx->priv_data;
341
        }
342
    }
343

    
344
    for(i=0; i<opt_name_count; i++){
345
        char buf[256];
346
        const AVOption *opt;
347
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
348
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
349
        if(str && ((opt->flags & flags) == flags))
350
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
351
        /* We need to use a differnt system to pass options to the private context because
352
           it is not known which codec and thus context kind that will be when parsing options
353
           we thus use opt_values directly instead of opts_ctx */
354
        if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
355
            av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
356
        }
357
    }
358
}
359

    
360
void print_error(const char *filename, int err)
361
{
362
    char errbuf[128];
363
    const char *errbuf_ptr = errbuf;
364

    
365
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
366
        errbuf_ptr = strerror(AVUNERROR(err));
367
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
368
}
369

    
370
static int warned_cfg = 0;
371

    
372
#define INDENT        1
373
#define SHOW_VERSION  2
374
#define SHOW_CONFIG   4
375

    
376
#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
377
    if (CONFIG_##LIBNAME) {                                             \
378
        const char *indent = flags & INDENT? "  " : "";                 \
379
        if (flags & SHOW_VERSION) {                                     \
380
            unsigned int version = libname##_version();                 \
381
            fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
382
                    indent, #libname,                                   \
383
                    LIB##LIBNAME##_VERSION_MAJOR,                       \
384
                    LIB##LIBNAME##_VERSION_MINOR,                       \
385
                    LIB##LIBNAME##_VERSION_MICRO,                       \
386
                    version >> 16, version >> 8 & 0xff, version & 0xff); \
387
        }                                                               \
388
        if (flags & SHOW_CONFIG) {                                      \
389
            const char *cfg = libname##_configuration();                \
390
            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
391
                if (!warned_cfg) {                                      \
392
                    fprintf(outstream,                                  \
393
                            "%sWARNING: library configuration mismatch\n", \
394
                            indent);                                    \
395
                    warned_cfg = 1;                                     \
396
                }                                                       \
397
                fprintf(stderr, "%s%-11s configuration: %s\n",          \
398
                        indent, #libname, cfg);                         \
399
            }                                                           \
400
        }                                                               \
401
    }                                                                   \
402

    
403
static void print_all_libs_info(FILE* outstream, int flags)
404
{
405
    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
406
    PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
407
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
408
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
409
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
410
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
411
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
412
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
413
}
414

    
415
void show_banner(void)
416
{
417
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
418
            program_name, program_birth_year, this_year);
419
    fprintf(stderr, "  built on %s %s with %s %s\n",
420
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
421
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
422
    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
423
    print_all_libs_info(stderr, INDENT|SHOW_VERSION);
424
}
425

    
426
void show_version(void) {
427
    printf("%s " FFMPEG_VERSION "\n", program_name);
428
    print_all_libs_info(stdout, SHOW_VERSION);
429
}
430

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

    
500
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
501
{
502
    int i;
503
    char fmt_str[128];
504
    for (i=-1; i < nb_fmts; i++) {
505
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
506
        fprintf(stdout, "%s\n", fmt_str);
507
    }
508
}
509

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
715
    return yesno;
716
}
717

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

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

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

    
742
void init_pts_correction(PtsCorrectionContext *ctx)
743
{
744
    ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
745
    ctx->last_pts = ctx->last_dts = INT64_MIN;
746
}
747

    
748
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
749
{
750
    int64_t pts = AV_NOPTS_VALUE;
751

    
752
    if (dts != AV_NOPTS_VALUE) {
753
        ctx->num_faulty_dts += dts <= ctx->last_dts;
754
        ctx->last_dts = dts;
755
    }
756
    if (reordered_pts != AV_NOPTS_VALUE) {
757
        ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
758
        ctx->last_pts = reordered_pts;
759
    }
760
    if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
761
       && reordered_pts != AV_NOPTS_VALUE)
762
        pts = reordered_pts;
763
    else
764
        pts = dts;
765

    
766
    return pts;
767
}
768

    
769
FILE *get_preset_file(char *filename, size_t filename_size,
770
                      const char *preset_name, int is_path, const char *codec_name)
771
{
772
    FILE *f = NULL;
773
    int i;
774
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
775
                           getenv("HOME"),
776
                           FFMPEG_DATADIR,
777
                         };
778

    
779
    if (is_path) {
780
        av_strlcpy(filename, preset_name, filename_size);
781
        f = fopen(filename, "r");
782
    } else {
783
        for (i = 0; i < 3 && !f; i++) {
784
            if (!base[i])
785
                continue;
786
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
787
            f = fopen(filename, "r");
788
            if (!f && codec_name) {
789
                snprintf(filename, filename_size,
790
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
791
                f = fopen(filename, "r");
792
            }
793
        }
794
    }
795

    
796
    return f;
797
}
798

    
799
#if CONFIG_AVFILTER
800

    
801
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
802
{
803
    FFSinkContext *priv = ctx->priv;
804

    
805
    if (!opaque)
806
        return AVERROR(EINVAL);
807
    *priv = *(FFSinkContext *)opaque;
808

    
809
    return 0;
810
}
811

    
812
static void null_end_frame(AVFilterLink *inlink) { }
813

    
814
static int ffsink_query_formats(AVFilterContext *ctx)
815
{
816
    FFSinkContext *priv = ctx->priv;
817
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
818

    
819
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
820
    return 0;
821
}
822

    
823
AVFilter ffsink = {
824
    .name      = "ffsink",
825
    .priv_size = sizeof(FFSinkContext),
826
    .init      = ffsink_init,
827

    
828
    .query_formats = ffsink_query_formats,
829

    
830
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
831
                                    .type          = AVMEDIA_TYPE_VIDEO,
832
                                    .end_frame     = null_end_frame,
833
                                    .min_perms     = AV_PERM_READ, },
834
                                  { .name = NULL }},
835
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
836
};
837

    
838
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
839
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
840
{
841
    int ret;
842
    AVFilterBufferRef *picref;
843

    
844
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
845
        return ret;
846
    if (!(picref = ctx->inputs[0]->cur_buf))
847
        return AVERROR(ENOENT);
848
    *picref_ptr = picref;
849
    ctx->inputs[0]->cur_buf = NULL;
850
    *tb = ctx->inputs[0]->time_base;
851

    
852
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
853
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
854
    frame->interlaced_frame = picref->video->interlaced;
855
    frame->top_field_first  = picref->video->top_field_first;
856

    
857
    return 1;
858
}
859

    
860
#endif /* CONFIG_AVFILTER */