Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ d7c2e8e3

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, "  configuration: " FFMPEG_CONFIGURATION "\n");
337
    print_all_lib_versions(stderr, 1);
338
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
339
#ifdef __GNUC__
340
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
341
#else
342
    fprintf(stderr, ", using a non-gcc compiler\n");
343
#endif
344
}
345

    
346
void show_version(void) {
347
    printf("%s " FFMPEG_VERSION "\n", program_name);
348
    print_all_lib_versions(stdout, 0);
349
}
350

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

    
420
void show_formats(void)
421
{
422
    AVInputFormat *ifmt=NULL;
423
    AVOutputFormat *ofmt=NULL;
424
    URLProtocol *up=NULL;
425
    AVCodec *p=NULL, *p2;
426
    AVBitStreamFilter *bsf=NULL;
427
    const char *last_name;
428

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

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

    
463
        printf(
464
            " %s%s %-15s %s\n",
465
            decode ? "D":" ",
466
            encode ? "E":" ",
467
            name,
468
            long_name ? long_name:" ");
469
    }
470
    printf("\n");
471

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

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

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

    
537
    printf("Bitstream filters:\n");
538
    while((bsf = av_bitstream_filter_next(bsf)))
539
        printf(" %s", bsf->name);
540
    printf("\n");
541

    
542
    printf("Supported file protocols:\n");
543
    while((up = av_protocol_next(up)))
544
        printf(" %s:", up->name);
545
    printf("\n");
546

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

    
557
int read_yesno(void)
558
{
559
    int c = getchar();
560
    int yesno = (toupper(c) == 'Y');
561

    
562
    while (c != '\n' && c != EOF)
563
        c = getchar();
564

    
565
    return yesno;
566
}