Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 0eb4ff9e

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

    
183
int opt_default(const char *opt, const char *arg){
184
    int type;
185
    int ret= 0;
186
    const AVOption *o= NULL;
187
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
188

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

    
213
//    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));
214

    
215
    //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
216
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
217
    opt_names[opt_name_count++]= o->name;
218

    
219
    if(avcodec_opts[0]->debug || avformat_opts->debug)
220
        av_log_set_level(AV_LOG_DEBUG);
221
    return 0;
222
}
223

    
224
int opt_loglevel(const char *opt, const char *arg)
225
{
226
    const struct { const char *name; int level; } log_levels[] = {
227
        { "quiet"  , AV_LOG_QUIET   },
228
        { "panic"  , AV_LOG_PANIC   },
229
        { "fatal"  , AV_LOG_FATAL   },
230
        { "error"  , AV_LOG_ERROR   },
231
        { "warning", AV_LOG_WARNING },
232
        { "info"   , AV_LOG_INFO    },
233
        { "verbose", AV_LOG_VERBOSE },
234
        { "debug"  , AV_LOG_DEBUG   },
235
    };
236
    char *tail;
237
    int level;
238
    int i;
239

    
240
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
241
        if (!strcmp(log_levels[i].name, arg)) {
242
            av_log_set_level(log_levels[i].level);
243
            return 0;
244
        }
245
    }
246

    
247
    level = strtol(arg, &tail, 10);
248
    if (*tail) {
249
        fprintf(stderr, "Invalid loglevel \"%s\". "
250
                        "Possible levels are numbers or:\n", arg);
251
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
252
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
253
        exit(1);
254
    }
255
    av_log_set_level(level);
256
    return 0;
257
}
258

    
259
void set_context_opts(void *ctx, void *opts_ctx, int flags)
260
{
261
    int i;
262
    for(i=0; i<opt_name_count; i++){
263
        char buf[256];
264
        const AVOption *opt;
265
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
266
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
267
        if(str && ((opt->flags & flags) == flags))
268
            av_set_string3(ctx, opt_names[i], str, 1, NULL);
269
    }
270
}
271

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

    
310
#define PRINT_LIB_VERSION(outstream,libname,LIBNAME,indent) \
311
    version= libname##_version(); \
312
    fprintf(outstream, "%slib%-10s %2d.%2d.%2d / %2d.%2d.%2d\n", indent? "  " : "", #libname, \
313
            LIB##LIBNAME##_VERSION_MAJOR, LIB##LIBNAME##_VERSION_MINOR, LIB##LIBNAME##_VERSION_MICRO, \
314
            version >> 16, version >> 8 & 0xff, version & 0xff);
315

    
316
static void print_all_lib_versions(FILE* outstream, int indent)
317
{
318
    unsigned int version;
319
    PRINT_LIB_VERSION(outstream, avutil,   AVUTIL,   indent);
320
    PRINT_LIB_VERSION(outstream, avcodec,  AVCODEC,  indent);
321
    PRINT_LIB_VERSION(outstream, avformat, AVFORMAT, indent);
322
    PRINT_LIB_VERSION(outstream, avdevice, AVDEVICE, indent);
323
#if CONFIG_AVFILTER
324
    PRINT_LIB_VERSION(outstream, avfilter, AVFILTER, indent);
325
#endif
326
    PRINT_LIB_VERSION(outstream, swscale,  SWSCALE,  indent);
327
#if CONFIG_POSTPROC
328
    PRINT_LIB_VERSION(outstream, postproc, POSTPROC, indent);
329
#endif
330
}
331

    
332
void show_banner(void)
333
{
334
    fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d Fabrice Bellard, et al.\n",
335
            program_name, program_birth_year, this_year);
