Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 2912e87a

History | View | Annotate | Download (28.9 KB)

1
/*
2
 * Various utilities for command line tools
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include <string.h>
23
#include <stdlib.h>
24
#include <errno.h>
25
#include <math.h>
26

    
27
/* Include only the enabled headers since some compilers (namely, Sun
28
   Studio) will not omit unused inline functions and create undefined
29
   references to libraries that are not being built. */
30

    
31
#include "config.h"
32
#include "libavformat/avformat.h"
33
#include "libavfilter/avfilter.h"
34
#include "libavdevice/avdevice.h"
35
#include "libswscale/swscale.h"
36
#include "libpostproc/postprocess.h"
37
#include "libavutil/avstring.h"
38
#include "libavutil/parseutils.h"
39
#include "libavutil/pixdesc.h"
40
#include "libavutil/eval.h"
41
#include "libavcodec/opt.h"
42
#include "cmdutils.h"
43
#include "version.h"
44
#if CONFIG_NETWORK
45
#include "libavformat/network.h"
46
#endif
47
#if HAVE_SYS_RESOURCE_H
48
#include <sys/resource.h>
49
#endif
50

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

    
58
static const int this_year = 2011;
59

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

    
71
void uninit_opts(void)
72
{
73
    int i;
74
    for (i = 0; i < AVMEDIA_TYPE_NB; i++)
75
        av_freep(&avcodec_opts[i]);
76
    av_freep(&avformat_opts->key);
77
    av_freep(&avformat_opts);
78
#if CONFIG_SWSCALE
79
    av_freep(&sws_opts);
80
#endif
81
    for (i = 0; i < opt_name_count; i++) {
82
        //opt_values are only stored for codec-specific options in which case
83
        //both the name and value are dup'd
84
        if (opt_values[i]) {
85
            av_freep(&opt_names[i]);
86
            av_freep(&opt_values[i]);
87
        }
88
    }
89
    av_freep(&opt_names);
90
    av_freep(&opt_values);
91
}
92

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

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

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

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

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

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

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

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

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

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

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

    
277
//    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));
278

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

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

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

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

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

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

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

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

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

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

    
380
static int warned_cfg = 0;
381

    
382
#define INDENT        1
383
#define SHOW_VERSION  2
384
#define SHOW_CONFIG   4
385

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

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

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

    
435
void show_version(void) {
436
    printf("%s " LIBAV_VERSION "\n", program_name);
437
    print_all_libs_info(stdout, SHOW_VERSION);
438
}
439

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

    
509
void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
510
{
511
    int i;
512
    char fmt_str[128];
513
    for (i=-1; i < nb_fmts; i++) {
514
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
515
        fprintf(stdout, "%s\n", fmt_str);
516
    }
517
}
518

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
724
    return yesno;
725
}
726

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

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

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

    
751
void init_pts_correction(PtsCorrectionContext *ctx)
752
{
753
    ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
754
    ctx->last_pts = ctx->last_dts = INT64_MIN;
755
}
756

    
757
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
758
{
759
    int64_t pts = AV_NOPTS_VALUE;
760

    
761
    if (dts != AV_NOPTS_VALUE) {
762
        ctx->num_faulty_dts += dts <= ctx->last_dts;
763
        ctx->last_dts = dts;
764
    }
765
    if (reordered_pts != AV_NOPTS_VALUE) {
766
        ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
767
        ctx->last_pts = reordered_pts;
768
    }
769
    if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
770
       && reordered_pts != AV_NOPTS_VALUE)
771
        pts = reordered_pts;
772
    else
773
        pts = dts;
774

    
775
    return pts;
776
}
777

    
778
FILE *get_preset_file(char *filename, size_t filename_size,
779
                      const char *preset_name, int is_path, const char *codec_name)
780
{
781
    FILE *f = NULL;
782
    int i;
783
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
784
                           getenv("HOME"),
785
                           FFMPEG_DATADIR,
786
                         };
787

    
788
    if (is_path) {
789
        av_strlcpy(filename, preset_name, filename_size);
790
        f = fopen(filename, "r");
791
    } else {
792
        for (i = 0; i < 3 && !f; i++) {
793
            if (!base[i])
794
                continue;
795
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
796
            f = fopen(filename, "r");
797
            if (!f && codec_name) {
798
                snprintf(filename, filename_size,
799
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
800
                f = fopen(filename, "r");
801
            }
802
        }
803
    }
804

    
805
    return f;
806
}
807

    
808
#if CONFIG_AVFILTER
809

    
810
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
811
{
812
    FFSinkContext *priv = ctx->priv;
813

    
814
    if (!opaque)
815
        return AVERROR(EINVAL);
816
    *priv = *(FFSinkContext *)opaque;
817

    
818
    return 0;
819
}
820

    
821
static void null_end_frame(AVFilterLink *inlink) { }
822

    
823
static int ffsink_query_formats(AVFilterContext *ctx)
824
{
825
    FFSinkContext *priv = ctx->priv;
826
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
827

    
828
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
829
    return 0;
830
}
831

    
832
AVFilter ffsink = {
833
    .name      = "ffsink",
834
    .priv_size = sizeof(FFSinkContext),
835
    .init      = ffsink_init,
836

    
837
    .query_formats = ffsink_query_formats,
838

    
839
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
840
                                    .type          = AVMEDIA_TYPE_VIDEO,
841
                                    .end_frame     = null_end_frame,
842
                                    .min_perms     = AV_PERM_READ, },
843
                                  { .name = NULL }},
844
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
845
};
846

    
847
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
848
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
849
{
850
    int ret;
851
    AVFilterBufferRef *picref;
852

    
853
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
854
        return ret;
855
    if (!(picref = ctx->inputs[0]->cur_buf))
856
        return AVERROR(ENOENT);
857
    *picref_ptr = picref;
858
    ctx->inputs[0]->cur_buf = NULL;
859
    *tb = ctx->inputs[0]->time_base;
860

    
861
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
862
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
863
    frame->interlaced_frame = picref->video->interlaced;
864
    frame->top_field_first  = picref->video->top_field_first;
865

    
866
    return 1;
867
}
868

    
869
#endif /* CONFIG_AVFILTER */