Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ ff0652e5

History | View | Annotate | Download (26.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/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 = 2010;
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
    sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
67
}
68

    
69
void uninit_opts(void)
70
{
71
    int i;
72
    for (i = 0; i < AVMEDIA_TYPE_NB; i++)
73
        av_freep(&avcodec_opts[i]);
74
    av_freep(&avformat_opts->key);
75
    av_freep(&avformat_opts);
76
    av_freep(&sws_opts);
77
}
78

    
79
void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
80
{
81
    vfprintf(stdout, fmt, vl);
82
}
83

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

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

    
112
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
113
{
114
    const OptionDef *po;
115
    int first;
116

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

    
135
static const OptionDef* find_option(const OptionDef *po, const char *name){
136
    while (po->name != NULL) {
137
        if (!strcmp(name, po->name))
138
            break;
139
        po++;
140
    }
141
    return po;
142
}
143

    
144
void parse_options(int argc, char **argv, const OptionDef *options,
145
                   void (* parse_arg_function)(const char*))
146
{
147
    const char *opt, *arg;
148
    int optindex, handleoptions=1;
149
    const OptionDef *po;
150

    
151
    /* parse options */
152
    optindex = 1;
153
    while (optindex < argc) {
154
        opt = argv[optindex++];
155

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

    
215
int opt_default(const char *opt, const char *arg){
216
    int type;
217
    int ret= 0;
218
    const AVOption *o= NULL;
219
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
220

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

    
255
//    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));
256

    
257
    //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
258
    opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
259
    opt_values[opt_name_count]= o ? NULL : arg;
260
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
261
    opt_names[opt_name_count++]= o ? o->name : opt;
262

    
263
    if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
264
        av_log_set_level(AV_LOG_DEBUG);
265
    return 0;
266
}
267

    
268
int opt_loglevel(const char *opt, const char *arg)
269
{
270
    const struct { const char *name; int level; } log_levels[] = {
271
        { "quiet"  , AV_LOG_QUIET   },
272
        { "panic"  , AV_LOG_PANIC   },
273
        { "fatal"  , AV_LOG_FATAL   },
274
        { "error"  , AV_LOG_ERROR   },
275
        { "warning", AV_LOG_WARNING },
276
        { "info"   , AV_LOG_INFO    },
277
        { "verbose", AV_LOG_VERBOSE },
278
        { "debug"  , AV_LOG_DEBUG   },
279
    };
280
    char *tail;
281
    int level;
282
    int i;
283

    
284
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
285
        if (!strcmp(log_levels[i].name, arg)) {
286
            av_log_set_level(log_levels[i].level);
287
            return 0;
288
        }
289
    }
290

    
291
    level = strtol(arg, &tail, 10);
292
    if (*tail) {
293
        fprintf(stderr, "Invalid loglevel \"%s\". "
294
                        "Possible levels are numbers or:\n", arg);
295
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
296
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
297
        exit(1);
298
    }
299
    av_log_set_level(level);
300
    return 0;
301
}
302

    
303
int opt_timelimit(const char *opt, const char *arg)
304
{
305
#if HAVE_SETRLIMIT
306
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
307
    struct rlimit rl = { lim, lim + 1 };
308
    if (setrlimit(RLIMIT_CPU, &rl))
309
        perror("setrlimit");
310
#else
311
    fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
312
#endif
313
    return 0;
314
}
315

    
316
void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
317
{
318
    int i;
319
    void *priv_ctx=NULL;
320
    if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
321
        AVCodecContext *avctx= ctx;
322
        if(codec && codec->priv_class && avctx->priv_data){
323
            priv_ctx= avctx->priv_data;
324
        }
325
    }
326
    for(i=0; i<opt_name_count; i++){
327
        char buf[256];
328
        const AVOption *opt;
329
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
330
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
331
        if(str && ((opt->flags & flags) == flags))
332
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
333
        /* We need to use a differnt system to pass options to the private context because
334
           it is not known which codec and thus context kind that will be when parsing options
335
           we thus use opt_values directly instead of opts_ctx */
336
        if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
337
            av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
338
        }
339
    }
340
}
341

    
342
void print_error(const char *filename, int err)
343
{
344
    char errbuf[128];
345
    const char *errbuf_ptr = errbuf;
346

    
347
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
348
        errbuf_ptr = strerror(AVUNERROR(err));
349
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
350
}
351

    
352
static int warned_cfg = 0;
353

    
354
#define INDENT        1
355
#define SHOW_VERSION  2
356
#define SHOW_CONFIG   4
357

    
358
#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
359
    if (CONFIG_##LIBNAME) {                                             \
360
        const char *indent = flags & INDENT? "  " : "";                 \
361
        if (flags & SHOW_VERSION) {                                     \
362
            unsigned int version = libname##_version();                 \
363
            fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", \
364
                    indent, #libname,                                   \
365
                    LIB##LIBNAME##_VERSION_MAJOR,                       \
366
                    LIB##LIBNAME##_VERSION_MINOR,                       \
367
                    LIB##LIBNAME##_VERSION_MICRO,                       \
368
                    version >> 16, version >> 8 & 0xff, version & 0xff); \
369
        }                                                               \
