Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 4c97a6fa

History | View | Annotate | Download (18.2 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 "libavcodec/opt.h"
39
#include "cmdutils.h"
40
#include "version.h"
41
#if CONFIG_NETWORK
42
#include "libavformat/network.h"
43
#endif
44

    
45
#undef exit
46

    
47
const char **opt_names;
48
static int opt_name_count;
49
AVCodecContext *avcodec_opts[CODEC_TYPE_NB];
50
AVFormatContext *avformat_opts;
51
struct SwsContext *sws_opts;
52

    
53
const int this_year = 2009;
54

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

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

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

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

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

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

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

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

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

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

    
205
//    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));
206

    
207
    //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
208
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
209
    opt_names[opt_name_count++]= o->name;
210

    
211
    if(avcodec_opts[0]->debug || avformat_opts->debug)
212
        av_log_set_level(AV_LOG_DEBUG);
213
    return 0;
214
}
215

    
216
int opt_loglevel(const char *opt, const char *arg)
217
{
218
    const struct { const char *name; int level; } const log_levels[] = {
219
        { "quiet"  , AV_LOG_QUIET   },
220
        { "panic"  , AV_LOG_PANIC   },
221
        { "fatal"  , AV_LOG_FATAL   },
222
        { "error"  , AV_LOG_ERROR   },
223
        { "warning", AV_LOG_WARNING },
224
        { "info"   , AV_LOG_INFO    },
225
        { "verbose", AV_LOG_VERBOSE },
226
        { "debug"  , AV_LOG_DEBUG   },
227
    };
228
    char *tail;
229
    int level;
230
    int i;
231

    
232
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
233
        if (!strcmp(log_levels[i].name, arg)) {
234
            av_log_set_level(log_levels[i].level);
235
            return 0;
236
        }
237
    }
238

    
239
    level = strtol(arg, &tail, 10);
240
    if (*tail) {
241
        fprintf(stderr, "Invalid loglevel \"%s\". "
242
                        "Possible levels are numbers or:\n", arg);
243
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
244
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
245
        exit(1);
246
    }
247
    av_log_set_level(level);
248
    return 0;
249
}
250

    
251
void set_context_opts(void *ctx, void *opts_ctx, int flags)
252
{
253
    int i;
254
    for(i=0; i<opt_name_count; i++){
255
        char buf[256];
256
        const AVOption *opt;
257
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
258
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
259
        if(str && ((opt->flags & flags) == flags))
260
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
261
    }
262
}
263

    
264
void print_error(const char *filename, int err)
265
{
266
    switch(err) {
267
    case AVERROR_NUMEXPECTED:
268
        fprintf(stderr, "%s: Incorrect image filename syntax.\n"
269
                "Use '%%d' to specify the image number:\n"
270
                "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
271
                "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
272
                filename);
273
        break;
274
    case AVERROR_INVALIDDATA:
275
        fprintf(stderr, "%s: Error while parsing header\n", filename);
276
        break;
277
    case AVERROR_NOFMT:
278
        fprintf(stderr, "%s: Unknown format\n", filename);
279
        break;
280
    case AVERROR(EIO):
281
        fprintf(stderr, "%s: I/O error occurred\n"
282
                "Usually that means that input file is truncated and/or corrupted.\n",
283
                filename);
284
        break;
285
    case AVERROR(ENOMEM):
286
        fprintf(stderr, "%s: memory allocation error occurred\n", filename);
287
        break;
288
    case AVERROR(ENOENT):
289
        fprintf(stderr, "%s: no such file or directory\n", filename);
290
        break;
291
#if CONFIG_NETWORK
292
    case AVERROR(FF_NETERROR(EPROTONOSUPPORT)):
293
        fprintf(stderr, "%s: Unsupported network protocol\n", filename);
294
        break;
295
#endif
296
    default:
297
        fprintf(stderr, "%s: Error while opening file\n", filename);
298
        break;
299
    }
300
}
301

    
302
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
303
    version= libname##_version(); \
