Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 35fe66ab

History | View | Annotate | Download (30.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 "libavutil/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
        av_freep(&opt_names[i]);
83
        av_freep(&opt_values[i]);
84
    }
85
    av_freep(&opt_names);
86
    av_freep(&opt_values);
87
}
88

    
89
void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
90
{
91
    vfprintf(stdout, fmt, vl);
92
}
93

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

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

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

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

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

    
156
#if defined(_WIN32) && !defined(__MINGW32CE__)
157
#include <windows.h>
158
/* Will be leaked on exit */
159
static char** win32_argv_utf8 = NULL;
160
static int win32_argc = 0;
161

    
162
/**
163
 * Prepare command line arguments for executable.
164
 * For Windows - perform wide-char to UTF-8 conversion.
165
 * Input arguments should be main() function arguments.
166
 * @param argc_ptr Arguments number (including executable)
167
 * @param argv_ptr Arguments list.
168
 */
169
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
170
{
171
    char *argstr_flat;
172
    wchar_t **argv_w;
173
    int i, buffsize = 0, offset = 0;
174

    
175
    if (win32_argv_utf8) {
176
        *argc_ptr = win32_argc;
177
        *argv_ptr = win32_argv_utf8;
178
        return;
179
    }
180

    
181
    win32_argc = 0;
182
    argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
183
    if (win32_argc <= 0 || !argv_w)
184
        return;
185

    
186
    /* determine the UTF-8 buffer size (including NULL-termination symbols) */
187
    for (i = 0; i < win32_argc; i++)
188
        buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
189
                                        NULL, 0, NULL, NULL);
190

    
191
    win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
192
    argstr_flat     = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
193
    if (win32_argv_utf8 == NULL) {
194
        LocalFree(argv_w);
195
        return;
196
    }
197

    
198
    for (i = 0; i < win32_argc; i++) {
199
        win32_argv_utf8[i] = &argstr_flat[offset];
200
        offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201
                                      &argstr_flat[offset],
202
                                      buffsize - offset, NULL, NULL);
203
    }
204
    win32_argv_utf8[i] = NULL;
205
    LocalFree(argv_w);
206

    
207
    *argc_ptr = win32_argc;
208
    *argv_ptr = win32_argv_utf8;
209
}
210
#else
211
static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
212
{
213
    /* nothing to do */
214
}
215
#endif /* WIN32 && !__MINGW32CE__ */
216

    
217
void parse_options(int argc, char **argv, const OptionDef *options,
218
                   void (* parse_arg_function)(const char*))
219
{
220
    const char *opt, *arg;
221
    int optindex, handleoptions=1;
222
    const OptionDef *po;
223

    
224
    /* perform system-dependent conversions for arguments list */
225
    prepare_app_arguments(&argc, &argv);
226

    
227
    /* parse options */
228
    optindex = 1;
229
    while (optindex < argc) {
230
        opt = argv[optindex++];
231

    
232
        if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
233
            int bool_val = 1;
234
            if (opt[1] == '-' && opt[2] == '\0') {
235
                handleoptions = 0;
236
                continue;
237
            }
238
            opt++;
239
            po= find_option(options, opt);
240
            if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
241
                /* handle 'no' bool option */
242
                po = find_option(options, opt + 2);
243
                if (!(po->name && (po->flags & OPT_BOOL)))
244
                    goto unknown_opt;
245
                bool_val = 0;
246
            }
247
            if (!po->name)
248
                po= find_option(options, "default");
249
            if (!po->name) {
250
unknown_opt:
251
                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
252
                exit(1);
253
            }
254
            arg = NULL;
255
            if (po->flags & HAS_ARG) {
256
                arg = argv[optindex++];
257
                if (!arg) {
258
                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
259
                    exit(1);
260
                }
261
            }
262
            if (po->flags & OPT_STRING) {
263
                char *str;
264
                str = av_strdup(arg);
265
                *po->u.str_arg = str;
266
            } else if (po->flags & OPT_BOOL) {
267
                *po->u.int_arg = bool_val;
268
            } else if (po->flags & OPT_INT) {
269
                *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
270
            } else if (po->flags & OPT_INT64) {
271
                *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
272
            } else if (po->flags & OPT_FLOAT) {
273
                *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
274
            } else if (po->flags & OPT_FUNC2) {
275
                if (po->u.func2_arg(opt, arg) < 0) {
276
                    fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
277
                    exit(1);
278
                }
279
            } else if (po->flags & OPT_DUMMY) {
280
                /* Do nothing for this option */
281
            } else {
282
                po->u.func_arg(arg);
283
            }
284
            if(po->flags & OPT_EXIT)
285
                exit(0);
286
        } else {
287
            if (parse_arg_function)
288
                parse_arg_function(opt);
289
        }
