Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 470bce2b

History | View | Annotate | Download (15.7 KB)

1
/*
2
 * Various utilities for command line tools
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

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

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

    
31
#include "config.h"
32
#include "libavformat/avformat.h"
33
#ifdef CONFIG_AVFILTER
34
#include "libavfilter/avfilter.h"
35
#endif
36
#include "libavdevice/avdevice.h"
37
#include "libswscale/swscale.h"
38
#ifdef CONFIG_POSTPROC
39
#include "libpostproc/postprocess.h"
40
#endif
41
#include "libavutil/avstring.h"
42
#include "libavcodec/opt.h"
43
#include "cmdutils.h"
44
#include "version.h"
45
#ifdef CONFIG_NETWORK
46
#include "libavformat/network.h"
47
#endif
48

    
49
#undef exit
50

    
51
const char **opt_names;
52
static int opt_name_count;
53
AVCodecContext *avctx_opts[CODEC_TYPE_NB];
54
AVFormatContext *avformat_opts;
55
struct SwsContext *sws_opts;
56

    
57
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
58
{
59
    char *tail;
60
    const char *error;
61
    double d = strtod(numstr, &tail);
62
    if (*tail)
63
        error= "Expected number for %s but found: %s\n";
64
    else if (d < min || d > max)
65
        error= "The value for %s was %s which is not within %f - %f\n";
66
    else if(type == OPT_INT64 && (int64_t)d != d)
67
        error= "Expected int64 for %s but found %s\n";
68
    else
69
        return d;
70
    fprintf(stderr, error, context, numstr, min, max);
71
    exit(1);
72
}
73

    
74
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
75
{
76
    int64_t us = parse_date(timestr, is_duration);
77
    if (us == INT64_MIN) {
78
        fprintf(stderr, "Invalid %s specification for %s: %s\n",
79
                is_duration ? "duration" : "date", context, timestr);
80
        exit(1);
81
    }
82
    return us;
83
}
84

    
85
void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
86
{
87
    const OptionDef *po;
88
    int first;
89

    
90
    first = 1;
91
    for(po = options; po->name != NULL; po++) {
92
        char buf[64];
93
        if ((po->flags & mask) == value) {
94
            if (first) {
95
                printf("%s", msg);
96
                first = 0;
97
            }
98
            av_strlcpy(buf, po->name, sizeof(buf));
99
            if (po->flags & HAS_ARG) {
100
                av_strlcat(buf, " ", sizeof(buf));
101
                av_strlcat(buf, po->argname, sizeof(buf));
102
            }
103
            printf("-%-17s  %s\n", buf, po->help);
104
        }
105
    }
106
}
107

    
108
static const OptionDef* find_option(const OptionDef *po, const char *name){
109
    while (po->name != NULL) {
110
        if (!strcmp(name, po->name))
111
            break;
112
        po++;
113
    }
114
    return po;
115
}
116

    
117
void parse_options(int argc, char **argv, const OptionDef *options,
118
                   void (* parse_arg_function)(const char*))
119
{
120
    const char *opt, *arg;
121
    int optindex, handleoptions=1;
122
    const OptionDef *po;
123

    
124
    /* parse options */
125
    optindex = 1;
126
    while (optindex < argc) {
127
        opt = argv[optindex++];
128

    
129
        if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
130
            if (opt[1] == '-' && opt[2] == '\0') {
131
                handleoptions = 0;
132
                continue;
133
            }
134
            po= find_option(options, opt + 1);
135
            if (!po->name)
136
                po= find_option(options, "default");
137
            if (!po->name) {
138
unknown_opt:
139
                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
140
                exit(1);
141
            }
142
            arg = NULL;
143
            if (po->flags & HAS_ARG) {
144
                arg = argv[optindex++];
145
                if (!arg) {
146
                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
147
                    exit(1);
148
                }
149
            }
150
            if (po->flags & OPT_STRING) {
151
                char *str;
152
                str = av_strdup(arg);
153
                *po->u.str_arg = str;
154
            } else if (po->flags & OPT_BOOL) {
155
                *po->u.int_arg = 1;
156
            } else if (po->flags & OPT_INT) {
157
                *po->u.int_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT_MIN, INT_MAX);
158
            } else if (po->flags & OPT_INT64) {
159
                *po->u.int64_arg = parse_number_or_die(opt+1, arg, OPT_INT64, INT64_MIN, INT64_MAX);
160
            } else if (po->flags & OPT_FLOAT) {
161
                *po->u.float_arg = parse_number_or_die(opt+1, arg, OPT_FLOAT, -1.0/0.0, 1.0/0.0);
162
            } else if (po->flags & OPT_FUNC2) {
163
                if(po->u.func2_arg(opt+1, arg)<0)
164
                    goto unknown_opt;
165
            } else {
166
                po->u.func_arg(arg);
167
            }