304
    fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
305
            LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
306
            version >> 16, version >> 8 & 0xff, version & 0xff);
307

    
308
static void print_all_lib_versions(FILE* outstream, int indent)
309
{
310
    unsigned int version;
311
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
312
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
313
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
314
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
315
#if CONFIG_AVFILTER
316
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
317
#endif
318
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
319
#if CONFIG_POSTPROC
320
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
321
#endif
322
}
323

    
324
void show_banner(void)
325
{
326
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
327
            program_name, program_birth_year, this_year);
328
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
329
    print_all_lib_versions(stderr, 1);
330
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
331
#ifdef __GNUC__
332
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
333
#else
334
    fprintf(stderr, ", using a non-gcc compiler\n");
335
#endif
336
}
337

    
338
void show_version(void) {
339
    printf("%s " FFMPEG_VERSION "\n", program_name);
340
    print_all_lib_versions(stdout, 0);
341
}
342

    
343
void show_license(void)
344
{
345
    printf(
346
#if CONFIG_NONFREE
347
    "This version of %s has nonfree parts compiled in.\n"
348
    "Therefore it is not legally redistributable.\n",
349
    program_name
350
#elif CONFIG_GPLV3
351
    "%s is free software; you can redistribute it and/or modify\n"
352
    "it under the terms of the GNU General Public License as published by\n"
353
    "the Free Software Foundation; either version 3 of the License, or\n"
354
    "(at your option) any later version.\n"
355
    "\n"
356
    "%s is distributed in the hope that it will be useful,\n"
357
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
358
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
359
    "GNU General Public License for more details.\n"
360
    "\n"
361
    "You should have received a copy of the GNU General Public License\n"
362
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
363
    program_name, program_name, program_name
364
#elif CONFIG_GPL
365
    "%s is free software; you can redistribute it and/or modify\n"
366
    "it under the terms of the GNU General Public License as published by\n"
367
    "the Free Software Foundation; either version 2 of the License, or\n"
368
    "(at your option) any later version.\n"
369
    "\n"
370
    "%s is distributed in the hope that it will be useful,\n"
371
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
372
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
373
    "GNU General Public License for more details.\n"
374
    "\n"
375
    "You should have received a copy of the GNU General Public License\n"
376
    "along with %s; if not, write to the Free Software\n"
377
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
378
    program_name, program_name, program_name
379
#elif CONFIG_LGPLV3
380
    "%s is free software; you can redistribute it and/or modify\n"
381
    "it under the terms of the GNU Lesser General Public License as published by\n"
382
    "the Free Software Foundation; either version 3 of the License, or\n"
383
    "(at your option) any later version.\n"
384
    "\n"
385
    "%s is distributed in the hope that it will be useful,\n"
386
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
387
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
388
    "GNU Lesser General Public License for more details.\n"
389
    "\n"
390
    "You should have received a copy of the GNU Lesser General Public License\n"
391
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
392
    program_name, program_name, program_name
393
#else
394
    "%s is free software; you can redistribute it and/or\n"
395
    "modify it under the terms of the GNU Lesser General Public\n"
396
    "License as published by the Free Software Foundation; either\n"
397
    "version 2.1 of the License, or (at your option) any later version.\n"
398
    "\n"
399
    "%s is distributed in the hope that it will be useful,\n"
400
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
401
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
402
    "Lesser General Public License for more details.\n"
403
    "\n"
404
    "You should have received a copy of the GNU Lesser General Public\n"
405
    "License along with %s; if not, write to the Free Software\n"
406
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
407
    program_name, program_name, program_name
408
#endif
409
    );
410
}
411

    
412
void show_formats(void)
413
{
414
    AVInputFormat *ifmt=NULL;
415
    AVOutputFormat *ofmt=NULL;
416
    URLProtocol *up=NULL;
417
    AVCodec *p=NULL, *p2;
418
    AVBitStreamFilter *bsf=NULL;
419
    const char *last_name;
420

    
421
    printf("File formats:\n");
422
    last_name= "000";
423
    for(;;){
424
        int decode=0;
425
        int encode=0;
426
        const char *name=NULL;
427
        const char *long_name=NULL;
428

    
429
        while((ofmt= av_oformat_next(ofmt))) {
430
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
431
                strcmp(ofmt->name, last_name)>0){
432
                name= ofmt->name;
433
                long_name= ofmt->long_name;
434
                encode=1;
435
            }
436
        }
437
        while((ifmt= av_iformat_next(ifmt))) {
438
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
439
                strcmp(ifmt->name, last_name)>0){
440
                name= ifmt->name;
441
                long_name= ifmt->long_name;
442
                encode=0;
443
            }
444
            if(name && strcmp(ifmt->name, name)==0)
445
                decode=1;
446
        }