290
    }
291
}
292

    
293
int opt_default(const char *opt, const char *arg){
294
    int type;
295
    int ret= 0;
296
    const AVOption *o= NULL;
297
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
298
    AVCodec *p = NULL;
299
    AVOutputFormat *oformat = NULL;
300
    AVInputFormat *iformat = NULL;
301

    
302
    while ((p = av_codec_next(p))) {
303
        AVClass *c = p->priv_class;
304
        if (c && av_find_opt(&c, opt, NULL, 0, 0))
305
            break;
306
    }
307
    if (p)
308
        goto out;
309
    while ((oformat = av_oformat_next(oformat))) {
310
        const AVClass *c = oformat->priv_class;
311
        if (c && av_find_opt(&c, opt, NULL, 0, 0))
312
            break;
313
    }
314
    if (oformat)
315
        goto out;
316
    while ((iformat = av_iformat_next(iformat))) {
317
        const AVClass *c = iformat->priv_class;
318
        if (c && av_find_opt(&c, opt, NULL, 0, 0))
319
            break;
320
    }
321
    if (iformat)
322
        goto out;
323

    
324
    for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
325
        const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
326
        if(o2)
327
            ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
328
    }
329
    if(!o && avformat_opts)
330
        ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
331
    if(!o && sws_opts)
332
        ret = av_set_string3(sws_opts, opt, arg, 1, &o);
333
    if(!o){
334
        if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
335
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
336
        else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
337
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
338
        else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
339
            ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
340
        if (ret >= 0)
341
            opt += 1;
342
    }
343
    if (o && ret < 0) {
344
        fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
345
        exit(1);
346
    }
347
    if (!o) {
348
        fprintf(stderr, "Unrecognized option '%s'\n", opt);
349
        exit(1);
350
    }
351

    
352
 out:
353
//    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));
354

    
355
    opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
356
    opt_values[opt_name_count] = av_strdup(arg);
357
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
358
    opt_names[opt_name_count++] = av_strdup(opt);
359

    
360
    if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
361
        av_log_set_level(AV_LOG_DEBUG);
362
    return 0;
363
}
364

    
365
int opt_loglevel(const char *opt, const char *arg)
366
{
367
    const struct { const char *name; int level; } log_levels[] = {
368
        { "quiet"  , AV_LOG_QUIET   },
369
        { "panic"  , AV_LOG_PANIC   },
370
        { "fatal"  , AV_LOG_FATAL   },
371
        { "error"  , AV_LOG_ERROR   },
372
        { "warning", AV_LOG_WARNING },
373
        { "info"   , AV_LOG_INFO    },
374
        { "verbose", AV_LOG_VERBOSE },
375
        { "debug"  , AV_LOG_DEBUG   },
376
    };
377
    char *tail;
378
    int level;
379
    int i;
380

    
381
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
382
        if (!strcmp(log_levels[i].name, arg)) {
383
            av_log_set_level(log_levels[i].level);
384
            return 0;
385
        }
386
    }
387

    
388
    level = strtol(arg, &tail, 10);
389
    if (*tail) {
390
        fprintf(stderr, "Invalid loglevel \"%s\". "
391
                        "Possible levels are numbers or:\n", arg);
392
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
393
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
394
        exit(1);
395
    }
396
    av_log_set_level(level);
397
    return 0;