370
        if (flags & SHOW_CONFIG) {                                      \
371
            const char *cfg = libname##_configuration();                \
372
            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
373
                if (!warned_cfg) {                                      \
374
                    fprintf(outstream,                                  \
375
                            "%sWARNING: library configuration mismatch\n", \
376
                            indent);                                    \
377
                    warned_cfg = 1;                                     \
378
                }                                                       \
379
                fprintf(stderr, "%s%-11s configuration: %s\n",          \
380
                        indent, #libname, cfg);                         \
381
            }                                                           \
382
        }                                                               \
383
    }                                                                   \
384

    
385
static void print_all_libs_info(FILE* outstream, int flags)
386
{
387
    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
388
    PRINT_LIB_INFO(outstream, avcore,   AVCORE,   flags);
389
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
390
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
391
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
392
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
393
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
394
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
395
}
396

    
397
void show_banner(void)
398
{
399
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
400
            program_name, program_birth_year, this_year);
401
    fprintf(stderr, "  built on %s %s with %s %s\n",
402
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
403
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
404
    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
405
    print_all_libs_info(stderr, INDENT|SHOW_VERSION);
406
}
407

    
408
void show_version(void) {
409
    printf("%s " FFMPEG_VERSION "\n", program_name);
410
    print_all_libs_info(stdout, SHOW_VERSION);
411
}
412

    
413
void show_license(void)
414
{
415
    printf(
416
#if CONFIG_NONFREE
417
    "This version of %s has nonfree parts compiled in.\n"
418
    "Therefore it is not legally redistributable.\n",
419
    program_name
420
#elif CONFIG_GPLV3
421
    "%s is free software; you can redistribute it and/or modify\n"
422
    "it under the terms of the GNU General Public License as published by\n"
423
    "the Free Software Foundation; either version 3 of the License, or\n"
424
    "(at your option) any later version.\n"
425
    "\n"
426
    "%s is distributed in the hope that it will be useful,\n"
427
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
428
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
429
    "GNU General Public License for more details.\n"
430
    "\n"
431
    "You should have received a copy of the GNU General Public License\n"
432
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
433
    program_name, program_name, program_name
434
#elif CONFIG_GPL
435
    "%s is free software; you can redistribute it and/or modify\n"
436
    "it under the terms of the GNU General Public License as published by\n"
437
    "the Free Software Foundation; either version 2 of the License, or\n"
438
    "(at your option) any later version.\n"
439
    "\n"
440
    "%s is distributed in the hope that it will be useful,\n"
441
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
442
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
443
    "GNU General Public License for more details.\n"
444
    "\n"
445
    "You should have received a copy of the GNU General Public License\n"
446
    "along with %s; if not, write to the Free Software\n"
447
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
448
    program_name, program_name, program_name
449
#elif CONFIG_LGPLV3
450
    "%s is free software; you can redistribute it and/or modify\n"
451
    "it under the terms of the GNU Lesser 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 Lesser General Public License for more details.\n"
459
    "\n"
460
    "You should have received a copy of the GNU Lesser 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
#else
464
    "%s is free software; you can redistribute it and/or\n"
465
    "modify it under the terms of the GNU Lesser General Public\n"
466
    "License as published by the Free Software Foundation; either\n"
467
    "version 2.1 of the License, or (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 GNU\n"
472
    "Lesser General Public License for more details.\n"
473
    "\n"
474
    "You should have received a copy of the GNU Lesser General Public\n"
475
    "License 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
#endif
479
    );
480
}
481

    
482
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
483
{
484
    int i;
485
    char fmt_str[128];
486
    for (i=-1; i < nb_fmts; i++) {
487
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
488
        fprintf(stdout, "%s\n", fmt_str);
489
    }
490
}
491

    
492
void show_formats(void)
493
{
494
    AVInputFormat *ifmt=NULL;
495
    AVOutputFormat *ofmt=NULL;
496
    const char *last_name;
497

    
498
    printf(
499
        "File formats:\n"
500
        " D. = Demuxing supported\n"
501
        " .E = Muxing supported\n"
502
        " --\n");
503
    last_name= "000";
504
    for(;;){
505
        int decode=0;
506
        int encode=0;
507
        const char *name=NULL;
508
        const char *long_name=NULL;
509

    
510
        while((ofmt= av_oformat_next(ofmt))) {
511
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
512
                strcmp(ofmt->name, last_name)>0){
513
                name= ofmt->name;
514
                long_name= ofmt->long_name;
515
                encode=1;
516
            }
517
        }
518
        while((ifmt= av_iformat_next(ifmt))) {
519
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
520
                strcmp(ifmt->name, last_name)>0){
521
                name= ifmt->name;
522
                long_name= ifmt->long_name;
523
                encode=0;
524
            }
525
            if(name && strcmp(ifmt->name, name)==0)
526
                decode=1;
527
        }