447
        if(name==NULL)
448
            break;
449
        last_name= name;
450

    
451
        printf(
452
            " %s%s %-15s %s\n",
453
            decode ? "D":" ",
454
            encode ? "E":" ",
455
            name,
456
            long_name ? long_name:" ");
457
    }
458
    printf("\n");
459

    
460
    printf("Codecs:\n");
461
    last_name= "000";
462
    for(;;){
463
        int decode=0;
464
        int encode=0;
465
        int cap=0;
466
        const char *type_str;
467

    
468
        p2=NULL;
469
        while((p= av_codec_next(p))) {
470
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
471
                strcmp(p->name, last_name)>0){
472
                p2= p;
473
                decode= encode= cap=0;
474
            }
475
            if(p2 && strcmp(p->name, p2->name)==0){
476
                if(p->decode) decode=1;
477
                if(p->encode) encode=1;
478
                cap |= p->capabilities;
479
            }
480
        }
481
        if(p2==NULL)
482
            break;
483
        last_name= p2->name;
484

    
485
        switch(p2->type) {
486
        case CODEC_TYPE_VIDEO:
487
            type_str = "V";
488
            break;
489
        case CODEC_TYPE_AUDIO:
490
            type_str = "A";
491
            break;
492
        case CODEC_TYPE_SUBTITLE:
493
            type_str = "S";
494
            break;
495
        default:
496
            type_str = "?";
497
            break;
498
        }
499
        printf(
500
            " %s%s%s%s%s%s %-15s %s",
501
            decode ? "D": (/*p2->decoder ? "d":*/" "),
502
            encode ? "E":" ",
503
            type_str,
504
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
505
            cap & CODEC_CAP_DR1 ? "D":" ",
506
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
507
            p2->name,
508
            p2->long_name ? p2->long_name : "");
509
       /* if(p2->decoder && decode==0)
510
            printf(" use %s for decoding", p2->decoder->name);*/
511
        printf("\n");
512
    }
513
    printf("\n");
514

    
515
    printf("Bitstream filters:\n");
516
    while((bsf = av_bitstream_filter_next(bsf)))
517
        printf(" %s", bsf->name);
518
    printf("\n");
519

    
520
    printf("Supported file protocols:\n");
521
    while((up = av_protocol_next(up)))
522
        printf(" %s:", up->name);
523
    printf("\n");
524

    
525
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
526
    printf("\n");
527
    printf(
528
"Note, the names of encoders and decoders do not always match, so there are\n"
529
"several cases where the above table shows encoder only or decoder only entries\n"
530
"even though both encoding and decoding are supported. For example, the h263\n"
531
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
532
"worse.\n");
533
}
534

    
535
int read_yesno(void)
536
{
537
    int c = getchar();
538
    int yesno = (toupper(c) == 'Y');
539

    
540
    while (c != '\n' && c != EOF)
541
        c = getchar();
542

    
543
    return yesno;
544
}