398
}
399

    
400
int opt_timelimit(const char *opt, const char *arg)
401
{
402
#if HAVE_SETRLIMIT
403
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
404
    struct rlimit rl = { lim, lim + 1 };
405
    if (setrlimit(RLIMIT_CPU, &rl))
406
        perror("setrlimit");
407
#else
408
    fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
409
#endif
410
    return 0;
411
}
412

    
413
void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
414
{
415
    int i;
416
    void *priv_ctx=NULL;
417
    if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
418
        AVCodecContext *avctx= ctx;
419
        if(codec && codec->priv_class && avctx->priv_data){
420
            priv_ctx= avctx->priv_data;
421
        }
422
    } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
423
        AVFormatContext *avctx = ctx;
424
        if (avctx->oformat && avctx->oformat->priv_class) {
425
            priv_ctx = avctx->priv_data;
426
        } else if (avctx->iformat && avctx->iformat->priv_class) {
427
            priv_ctx = avctx->priv_data;
428
        }
429
    }
430

    
431
    for(i=0; i<opt_name_count; i++){
432
        char buf[256];
433
        const AVOption *opt;
434
        const char *str;
435
        if (priv_ctx) {
436
            if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
437
                if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 0, NULL) < 0) {
438
                    fprintf(stderr, "Invalid value '%s' for option '%s'\n",
439
                            opt_names[i], opt_values[i]);
440
                    exit(1);
441
                }
442
            } else
443
                goto global;
444
        } else {
445
        global:
446
            str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
447
            /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
448
            if (str && ((opt->flags & flags) == flags))
449
                av_set_string3(ctx, opt_names[i], str, 1, NULL);
450
        }
451
    }
452
}
453

    
454
void print_error(const char *filename, int err)
455
{
456
    char errbuf[128];
457
    const char *errbuf_ptr = errbuf;
458

    
459
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
460
        errbuf_ptr = strerror(AVUNERROR(err));
461
    fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
462
}
463

    
464
static int warned_cfg = 0;
465

    
466
#define INDENT        1
467
#define SHOW_VERSION  2
468
#define SHOW_CONFIG   4
469

    
470
#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
471
    if (CONFIG_##LIBNAME) {                                             \
472
        const char *indent = flags & INDENT? "  " : "";                 \
473
        if (flags & SHOW_VERSION) {                                     \
474
            unsigned int version = libname##_version();                 \
475
            fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
476
                    indent, #libname,                                   \
477
                    LIB##LIBNAME##_VERSION_MAJOR,                       \
478
                    LIB##LIBNAME##_VERSION_MINOR,                       \
479
                    LIB##LIBNAME##_VERSION_MICRO,                       \
480
                    version >> 16, version >> 8 & 0xff, version & 0xff); \
481
        }                                                               \
482
        if (flags & SHOW_CONFIG) {                                      \
483
            const char *cfg = libname##_configuration();                \
484
            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
485
                if (!warned_cfg) {                                      \
486
                    fprintf(outstream,                                  \
487
                            "%sWARNING: library configuration mismatch\n", \
488
                            indent);                                    \
489
                    warned_cfg = 1;                                     \
490
                }                                                       \
491
                fprintf(stderr, "%s%-11s configuration: %s\n",          \
492
                        indent, #libname, cfg);                         \
493
            }                                                           \
494
        }                                                               \
495
    }                                                                   \
496

    
497
static void print_all_libs_info(FILE* outstream, int flags)
498
{
499
    PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
500
    PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
501
    PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
502
    PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
503
    PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
504
    PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
505
    PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
506
}
507

    
508
void show_banner(void)
509
{
510
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
511
            program_name, program_birth_year, this_year);
