Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 60ff9de6

History | View | Annotate | Download (29 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
    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 = parse_date(timestr, is_duration);
118
    if (us == INT64_MIN) {
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(FFMPEG_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, avcore,   AVCORE,   flags);
417
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
418
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
419
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
420
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
421
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
422
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
423
}
424

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
725
    return yesno;
726
}
727

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

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

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

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

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

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

    
776
    return pts;
777
}
778

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

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

    
806
    return f;
807
}
808

    
809
#if CONFIG_AVFILTER
810

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

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

    
819
    return 0;
820
}
821

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

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

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

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

    
838
    .query_formats = ffsink_query_formats,
839

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

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

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

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

    
867
    return 1;
868
}
869

    
870
#endif /* CONFIG_AVFILTER */