528
        if(name==NULL)
529
            break;
530
        last_name= name;
531

    
532
        printf(
533
            " %s%s %-15s %s\n",
534
            decode ? "D":" ",
535
            encode ? "E":" ",
536
            name,
537
            long_name ? long_name:" ");
538
    }
539
}
540

    
541
void show_codecs(void)
542
{
543
    AVCodec *p=NULL, *p2;
544
    const char *last_name;
545
    printf(
546
        "Codecs:\n"
547
        " D..... = Decoding supported\n"
548
        " .E.... = Encoding supported\n"
549
        " ..V... = Video codec\n"
550
        " ..A... = Audio codec\n"
551
        " ..S... = Subtitle codec\n"
552
        " ...S.. = Supports draw_horiz_band\n"
553
        " ....D. = Supports direct rendering method 1\n"
554
        " .....T = Supports weird frame truncation\n"
555
        " ------\n");
556
    last_name= "000";
557
    for(;;){
558
        int decode=0;
559
        int encode=0;
560
        int cap=0;
561
        const char *type_str;
562

    
563
        p2=NULL;
564
        while((p= av_codec_next(p))) {
565
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
566
                strcmp(p->name, last_name)>0){
567
                p2= p;
568
                decode= encode= cap=0;
569
            }
570
            if(p2 && strcmp(p->name, p2->name)==0){
571
                if(p->decode) decode=1;
572
                if(p->encode) encode=1;
573
                cap |= p->capabilities;
574
            }
575
        }
576
        if(p2==NULL)
577
            break;
578
        last_name= p2->name;
579

    
580
        switch(p2->type) {
581
        case AVMEDIA_TYPE_VIDEO:
582
            type_str = "V";
583
            break;
584
        case AVMEDIA_TYPE_AUDIO:
585
            type_str = "A";
586
            break;
587
        case AVMEDIA_TYPE_SUBTITLE:
588
            type_str = "S";
589
            break;
590
        default:
591
            type_str = "?";
592
            break;
593
        }
594
        printf(
595
            " %s%s%s%s%s%s %-15s %s",
596
            decode ? "D": (/*p2->decoder ? "d":*/" "),
597
            encode ? "E":" ",
598
            type_str,
599
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
600
            cap & CODEC_CAP_DR1 ? "D":" ",
601
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
602
            p2->name,
603
            p2->long_name ? p2->long_name : "");
604
       /* if(p2->decoder && decode==0)
605
            printf(" use %s for decoding", p2->decoder->name);*/
606
        printf("\n");
607
    }
608
    printf("\n");
609
    printf(
610
"Note, the names of encoders and decoders do not always match, so there are\n"
611
"several cases where the above table shows encoder only or decoder only entries\n"
612
"even though both encoding and decoding are supported. For example, the h263\n"
613
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
614
"worse.\n");
615
}
616

    
617
void show_bsfs(void)
618
{
619
    AVBitStreamFilter *bsf=NULL;
620

    
621
    printf("Bitstream filters:\n");
622
    while((bsf = av_bitstream_filter_next(bsf)))
623
        printf("%s\n", bsf->name);
624
    printf("\n");
625
}
626

    
627
void show_protocols(void)
628
{
629
    URLProtocol *up=NULL;
630

    
631
    printf("Supported file protocols:\n"
632
           "I.. = Input  supported\n"
633
           ".O. = Output supported\n"
634
           "..S = Seek   supported\n"
635
           "FLAGS NAME\n"
636
           "----- \n");
637
    while((up = av_protocol_next(up)))
638
        printf("%c%c%c   %s\n",
639
               up->url_read  ? 'I' : '.',
640
               up->url_write ? 'O' : '.',
641
               up->url_seek  ? 'S' : '.',
642
               up->name);
643
}
644

    
645
void show_filters(void)
646
{
647
    AVFilter av_unused(**filter) = NULL;
648

    
649
    printf("Filters:\n");
650
#if CONFIG_AVFILTER
651
    while ((filter = av_filter_next(filter)) && *filter)
652
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
653
#endif
654
}
655

    
656
void show_pix_fmts(void)
657
{
658
    enum PixelFormat pix_fmt;
659

    
660
    printf(
661
        "Pixel formats:\n"
662
        "I.... = Supported Input  format for conversion\n"
663
        ".O... = Supported Output format for conversion\n"
664
        "..H.. = Hardware accelerated format\n"
665
        "...P. = Paletted format\n"
666
        "....B = Bitstream format\n"
667
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
668
        "-----\n");
669

    
670
#if !CONFIG_SWSCALE
671
#   define sws_isSupportedInput(x)  0
672
#   define sws_isSupportedOutput(x) 0
673
#endif
674

    
675
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
676
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
677
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
678
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
679
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
680
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
681
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
682
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
683
               pix_desc->name,
684
               pix_desc->nb_components,
685
               av_get_bits_per_pixel(pix_desc));