512
    fprintf(stderr, "  built on %s %s with %s %s\n",
513
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
514
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
515
    print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
516
    print_all_libs_info(stderr, INDENT|SHOW_VERSION);
517
}
518

    
519
void show_version(void) {
520
    printf("%s " FFMPEG_VERSION "\n", program_name);
521
    print_all_libs_info(stdout, SHOW_VERSION);
522
}
523

    
524
void show_license(void)
525
{
526
    printf(
527
#if CONFIG_NONFREE
528
    "This version of %s has nonfree parts compiled in.\n"
529
    "Therefore it is not legally redistributable.\n",
530
    program_name
531
#elif CONFIG_GPLV3
532
    "%s is free software; you can redistribute it and/or modify\n"
533
    "it under the terms of the GNU General Public License as published by\n"
534
    "the Free Software Foundation; either version 3 of the License, or\n"
535
    "(at your option) any later version.\n"
536
    "\n"
537
    "%s is distributed in the hope that it will be useful,\n"
538
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
539
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
540
    "GNU General Public License for more details.\n"
541
    "\n"
542
    "You should have received a copy of the GNU General Public License\n"
543
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
544
    program_name, program_name, program_name
545
#elif CONFIG_GPL
546
    "%s is free software; you can redistribute it and/or modify\n"
547
    "it under the terms of the GNU General Public License as published by\n"
548
    "the Free Software Foundation; either version 2 of the License, or\n"
549
    "(at your option) any later version.\n"
550
    "\n"
551
    "%s is distributed in the hope that it will be useful,\n"
552
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
553
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
554
    "GNU General Public License for more details.\n"
555
    "\n"
556
    "You should have received a copy of the GNU General Public License\n"
557
    "along with %s; if not, write to the Free Software\n"
558
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
559
    program_name, program_name, program_name
560
#elif CONFIG_LGPLV3
561
    "%s is free software; you can redistribute it and/or modify\n"
562
    "it under the terms of the GNU Lesser General Public License as published by\n"
563
    "the Free Software Foundation; either version 3 of the License, or\n"
564
    "(at your option) any later version.\n"
565
    "\n"
566
    "%s is distributed in the hope that it will be useful,\n"
567
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
568
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
569
    "GNU Lesser General Public License for more details.\n"
570
    "\n"
571
    "You should have received a copy of the GNU Lesser General Public License\n"
572
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
573
    program_name, program_name, program_name
574
#else
575
    "%s is free software; you can redistribute it and/or\n"
576
    "modify it under the terms of the GNU Lesser General Public\n"
577
    "License as published by the Free Software Foundation; either\n"
578
    "version 2.1 of the License, or (at your option) any later version.\n"
579
    "\n"
580
    "%s is distributed in the hope that it will be useful,\n"
581
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
582
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
583
    "Lesser General Public License for more details.\n"
584
    "\n"
585
    "You should have received a copy of the GNU Lesser General Public\n"
586
    "License along with %s; if not, write to the Free Software\n"
587
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
588
    program_name, program_name, program_name
589
#endif
590
    );
591
}
592

    
593
void show_formats(void)
594
{
595
    AVInputFormat *ifmt=NULL;
596
    AVOutputFormat *ofmt=NULL;
597
    const char *last_name;
598

    
599
    printf(
600
        "File formats:\n"
601
        " D. = Demuxing supported\n"
602
        " .E = Muxing supported\n"
603
        " --\n");
604
    last_name= "000";
605
    for(;;){
606
        int decode=0;
607
        int encode=0;
608
        const char *name=NULL;
609
        const char *long_name=NULL;
610

    
611
        while((ofmt= av_oformat_next(ofmt))) {
612
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
613
                strcmp(ofmt->name, last_name)>0){
614
                name= ofmt->name;
615
                long_name= ofmt->long_name;
616
                encode=1;
617
            }
618
        }
619
        while((ifmt= av_iformat_next(ifmt))) {
620
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
621
                strcmp(ifmt->name, last_name)>0){
622
                name= ifmt->name;
623
                long_name= ifmt->long_name;
624
                encode=0;
625
            }
626
            if(name && strcmp(ifmt->name, name)==0)
627
                decode=1;
628
        }
629
        if(name==NULL)
630
            break;
631
        last_name= name;
632

    
633
        printf(
634
            " %s%s %-15s %s\n",
635
            decode ? "D":" ",
636
            encode ? "E":" ",
637
            name,
638
            long_name ? long_name:" ");
639
    }
