Fix weird indent.
[ffmpeg.git] / cmdutils.c
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_string2(ctx, opt_names[i], str, 1);
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-2008 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 }