686
    }
687
}
688

    
689
int read_yesno(void)
690
{
691
    int c = getchar();
692
    int yesno = (toupper(c) == 'Y');
693

    
694
    while (c != '\n' && c != EOF)
695
        c = getchar();
696

    
697
    return yesno;
698
}
699

    
700
int read_file(const char *filename, char **bufptr, size_t *size)
701
{
702
    FILE *f = fopen(filename, "rb");
703

    
704
    if (!f) {
705
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
706
        return AVERROR(errno);
707
    }
708
    fseek(f, 0, SEEK_END);
709
    *size = ftell(f);
710
    fseek(f, 0, SEEK_SET);
711
    *bufptr = av_malloc(*size + 1);
712
    if (!*bufptr) {
713
        fprintf(stderr, "Could not allocate file buffer\n");
714
        fclose(f);
715
        return AVERROR(ENOMEM);
716
    }
717
    fread(*bufptr, 1, *size, f);
718
    (*bufptr)[*size++] = '\0';
719

    
720
    fclose(f);
721
    return 0;
722
}
723

    
724
void init_pts_correction(PtsCorrectionContext *ctx)
725
{
726
    ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
727
    ctx->last_pts = ctx->last_dts = INT64_MIN;
728
}
729

    
730
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
731
{
732
    int64_t pts = AV_NOPTS_VALUE;
733

    
734
    if (dts != AV_NOPTS_VALUE) {
735
        ctx->num_faulty_dts += dts <= ctx->last_dts;
736
        ctx->last_dts = dts;
737
    }
738
    if (reordered_pts != AV_NOPTS_VALUE) {
739
        ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
740
        ctx->last_pts = reordered_pts;
741
    }
742
    if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
743
       && reordered_pts != AV_NOPTS_VALUE)
744
        pts = reordered_pts;
745
    else
746
        pts = dts;
747

    
748
    return pts;
749
}
750

    
751
#if CONFIG_AVFILTER
752

    
753
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
754
{
755
    FFSinkContext *priv = ctx->priv;
756

    
757
    if (!opaque)
758
        return AVERROR(EINVAL);
759
    *priv = *(FFSinkContext *)opaque;
760

    
761
    return 0;
762
}
763

    
764
static void null_end_frame(AVFilterLink *inlink) { }
765

    
766
static int ffsink_query_formats(AVFilterContext *ctx)
767
{
768
    FFSinkContext *priv = ctx->priv;
769
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
770

    
771
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
772
    return 0;
773
}
774

    
775
AVFilter ffsink = {
776
    .name      = "ffsink",
777
    .priv_size = sizeof(FFSinkContext),
778
    .init      = ffsink_init,
779

    
780
    .query_formats = ffsink_query_formats,
781

    
782
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
783
                                    .type          = AVMEDIA_TYPE_VIDEO,
784
                                    .end_frame     = null_end_frame,
785
                                    .min_perms     = AV_PERM_READ, },
786
                                  { .name = NULL }},
787
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
788
};
789

    
790
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
791
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
792
{
793
    int ret;
794
    AVFilterBufferRef *picref;
795

    
796
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
797
        return ret;
798
    if (!(picref = ctx->inputs[0]->cur_buf))
799
        return AVERROR(ENOENT);
800
    *picref_ptr = picref;
801
    ctx->inputs[0]->cur_buf = NULL;
802
    *tb = ctx->inputs[0]->time_base;
803

    
804
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
805
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
806
    frame->interlaced_frame = picref->video->interlaced;
807
    frame->top_field_first  = picref->video->top_field_first;
808

    
809
    return 1;
810
}
811

    
812
#endif /* CONFIG_AVFILTER */