168
            if(po->flags & OPT_EXIT)
169
                exit(0);
170
        } else {
171
            if (parse_arg_function)
172
                parse_arg_function(opt);
173
        }
174
    }
175
}
176

    
177
int opt_default(const char *opt, const char *arg){
178
    int type;
179
    int ret= 0;
180
    const AVOption *o= NULL;
181
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
182

    
183
    for(type=0; type<CODEC_TYPE_NB && ret>= 0; type++){
184
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
185
        if(o2)
186
            ret = av_set_string3(avctx_opts[type], opt, arg, 1, &o);
187
    }
188
    if(!o)
189
        ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
190
    if(!o)
191
        ret = av_set_string3(sws_opts, opt, arg, 1, &o);
192
    if(!o){
193
        if(opt[0] == 'a')
194
            ret = av_set_string3(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1, &o);
195
        else if(opt[0] == 'v')
196
            ret = av_set_string3(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1, &o);
197
        else if(opt[0] == 's')
198
            ret = av_set_string3(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1, &o);
199
    }
200
    if (o && ret < 0) {
201
        fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
202
        exit(1);
203
    }
204
    if(!o)
205
        return -1;
206

    
207
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
208

    
209
    //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
210
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
211
    opt_names[opt_name_count++]= o->name;
212

    
213
    if(avctx_opts[0]->debug || avformat_opts->debug)
214
        av_log_set_level(AV_LOG_DEBUG);
215
    return 0;
216
}
217

    
218
void set_context_opts(void *ctx, void *opts_ctx, int flags)
219
{
220
    int i;
221
    for(i=0; i<opt_name_count; i++){
222
        char buf[256];
223
        const AVOption *opt;
224
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
225
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
226
        if(str && ((opt->flags & flags) == flags))
227
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
228
    }
229
}
230

    
231
void print_error(const char *filename, int err)
232
{
233
    switch(err) {
234
    case AVERROR_NUMEXPECTED:
235
        fprintf(stderr, "%s: Incorrect image filename syntax.\n"
236
                "Use '%%d' to specify the image number:\n"
237
                "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
238
                "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
239
                filename);
240
        break;
241
    case AVERROR_INVALIDDATA:
242
        fprintf(stderr, "%s: Error while parsing header\n", filename);
243
        break;
244
    case AVERROR_NOFMT:
245
        fprintf(stderr, "%s: Unknown format\n", filename);
246
        break;
247
    case AVERROR(EIO):
248
        fprintf(stderr, "%s: I/O error occurred\n"
249
                "Usually that means that input file is truncated and/or corrupted.\n",
250
                filename);
251
        break;
252
    case AVERROR(ENOMEM):
253
        fprintf(stderr, "%s: memory allocation error occurred\n", filename);
254
        break;
255
    case AVERROR(ENOENT):
256
        fprintf(stderr, "%s: no such file or directory\n", filename);
257
        break;
258
#ifdef CONFIG_NETWORK
259
    case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
260
        fprintf(stderr, "%s: Unsupported network protocol\n", filename);
261
        break;
262
#endif
263
    default:
264
        fprintf(stderr, "%s: Error while opening file\n", filename);
265
        break;
266
    }
267
}
268

    
269
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
270
    version= libname##_version(); \
271
    fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
272
            LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
273
            version >> 16, version >> 8 & 0xff, version & 0xff);
274

    
275
static void print_all_lib_versions(FILE* outstream, int indent)
276
{
277
    unsigned int version;
278
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
279
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
280
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
281
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
282
#ifdef CONFIG_AVFILTER
283
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
284
#endif
285
#ifdef CONFIG_SWSCALE
286
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
287
#endif
288
#ifdef CONFIG_POSTPROC
289
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
290
#endif
291
}
292

    
293
void show_banner(void)
294
{
295
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-2009 Fabrice Bellard, et al.\n",
296
            program_name, program_birth_year);
297
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
298
    print_all_lib_versions(stderr, 1);
299
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
300
#ifdef __GNUC__
301
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
302
#else
303
    fprintf(stderr, ", using a non-gcc compiler\n");
