Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ ba3517aa

History | View | Annotate | Download (28.7 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
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
    av_freep(&opt_names);
82
    av_freep(&opt_values);
83
}
84

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

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

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

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

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

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

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

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

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

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

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

    
269
//    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));
270

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

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

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

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

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

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

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

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

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

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

    
372
static int warned_cfg = 0;
373

    
374
#define INDENT        1
375
#define SHOW_VERSION  2
376
#define SHOW_CONFIG   4
377

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
717
    return yesno;
718
}
719

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

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

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

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

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

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

    
768
    return pts;
769
}
770

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

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

    
798
    return f;
799
}
800

    
801
#if CONFIG_AVFILTER
802

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

    
807
    if (!opaque)
808
        return AVERROR(EINVAL);
809
    *priv = *(FFSinkContext *)opaque;
810

    
811
    return 0;
812
}
813

    
814
static void null_end_frame(AVFilterLink *inlink) { }
815

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

    
821
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
822
    return 0;
823
}
824

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

    
830
    .query_formats = ffsink_query_formats,
831

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

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

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

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

    
859
    return 1;
860
}
861

    
862
#endif /* CONFIG_AVFILTER */