Statistics
| Branch: | Revision:

ffmpeg / cmdutils.c @ 663c2edf

History | View | Annotate | Download (19.5 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 list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
417
{
418
    int i;
419
    char fmt_str[128];
420
    for (i=-1; i < nb_fmts; i++) {
421
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
422
        fprintf(stdout, "%s\n", fmt_str);
423
    }
424
}
425

    
426
void show_formats(void)
427
{
428
    AVInputFormat *ifmt=NULL;
429
    AVOutputFormat *ofmt=NULL;
430
    const char *last_name;
431

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

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

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

    
475
void show_codecs(void)
476
{
477
    AVCodec *p=NULL, *p2;
478
    const char *last_name;
479
    printf(
480
        "Codecs:\n"
481
        " D..... = Decoding supported\n"
482
        " .E.... = Encoding supported\n"
483
        " ..V... = Video codec\n"
484
        " ..A... = Audio codec\n"
485
        " ..S... = Subtitle codec\n"
486
        " ...S.. = Supports draw_horiz_band\n"
487
        " ....D. = Supports direct rendering method 1\n"
488
        " .....T = Supports weird frame truncation\n"
489
        " ------\n");
490
    last_name= "000";
491
    for(;;){
492
        int decode=0;
493
        int encode=0;
494
        int cap=0;
495
        const char *type_str;
496

    
497
        p2=NULL;
498
        while((p= av_codec_next(p))) {
499
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
500
                strcmp(p->name, last_name)>0){
501
                p2= p;
502
                decode= encode= cap=0;
503
            }
504
            if(p2 && strcmp(p->name, p2->name)==0){
505
                if(p->decode) decode=1;
506
                if(p->encode) encode=1;
507
                cap |= p->capabilities;
508
            }
509
        }
510
        if(p2==NULL)
511
            break;
512
        last_name= p2->name;
513

    
514
        switch(p2->type) {
515
        case CODEC_TYPE_VIDEO:
516
            type_str = "V";
517
            break;
518
        case CODEC_TYPE_AUDIO:
519
            type_str = "A";
520
            break;
521
        case CODEC_TYPE_SUBTITLE:
522
            type_str = "S";
523
            break;
524
        default:
525
            type_str = "?";
526
            break;
527
        }
528
        printf(
529
            " %s%s%s%s%s%s %-15s %s",
530
            decode ? "D": (/*p2->decoder ? "d":*/" "),
531
            encode ? "E":" ",
532
            type_str,
533
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
534
            cap & CODEC_CAP_DR1 ? "D":" ",
535
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
536
            p2->name,
537
            p2->long_name ? p2->long_name : "");
538
       /* if(p2->decoder && decode==0)
539
            printf(" use %s for decoding", p2->decoder->name);*/
540
        printf("\n");
541
    }
542
    printf("\n");
543
    printf(
544
"Note, the names of encoders and decoders do not always match, so there are\n"
545
"several cases where the above table shows encoder only or decoder only entries\n"
546
"even though both encoding and decoding are supported. For example, the h263\n"
547
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
548
"worse.\n");
549
}
550

    
551
void show_bsfs(void)
552
{
553
    AVBitStreamFilter *bsf=NULL;
554

    
555
    printf("Bitstream filters:\n");
556
    while((bsf = av_bitstream_filter_next(bsf)))
557
        printf("%s\n", bsf->name);
558
    printf("\n");
559
}
560

    
561
void show_protocols(void)
562
{
563
    URLProtocol *up=NULL;
564

    
565
    printf("Supported file protocols:\n");
566
    while((up = av_protocol_next(up)))
567
        printf("%s\n", up->name);
568
    printf("\n");
569

    
570
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
571
}
572

    
573
void show_filters(void)
574
{
575
    AVFilter **filter = NULL;
576

    
577
    printf("Filters:\n");
578
#if CONFIG_AVFILTER
579
    while ((filter = av_filter_next(filter)) && *filter)
580
        printf("%-16s %s\n", (*filter)->name, (*filter)->description);
581
#endif
582
}
583

    
584
int read_yesno(void)
585
{
586
    int c = getchar();
587
    int yesno = (toupper(c) == 'Y');
588

    
589
    while (c != '\n' && c != EOF)
590
        c = getchar();
591

    
592
    return yesno;
593
}