336
    fprintf(stderr, "  built on %s %s with %s %s\n",
337
            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
338
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
339
    print_all_lib_versions(stderr, 1);
340
}
341

    
342
void show_version(void) {
343
    printf("%s " FFMPEG_VERSION "\n", program_name);
344
    print_all_lib_versions(stdout, 0);
345
}
346

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

    
416
void show_formats(void)
417
{
418
    AVInputFormat *ifmt=NULL;
419
    AVOutputFormat *ofmt=NULL;
420
    URLProtocol *up=NULL;
421
    AVCodec *p=NULL, *p2;
422
    AVBitStreamFilter *bsf=NULL;
423
    const char *last_name;
424

    
425
    printf(
426
        "File formats:\n"
427
        " D. = Demuxing supported\n"
428
        " .E = Muxing supported\n"
429
        " --\n");
430
    last_name= "000";
431
    for(;;){
432
        int decode=0;
433
        int encode=0;
434
        const char *name=NULL;
435
        const char *long_name=NULL;
436

    
437
        while((ofmt= av_oformat_next(ofmt))) {
438
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
439
                strcmp(ofmt->name, last_name)>0){
440
                name= ofmt->name;
441
                long_name= ofmt->long_name;
442
                encode=1;
443
            }
444
        }
445
        while((ifmt= av_iformat_next(ifmt))) {
446
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
447
                strcmp(ifmt->name, last_name)>0){
448
                name= ifmt->name;
449
                long_name= ifmt->long_name;
450
                encode=0;
451
            }
452
            if(name && strcmp(ifmt->name, name)==0)
453
                decode=1;
454
        }
455
        if(name==NULL)
456
            break;
457
        last_name= name;
458

    
459
        printf(
460
            " %s%s %-15s %s\n",
461
            decode ? "D":" ",
462
            encode ? "E":" ",
463
            name,
464
            long_name ? long_name:" ");
465
    }
466
    printf("\n");
467

    
468
    printf(
469
        "Codecs:\n"
470
        " D..... = Decoding supported\n"
471
        " .E.... = Encoding supported\n"
472
        " ..V... = Video codec\n"
473
        " ..A... = Audio codec\n"
474
        " ..S... = Subtitle codec\n"
475
        " ...S.. = Supports draw_horiz_band\n"
476
        " ....D. = Supports direct rendering method 1\n"
477
        " .....T = Supports weird frame truncation\n"
478
        " ------\n");
479
    last_name= "000";
480
    for(;;){
481
        int decode=0;
482
        int encode=0;
483
        int cap=0;
484
        const char *type_str;
485

    
486
        p2=NULL;
487
        while((p= av_codec_next(p))) {
488
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
489
                strcmp(p->name, last_name)>0){
490
                p2= p;
491
                decode= encode= cap=0;
492
            }
493
            if(p2 && strcmp(p->name, p2->name)==0){
494
                if(p->decode) decode=1;
495
                if(p->encode) encode=1;
496
                cap |= p->capabilities;
497
            }
498
        }
499
        if(p2==NULL)
500
            break;
501
        last_name= p2->name;
502

    
503
        switch(p2->type) {
504
        case CODEC_TYPE_VIDEO:
505
            type_str = "V";
506
            break;
507
        case CODEC_TYPE_AUDIO:
508
            type_str = "A";
509
            break;
510
        case CODEC_TYPE_SUBTITLE:
511
            type_str = "S";
512
            break;
513
        default:
514
            type_str = "?";
515
            break;
516
        }
517
        printf(
518
            " %s%s%s%s%s%s %-15s %s",
519
            decode ? "D": (/*p2->decoder ? "d":*/" "),
520
            encode ? "E":" ",
521
            type_str,
522
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
523
            cap & CODEC_CAP_DR1 ? "D":" ",
524
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
525
            p2->name,
526
            p2->long_name ? p2->long_name : "");
527
       /* if(p2->decoder && decode==0)
528
            printf(" use %s for decoding", p2->decoder->name);*/
529
        printf("\n");
530
    }
531
    printf("\n");
532

    
533
    printf("Bitstream filters:\n");
534
    while((bsf = av_bitstream_filter_next(bsf)))
535
        printf(" %s", bsf->name);
536
    printf("\n");
537

    
538
    printf("Supported file protocols:\n");
539
    while((up = av_protocol_next(up)))
540
        printf(" %s:", up->name);
541
    printf("\n");
542

    
543
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
544
    printf("\n");
545
    printf(
546
"Note, the names of encoders and decoders do not always match, so there are\n"
547
"several cases where the above table shows encoder only or decoder only entries\n"
548
"even though both encoding and decoding are supported. For example, the h263\n"
549
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
550
"worse.\n");
551
}
552

    
553
int read_yesno(void)
554
{
555
    int c = getchar();
556
    int yesno = (toupper(c) == 'Y');
557

    
558
    while (c != '\n' && c != EOF)
559
        c = getchar();
560

    
561
    return yesno;
562
}