304
#endif
305
}
306

    
307
void show_version(void) {
308
    printf("%s " FFMPEG_VERSION "\n", program_name);
309
    print_all_lib_versions(stdout, 0);
310
}
311

    
312
void show_license(void)
313
{
314
#ifdef CONFIG_NONFREE
315
    printf(
316
    "This version of %s has nonfree parts compiled in.\n"
317
    "Therefore it is not legally redistributable.\n",
318
    program_name
319
    );
320
#elif CONFIG_GPL
321
    printf(
322
    "%s is free software; you can redistribute it and/or modify\n"
323
    "it under the terms of the GNU General Public License as published by\n"
324
    "the Free Software Foundation; either version 2 of the License, or\n"
325
    "(at your option) any later version.\n"
326
    "\n"
327
    "%s is distributed in the hope that it will be useful,\n"
328
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
329
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
330
    "GNU General Public License for more details.\n"
331
    "\n"
332
    "You should have received a copy of the GNU General Public License\n"
333
    "along with %s; if not, write to the Free Software\n"
334
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
335
    program_name, program_name, program_name
336
    );
337
#else
338
    printf(
339
    "%s is free software; you can redistribute it and/or\n"
340
    "modify it under the terms of the GNU Lesser General Public\n"
341
    "License as published by the Free Software Foundation; either\n"
342
    "version 2.1 of the License, or (at your option) any later version.\n"
343
    "\n"
344
    "%s is distributed in the hope that it will be useful,\n"
345
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
346
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
347
    "Lesser General Public License for more details.\n"
348
    "\n"
349
    "You should have received a copy of the GNU Lesser General Public\n"
350
    "License along with %s; if not, write to the Free Software\n"
351
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
352
    program_name, program_name, program_name
353
    );
354
#endif
355
}
356

    
357
void show_formats(void)
358
{
359
    AVInputFormat *ifmt=NULL;
360
    AVOutputFormat *ofmt=NULL;
361
    URLProtocol *up=NULL;
362
    AVCodec *p=NULL, *p2;
363
    AVBitStreamFilter *bsf=NULL;
364
    const char *last_name;
365

    
366
    printf("File formats:\n");
367
    last_name= "000";
368
    for(;;){
369
        int decode=0;
370
        int encode=0;
371
        const char *name=NULL;
372
        const char *long_name=NULL;
373

    
374
        while((ofmt= av_oformat_next(ofmt))) {
375
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
376
                strcmp(ofmt->name, last_name)>0){
377
                name= ofmt->name;
378
                long_name= ofmt->long_name;
379
                encode=1;
380
            }
381
        }
382
        while((ifmt= av_iformat_next(ifmt))) {
383
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
384
                strcmp(ifmt->name, last_name)>0){
385
                name= ifmt->name;
386
                long_name= ifmt->long_name;
387
                encode=0;
388
            }
389
            if(name && strcmp(ifmt->name, name)==0)
390
                decode=1;
391
        }
392
        if(name==NULL)
393
            break;
394
        last_name= name;
395

    
396
        printf(
397
            " %s%s %-15s %s\n",
398
            decode ? "D":" ",
399
            encode ? "E":" ",
400
            name,
401
            long_name ? long_name:" ");
402
    }
403
    printf("\n");
404

    
405
    printf("Codecs:\n");
406
    last_name= "000";
407
    for(;;){
408
        int decode=0;
409
        int encode=0;
410
        int cap=0;
411
        const char *type_str;
412

    
413
        p2=NULL;
414
        while((p= av_codec_next(p))) {
415
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
416
                strcmp(p->name, last_name)>0){
417
                p2= p;
418
                decode= encode= cap=0;
419
            }
420
            if(p2 && strcmp(p->name, p2->name)==0){
421
                if(p->decode) decode=1;
422
                if(p->encode) encode=1;
423
                cap |= p->capabilities;
424
            }
425
        }
426
        if(p2==NULL)
427
            break;
428
        last_name= p2->name;
429

    
430
        switch(p2->type) {
431
        case CODEC_TYPE_VIDEO:
432
            type_str = "V";
433
            break;
434
        case CODEC_TYPE_AUDIO:
435
            type_str = "A";
436
            break;
437
        case CODEC_TYPE_SUBTITLE:
438
            type_str = "S";
439
            break;
440
        default:
441
            type_str = "?";
442
            break;
443
        }
444
        printf(
445
            " %s%s%s%s%s%s %-15s %s",
446
            decode ? "D": (/*p2->decoder ? "d":*/" "),
447
            encode ? "E":" ",
448
            type_str,
449
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
450
            cap & CODEC_CAP_DR1 ? "D":" ",
451
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
452
            p2->name,
453
            p2->long_name ? p2->long_name : "");
454
       /* if(p2->decoder && decode==0)
455
            printf(" use %s for decoding", p2->decoder->name);*/
456
        printf("\n");
457
    }
458
    printf("\n");
459

    
460
    printf("Bitstream filters:\n");
461
    while((bsf = av_bitstream_filter_next(bsf)))
462
        printf(" %s", bsf->name);
463
    printf("\n");
464

    
465
    printf("Supported file protocols:\n");
466
    while((up = av_protocol_next(up)))
467
        printf(" %s:", up->name);
468
    printf("\n");
469

    
470
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
471
    printf("\n");
472
    printf(
473
"Note, the names of encoders and decoders do not always match, so there are\n"
474
"several cases where the above table shows encoder only or decoder only entries\n"
475
"even though both encoding and decoding are supported. For example, the h263\n"
476
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
477
"worse.\n");
478
}