640
}
641

    
642
void show_codecs(void)
643
{
644
    AVCodec *p=NULL, *p2;
645
    const char *last_name;
646
    printf(
647
        "Codecs:\n"
648
        " D..... = Decoding supported\n"
649
        " .E.... = Encoding supported\n"
650
        " ..V... = Video codec\n"
651
        " ..A... = Audio codec\n"
652
        " ..S... = Subtitle codec\n"
653
        " ...S.. = Supports draw_horiz_band\n"
654
        " ....D. = Supports direct rendering method 1\n"
655
        " .....T = Supports weird frame truncation\n"
656
        " ------\n");
657
    last_name= "000";
658
    for(;;){
659
        int decode=0;
660
        int encode=0;
661
        int cap=0;
662
        const char *type_str;
663

    
664
        p2=NULL;
665
        while((p= av_codec_next(p))) {
666
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
667
                strcmp(p->name, last_name)>0){
668
                p2= p;
669
                decode= encode= cap=0;
670
            }
671
            if(p2 && strcmp(p->name, p2->name)==0){
672
                if(p->decode) decode=1;
673
                if(p->encode) encode=1;
674
                cap |= p->capabilities;
675
            }
676
        }
677
        if(p2==NULL)
678
            break;
679
        last_name= p2->name;
680

    
681
        switch(p2->type) {
682
        case AVMEDIA_TYPE_VIDEO:
683
            type_str = "V";
684
            break;
685
        case AVMEDIA_TYPE_AUDIO:
686
            type_str = "A";
687
            break;
688
        case AVMEDIA_TYPE_SUBTITLE:
689
            type_str = "S";
690
            break;
691
        default:
692
            type_str = "?";
693
            break;
694
        }
695
        printf(
696
            " %s%s%s%s%s%s %-15s %s",
697
            decode ? "D": (/*p2->decoder ? "d":*/" "),
698
            encode ? "E":" ",
699
            type_str,
700
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
701
            cap & CODEC_CAP_DR1 ? "D":" ",
702
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
703
            p2->name,
704
            p2->long_name ? p2->long_name : "");
705
       /* if(p2->decoder && decode==0)
706
            printf(" use %s for decoding", p2->decoder->name);*/
707
        printf("\n");
708
    }
709
    printf("\n");
710
    printf(
711
"Note, the names of encoders and decoders do not always match, so there are\n"
712
"several cases where the above table shows encoder only or decoder only entries\n"
713
"even though both encoding and decoding are supported. For example, the h263\n"
714
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
715
"worse.\n");
716
}
717

    
718
void show_bsfs(void)
719
{
720
    AVBitStreamFilter *bsf=NULL;
721

    
722
    printf("Bitstream filters:\n");
723
    while((bsf = av_bitstream_filter_next(bsf)))
724
        printf("%s\n", bsf->name);
725
    printf("\n");
726
}
727

    
728
void show_protocols(void)
729
{
730
    URLProtocol *up=NULL;
731

    
732
    printf("Supported file protocols:\n"
733
           "I.. = Input  supported\n"
734
           ".O. = Output supported\n"
735
           "..S = Seek   supported\n"
736
           "FLAGS NAME\n"
737
           "----- \n");
738
    while((up = av_protocol_next(up)))
739
        printf("%c%c%c   %s\n",
740
               up->url_read  ? 'I' : '.',
741
               up->url_write ? 'O' : '.',
742
               up->url_seek  ? 'S' : '.',
743
               up->name);
744
}
745

    
746
void show_filters(void)
747
{
748
    AVFilter av_unused(**filter) = NULL;
749

    
750
    printf("Filters:\n");
751
#if CONFIG_AVFILTER
752
    while ((filter = av_filter_next(filter)) && *filter)
753
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
754
#endif
755
}
756

    
757
void show_pix_fmts(void)
758
{
759
    enum PixelFormat pix_fmt;
760

    
761
    printf(
762
        "Pixel formats:\n"
763
        "I.... = Supported Input  format for conversion\n"
764
        ".O... = Supported Output format for conversion\n"
765
        "..H.. = Hardware accelerated format\n"
766
        "...P. = Paletted format\n"
767
        "....B = Bitstream format\n"
768
        "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
769
        "-----\n");
770

    
771
#if !CONFIG_SWSCALE
772
#   define sws_isSupportedInput(x)  0
773
#   define sws_isSupportedOutput(x) 0
774
#endif
775

    
776
    for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
777
        const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
778
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
779
               sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
780
               sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
781
               pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
782
               pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
783
               pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
784
               pix_desc->name,
785
               pix_desc->nb_components,
786
               av_get_bits_per_pixel(pix_desc));
