Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 76d4c167

History | View | Annotate | Download (28.3 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/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 if (po->flags & OPT_DUMMY) {
218
                /* Do nothing for this option */
219
            } else {
220
                po->u.func_arg(arg);
221
            }
222
            if(po->flags & OPT_EXIT)
223
                exit(0);
224
        } else {
225
            if (parse_arg_function)
226
                parse_arg_function(opt);
227
        }
228
    }
229
}
230

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

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

    
279
//    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));
280

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

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

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

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

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

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

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

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

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

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

    
382
static int warned_cfg = 0;
383

    
384
#define INDENT        1
385
#define SHOW_VERSION  2
386
#define SHOW_CONFIG   4
387

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
726
    return yesno;
727
}
728

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

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

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

    
753
FILE *get_preset_file(char *filename, size_t filename_size,
754
                      const char *preset_name, int is_path, const char *codec_name)
755
{
756
    FILE *f = NULL;
757
    int i;
758
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
759
                           getenv("HOME"),
760
                           FFMPEG_DATADIR,
761
                         };
762

    
763
    if (is_path) {
764
        av_strlcpy(filename, preset_name, filename_size);
765
        f = fopen(filename, "r");
766
    } else {
767
        for (i = 0; i < 3 && !f; i++) {
768
            if (!base[i])
769
                continue;
770
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
771
            f = fopen(filename, "r");
772
            if (!f && codec_name) {
773
                snprintf(filename, filename_size,
774
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
775
                f = fopen(filename, "r");
776
            }
777
        }
778
    }
779

    
780
    return f;
781
}
782

    
783
#if CONFIG_AVFILTER
784

    
785
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
786
{
787
    FFSinkContext *priv = ctx->priv;
788

    
789
    if (!opaque)
790
        return AVERROR(EINVAL);
791
    *priv = *(FFSinkContext *)opaque;
792

    
793
    return 0;
794
}
795

    
796
static void null_end_frame(AVFilterLink *inlink) { }
797

    
798
static int ffsink_query_formats(AVFilterContext *ctx)
799
{
800
    FFSinkContext *priv = ctx->priv;
801
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
802

    
803
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
804
    return 0;
805
}
806

    
807
AVFilter ffsink = {
808
    .name      = "ffsink",
809
    .priv_size = sizeof(FFSinkContext),
810
    .init      = ffsink_init,
811

    
812
    .query_formats = ffsink_query_formats,
813

    
814
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
815
                                    .type          = AVMEDIA_TYPE_VIDEO,
816
                                    .end_frame     = null_end_frame,
817
                                    .min_perms     = AV_PERM_READ, },
818
                                  { .name = NULL }},
819
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
820
};
821

    
822
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
823
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
824
{
825
    int ret;
826
    AVFilterBufferRef *picref;
827

    
828
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
829
        return ret;
830
    if (!(picref = ctx->inputs[0]->cur_buf))
831
        return AVERROR(ENOENT);
832
    *picref_ptr = picref;
833
    ctx->inputs[0]->cur_buf = NULL;
834
    *tb = ctx->inputs[0]->time_base;
835

    
836
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
837
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
838
    frame->interlaced_frame = picref->video->interlaced;
839
    frame->top_field_first  = picref->video->top_field_first;
840

    
841
    return 1;
842
}
843

    
844
#endif /* CONFIG_AVFILTER */