787
    }
788
}
789

    
790
int read_yesno(void)
791
{
792
    int c = getchar();
793
    int yesno = (toupper(c) == 'Y');
794

    
795
    while (c != '\n' && c != EOF)
796
        c = getchar();
797

    
798
    return yesno;
799
}
800

    
801
int read_file(const char *filename, char **bufptr, size_t *size)
802
{
803
    FILE *f = fopen(filename, "rb");
804

    
805
    if (!f) {
806
        fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
807
        return AVERROR(errno);
808
    }
809
    fseek(f, 0, SEEK_END);
810
    *size = ftell(f);
811
    fseek(f, 0, SEEK_SET);
812
    *bufptr = av_malloc(*size + 1);
813
    if (!*bufptr) {
814
        fprintf(stderr, "Could not allocate file buffer\n");
815
        fclose(f);
816
        return AVERROR(ENOMEM);
817
    }
818
    fread(*bufptr, 1, *size, f);
819
    (*bufptr)[*size++] = '\0';
820

    
821
    fclose(f);
822
    return 0;
823
}
824

    
825
FILE *get_preset_file(char *filename, size_t filename_size,
826
                      const char *preset_name, int is_path, const char *codec_name)
827
{
828
    FILE *f = NULL;
829
    int i;
830
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
831
                           getenv("HOME"),
832
                           FFMPEG_DATADIR,
833
                         };
834

    
835
    if (is_path) {
836
        av_strlcpy(filename, preset_name, filename_size);
837
        f = fopen(filename, "r");
838
    } else {
839
        for (i = 0; i < 3 && !f; i++) {
840
            if (!base[i])
841
                continue;
842
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
843
            f = fopen(filename, "r");
844
            if (!f && codec_name) {
845
                snprintf(filename, filename_size,
846
                         "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
847
                f = fopen(filename, "r");
848
            }
849
        }
850
    }
851

    
852
    return f;
853
}
854

    
855
#if CONFIG_AVFILTER
856

    
857
static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
858
{
859
    FFSinkContext *priv = ctx->priv;
860

    
861
    if (!opaque)
862
        return AVERROR(EINVAL);
863
    *priv = *(FFSinkContext *)opaque;
864

    
865
    return 0;
866
}
867

    
868
static void null_end_frame(AVFilterLink *inlink) { }
869

    
870
static int ffsink_query_formats(AVFilterContext *ctx)
871
{
872
    FFSinkContext *priv = ctx->priv;
873
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
874

    
875
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
876
    return 0;
877
}
878

    
879
AVFilter ffsink = {
880
    .name      = "ffsink",
881
    .priv_size = sizeof(FFSinkContext),
882
    .init      = ffsink_init,
883

    
884
    .query_formats = ffsink_query_formats,
885

    
886
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
887
                                    .type          = AVMEDIA_TYPE_VIDEO,
888
                                    .end_frame     = null_end_frame,
889
                                    .min_perms     = AV_PERM_READ, },
890
                                  { .name = NULL }},
891
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
892
};
893

    
894
int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
895
                             AVFilterBufferRef **picref_ptr, AVRational *tb)
896
{
897
    int ret;
898
    AVFilterBufferRef *picref;
899

    
900
    if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
901
        return ret;
902
    if (!(picref = ctx->inputs[0]->cur_buf))
903
        return AVERROR(ENOENT);
904
    *picref_ptr = picref;
905
    ctx->inputs[0]->cur_buf = NULL;
906
    *tb = ctx->inputs[0]->time_base;
907

    
908
    memcpy(frame->data,     picref->data,     sizeof(frame->data));
909
    memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
910
    frame->pkt_pos          = picref->pos;
911
    frame->interlaced_frame = picref->video->interlaced;
912
    frame->top_field_first  = picref->video->top_field_first;
913
    frame->key_frame        = picref->video->key_frame;
914
    frame->pict_type        = picref->video->pict_type;
915
    frame->sample_aspect_ratio = picref->video->sample_aspect_ratio;
916

    
917
    return 1;
918
}
919

    
920
#endif /* CONFIG_AVFILTER */