opt_pix_fmts: try to fix segfault on open solaris
[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 #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 "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/eval.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/opt.h"
44 #include "cmdutils.h"
45 #include "version.h"
46 #if CONFIG_NETWORK
47 #include "libavformat/network.h"
48 #endif
49 #if HAVE_SYS_RESOURCE_H
50 #include <sys/resource.h>
51 #endif
52
53 struct SwsContext *sws_opts;
54 AVDictionary *format_opts, *codec_opts;
55
56 static const int this_year = 2011;
57
58 void init_opts(void)
59 {
60 #if CONFIG_SWSCALE
61     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
62 #endif
63 }
64
65 void uninit_opts(void)
66 {
67 #if CONFIG_SWSCALE
68     sws_freeContext(sws_opts);
69     sws_opts = NULL;
70 #endif
71     av_dict_free(&format_opts);
72     av_dict_free(&codec_opts);
73 }
74
75 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
76 {
77     vfprintf(stdout, fmt, vl);
78 }
79
80 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
81 {
82     char *tail;
83     const char *error;
84     double d = av_strtod(numstr, &tail);
85     if (*tail)
86         error= "Expected number for %s but found: %s\n";
87     else if (d < min || d > max)
88         error= "The value for %s was %s which is not within %f - %f\n";
89     else if(type == OPT_INT64 && (int64_t)d != d)
90         error= "Expected int64 for %s but found %s\n";
91     else if (type == OPT_INT && (int)d != d)
92         error= "Expected int for %s but found %s\n";
93     else
94         return d;
95     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
96     exit_program(1);
97     return 0;
98 }
99
100 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
101 {
102     int64_t us;
103     if (av_parse_time(&us, timestr, is_duration) < 0) {
104         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
105                is_duration ? "duration" : "date", context, timestr);
106         exit_program(1);
107     }
108     return us;
109 }
110
111 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
112 {
113     const OptionDef *po;
114     int first;
115
116     first = 1;
117     for(po = options; po->name != NULL; po++) {
118         char buf[64];
119         if ((po->flags & mask) == value) {
120             if (first) {
121                 printf("%s", msg);
122                 first = 0;
123             }
124             av_strlcpy(buf, po->name, sizeof(buf));
125             if (po->flags & HAS_ARG) {
126                 av_strlcat(buf, " ", sizeof(buf));
127                 av_strlcat(buf, po->argname, sizeof(buf));
128             }
129             printf("-%-17s  %s\n", buf, po->help);
130         }
131     }
132 }
133
134 void show_help_children(const AVClass *class, int flags)
135 {
136     const AVClass *child = NULL;
137     av_opt_show2(&class, NULL, flags, 0);
138     printf("\n");
139
140     while (child = av_opt_child_class_next(class, child))
141         show_help_children(child, flags);
142 }
143
144 static const OptionDef* find_option(const OptionDef *po, const char *name){
145     const char *p = strchr(name, ':');
146     int len = p ? p - name : strlen(name);
147
148     while (po->name != NULL) {
149         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
150             break;
151         po++;
152     }
153     return po;
154 }
155
156 #if defined(_WIN32) && !defined(__MINGW32CE__)
157 #include <windows.h>
158 /* Will be leaked on exit */
159 static char** win32_argv_utf8 = NULL;
160 static int win32_argc = 0;
161
162 /**
163  * Prepare command line arguments for executable.
164  * For Windows - perform wide-char to UTF-8 conversion.
165  * Input arguments should be main() function arguments.
166  * @param argc_ptr Arguments number (including executable)
167  * @param argv_ptr Arguments list.
168  */
169 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
170 {
171     char *argstr_flat;
172     wchar_t **argv_w;
173     int i, buffsize = 0, offset = 0;
174
175     if (win32_argv_utf8) {
176         *argc_ptr = win32_argc;
177         *argv_ptr = win32_argv_utf8;
178         return;
179     }
180
181     win32_argc = 0;
182     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
183     if (win32_argc <= 0 || !argv_w)
184         return;
185
186     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
187     for (i = 0; i < win32_argc; i++)
188         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
189                                         NULL, 0, NULL, NULL);
190
191     win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
192     argstr_flat     = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
193     if (win32_argv_utf8 == NULL) {
194         LocalFree(argv_w);
195         return;
196     }
197
198     for (i = 0; i < win32_argc; i++) {
199         win32_argv_utf8[i] = &argstr_flat[offset];
200         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201                                       &argstr_flat[offset],
202                                       buffsize - offset, NULL, NULL);
203     }
204     win32_argv_utf8[i] = NULL;
205     LocalFree(argv_w);
206
207     *argc_ptr = win32_argc;
208     *argv_ptr = win32_argv_utf8;
209 }
210 #else
211 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
212 {
213     /* nothing to do */
214 }
215 #endif /* WIN32 && !__MINGW32CE__ */
216
217
218 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
219 {
220     const OptionDef *po;
221     int bool_val = 1;
222     int *dstcount;
223     void *dst;
224
225     po = find_option(options, opt);
226     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
227         /* handle 'no' bool option */
228         po = find_option(options, opt + 2);
229         if (!(po->name && (po->flags & OPT_BOOL)))
230             goto unknown_opt;
231         bool_val = 0;
232     }
233     if (!po->name)
234         po = find_option(options, "default");
235     if (!po->name) {
236 unknown_opt:
237         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
238         return AVERROR(EINVAL);
239     }
240     if (po->flags & HAS_ARG && !arg) {
241         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
242         return AVERROR(EINVAL);
243     }
244
245     /* new-style options contain an offset into optctx, old-style address of
246      * a global var*/
247     dst = po->flags & (OPT_OFFSET|OPT_SPEC) ? (uint8_t*)optctx + po->u.off : po->u.dst_ptr;
248
249     if (po->flags & OPT_SPEC) {
250         SpecifierOpt **so = dst;
251         char *p = strchr(opt, ':');
252
253         dstcount = (int*)(so + 1);
254         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
255         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
256         dst = &(*so)[*dstcount - 1].u;
257     }
258
259     if (po->flags & OPT_STRING) {
260         char *str;
261         str = av_strdup(arg);
262         *(char**)dst = str;
263     } else if (po->flags & OPT_BOOL) {
264         *(int*)dst = bool_val;
265     } else if (po->flags & OPT_INT) {
266         *(int*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
267     } else if (po->flags & OPT_INT64) {
268         *(int64_t*)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
269     } else if (po->flags & OPT_TIME) {
270         *(int64_t*)dst = parse_time_or_die(opt, arg, 1);
271     } else if (po->flags & OPT_FLOAT) {
272         *(float*)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
273     } else if (po->flags & OPT_DOUBLE) {
274         *(double*)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
275     } else if (po->u.func_arg) {
276         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg) :
277                                           po->u.func_arg(opt, arg);
278         if (ret < 0) {
279             av_log(NULL, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", arg, opt);
280             return ret;
281         }
282     }
283     if (po->flags & OPT_EXIT)
284         exit_program(0);
285     return !!(po->flags & HAS_ARG);
286 }
287
288 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
289                    void (* parse_arg_function)(void *, const char*))
290 {
291     const char *opt;
292     int optindex, handleoptions = 1, ret;
293
294     /* perform system-dependent conversions for arguments list */
295     prepare_app_arguments(&argc, &argv);
296
297     /* parse options */
298     optindex = 1;
299     while (optindex < argc) {
300         opt = argv[optindex++];
301
302         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
303             if (opt[1] == '-' && opt[2] == '\0') {
304                 handleoptions = 0;
305                 continue;
306             }
307             opt++;
308
309             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
310                 exit_program(1);
311             optindex += ret;
312         } else {
313             if (parse_arg_function)
314                 parse_arg_function(optctx, opt);
315         }
316     }
317 }
318
319 /*
320  * Return index of option opt in argv or 0 if not found.
321  */
322 static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
323 {
324     const OptionDef *po;
325     int i;
326
327     for (i = 1; i < argc; i++) {
328         const char *cur_opt = argv[i];
329
330         if (*cur_opt++ != '-')
331             continue;
332
333         po = find_option(options, cur_opt);
334         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
335             po = find_option(options, cur_opt + 2);
336
337         if ((!po->name && !strcmp(cur_opt, optname)) ||
338              (po->name && !strcmp(optname, po->name)))
339             return i;
340
341         if (!po || po->flags & HAS_ARG)
342             i++;
343     }
344     return 0;
345 }
346
347 void parse_loglevel(int argc, char **argv, const OptionDef *options)
348 {
349     int idx = locate_option(argc, argv, options, "loglevel");
350     if (!idx)
351         idx = locate_option(argc, argv, options, "v");
352     if (idx && argv[idx + 1])
353         opt_loglevel("loglevel", argv[idx + 1]);
354 }
355
356 #define FLAGS(o) ((o)->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
357 int opt_default(const char *opt, const char *arg)
358 {
359     const AVOption *oc, *of, *os;
360     char opt_stripped[128];
361     const char *p;
362     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc;
363
364     if (!(p = strchr(opt, ':')))
365         p = opt + strlen(opt);
366     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
367
368     if ((oc = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) ||
369          ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
370           (oc = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
371         av_dict_set(&codec_opts, opt, arg, FLAGS(oc));
372     if ((of = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
373         av_dict_set(&format_opts, opt, arg, FLAGS(of));
374 #if CONFIG_SWSCALE
375     sc = sws_get_class();
376     if ((os = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
377         // XXX we only support sws_flags, not arbitrary sws options
378         int ret = av_opt_set(sws_opts, opt, arg, 0);
379         if (ret < 0) {
380             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
381             return ret;
382         }
383     }
384 #endif
385
386     if (oc || of || os)
387         return 0;
388     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
389     return AVERROR_OPTION_NOT_FOUND;
390 }
391
392 int opt_loglevel(const char *opt, const char *arg)
393 {
394     const struct { const char *name; int level; } log_levels[] = {
395         { "quiet"  , AV_LOG_QUIET   },
396         { "panic"  , AV_LOG_PANIC   },
397         { "fatal"  , AV_LOG_FATAL   },
398         { "error"  , AV_LOG_ERROR   },
399         { "warning", AV_LOG_WARNING },
400         { "info"   , AV_LOG_INFO    },
401         { "verbose", AV_LOG_VERBOSE },
402         { "debug"  , AV_LOG_DEBUG   },
403     };
404     char *tail;
405     int level;
406     int i;
407
408     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
409         if (!strcmp(log_levels[i].name, arg)) {
410             av_log_set_level(log_levels[i].level);
411             return 0;
412         }
413     }
414
415     level = strtol(arg, &tail, 10);
416     if (*tail) {
417         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
418                "Possible levels are numbers or:\n", arg);
419         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
420             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
421         exit_program(1);
422     }
423     av_log_set_level(level);
424     return 0;
425 }
426
427 int opt_codec_debug(const char *opt, const char *arg)
428 {
429     av_log_set_level(AV_LOG_DEBUG);
430     return opt_default(opt, arg);
431 }
432
433 int opt_timelimit(const char *opt, const char *arg)
434 {
435 #if HAVE_SETRLIMIT
436     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
437     struct rlimit rl = { lim, lim + 1 };
438     if (setrlimit(RLIMIT_CPU, &rl))
439         perror("setrlimit");
440 #else
441     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
442 #endif
443     return 0;
444 }
445
446 void print_error(const char *filename, int err)
447 {
448     char errbuf[128];
449     const char *errbuf_ptr = errbuf;
450
451     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
452         errbuf_ptr = strerror(AVUNERROR(err));
453     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
454 }
455
456 static int warned_cfg = 0;
457
458 #define INDENT        1
459 #define SHOW_VERSION  2
460 #define SHOW_CONFIG   4
461
462 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
463     if (CONFIG_##LIBNAME) {                                             \
464         const char *indent = flags & INDENT? "  " : "";                 \
465         if (flags & SHOW_VERSION) {                                     \
466             unsigned int version = libname##_version();                 \
467             av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
468                    indent, #libname,                                    \
469                    LIB##LIBNAME##_VERSION_MAJOR,                        \
470                    LIB##LIBNAME##_VERSION_MINOR,                        \
471                    LIB##LIBNAME##_VERSION_MICRO,                        \
472                    version >> 16, version >> 8 & 0xff, version & 0xff); \
473         }                                                               \
474         if (flags & SHOW_CONFIG) {                                      \
475             const char *cfg = libname##_configuration();                \
476             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
477                 if (!warned_cfg) {                                      \
478                     av_log(NULL, level,                                 \
479                             "%sWARNING: library configuration mismatch\n", \
480                             indent);                                    \
481                     warned_cfg = 1;                                     \
482                 }                                                       \
483                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
484                         indent, #libname, cfg);                         \
485             }                                                           \
486         }                                                               \
487     }                                                                   \
488
489 static void print_all_libs_info(int flags, int level)
490 {
491     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
492     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
493     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
494     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
495     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
496     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
497     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
498 }
499
500 void show_banner(void)
501 {
502     av_log(NULL, AV_LOG_INFO, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
503            program_name, program_birth_year, this_year);
504     av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s %s\n",
505            __DATE__, __TIME__, CC_TYPE, CC_VERSION);
506     av_log(NULL, AV_LOG_INFO, "  configuration: " FFMPEG_CONFIGURATION "\n");
507     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
508     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
509 }
510
511 int opt_version(const char *opt, const char *arg) {
512     av_log_set_callback(log_callback_help);
513     printf("%s " FFMPEG_VERSION "\n", program_name);
514     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
515     return 0;
516 }
517
518 int opt_license(const char *opt, const char *arg)
519 {
520     printf(
521 #if CONFIG_NONFREE
522     "This version of %s has nonfree parts compiled in.\n"
523     "Therefore it is not legally redistributable.\n",
524     program_name
525 #elif CONFIG_GPLV3
526     "%s is free software; you can redistribute it and/or modify\n"
527     "it under the terms of the GNU General Public License as published by\n"
528     "the Free Software Foundation; either version 3 of the License, or\n"
529     "(at your option) any later version.\n"
530     "\n"
531     "%s is distributed in the hope that it will be useful,\n"
532     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
533     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
534     "GNU General Public License for more details.\n"
535     "\n"
536     "You should have received a copy of the GNU General Public License\n"
537     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
538     program_name, program_name, program_name
539 #elif CONFIG_GPL
540     "%s is free software; you can redistribute it and/or modify\n"
541     "it under the terms of the GNU General Public License as published by\n"
542     "the Free Software Foundation; either version 2 of the License, or\n"
543     "(at your option) any later version.\n"
544     "\n"
545     "%s is distributed in the hope that it will be useful,\n"
546     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
547     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
548     "GNU General Public License for more details.\n"
549     "\n"
550     "You should have received a copy of the GNU General Public License\n"
551     "along with %s; if not, write to the Free Software\n"
552     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
553     program_name, program_name, program_name
554 #elif CONFIG_LGPLV3
555     "%s is free software; you can redistribute it and/or modify\n"
556     "it under the terms of the GNU Lesser General Public License as published by\n"
557     "the Free Software Foundation; either version 3 of the License, or\n"
558     "(at your option) any later version.\n"
559     "\n"
560     "%s is distributed in the hope that it will be useful,\n"
561     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
562     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
563     "GNU Lesser General Public License for more details.\n"
564     "\n"
565     "You should have received a copy of the GNU Lesser General Public License\n"
566     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
567     program_name, program_name, program_name
568 #else
569     "%s is free software; you can redistribute it and/or\n"
570     "modify it under the terms of the GNU Lesser General Public\n"
571     "License as published by the Free Software Foundation; either\n"
572     "version 2.1 of the License, or (at your option) any later version.\n"
573     "\n"
574     "%s is distributed in the hope that it will be useful,\n"
575     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
576     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
577     "Lesser General Public License for more details.\n"
578     "\n"
579     "You should have received a copy of the GNU Lesser General Public\n"
580     "License along with %s; if not, write to the Free Software\n"
581     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
582     program_name, program_name, program_name
583 #endif
584     );
585     return 0;
586 }
587
588 int opt_formats(const char *opt, const char *arg)
589 {
590     AVInputFormat *ifmt=NULL;
591     AVOutputFormat *ofmt=NULL;
592     const char *last_name;
593
594     printf(
595         "File formats:\n"
596         " D. = Demuxing supported\n"
597         " .E = Muxing supported\n"
598         " --\n");
599     last_name= "000";
600     for(;;){
601         int decode=0;
602         int encode=0;
603         const char *name=NULL;
604         const char *long_name=NULL;
605
606         while((ofmt= av_oformat_next(ofmt))) {
607             if((name == NULL || strcmp(ofmt->name, name)<0) &&
608                 strcmp(ofmt->name, last_name)>0){
609                 name= ofmt->name;
610                 long_name= ofmt->long_name;
611                 encode=1;
612             }
613         }
614         while((ifmt= av_iformat_next(ifmt))) {
615             if((name == NULL || strcmp(ifmt->name, name)<0) &&
616                 strcmp(ifmt->name, last_name)>0){
617                 name= ifmt->name;
618                 long_name= ifmt->long_name;
619                 encode=0;
620             }
621             if(name && strcmp(ifmt->name, name)==0)
622                 decode=1;
623         }
624         if(name==NULL)
625             break;
626         last_name= name;
627
628         printf(
629             " %s%s %-15s %s\n",
630             decode ? "D":" ",
631             encode ? "E":" ",
632             name,
633             long_name ? long_name:" ");
634     }
635     return 0;
636 }
637
638 int opt_codecs(const char *opt, const char *arg)
639 {
640     AVCodec *p=NULL, *p2;
641     const char *last_name;
642     printf(
643         "Codecs:\n"
644         " D..... = Decoding supported\n"
645         " .E.... = Encoding supported\n"
646         " ..V... = Video codec\n"
647         " ..A... = Audio codec\n"
648         " ..S... = Subtitle codec\n"
649         " ...S.. = Supports draw_horiz_band\n"
650         " ....D. = Supports direct rendering method 1\n"
651         " .....T = Supports weird frame truncation\n"
652         " ------\n");
653     last_name= "000";
654     for(;;){
655         int decode=0;
656         int encode=0;
657         int cap=0;
658         const char *type_str;
659
660         p2=NULL;
661         while((p= av_codec_next(p))) {
662             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
663                 strcmp(p->name, last_name)>0){
664                 p2= p;
665                 decode= encode= cap=0;
666             }
667             if(p2 && strcmp(p->name, p2->name)==0){
668                 if(p->decode) decode=1;
669                 if(p->encode) encode=1;
670                 cap |= p->capabilities;
671             }
672         }
673         if(p2==NULL)
674             break;
675         last_name= p2->name;
676
677         switch(p2->type) {
678         case AVMEDIA_TYPE_VIDEO:
679             type_str = "V";
680             break;
681         case AVMEDIA_TYPE_AUDIO:
682             type_str = "A";
683             break;
684         case AVMEDIA_TYPE_SUBTITLE:
685             type_str = "S";
686             break;
687         default:
688             type_str = "?";
689             break;
690         }
691         printf(
692             " %s%s%s%s%s%s %-15s %s",
693             decode ? "D": (/*p2->decoder ? "d":*/" "),
694             encode ? "E":" ",
695             type_str,
696             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
697             cap & CODEC_CAP_DR1 ? "D":" ",
698             cap & CODEC_CAP_TRUNCATED ? "T":" ",
699             p2->name,
700             p2->long_name ? p2->long_name : "");
701        /* if(p2->decoder && decode==0)
702             printf(" use %s for decoding", p2->decoder->name);*/
703         printf("\n");
704     }
705     printf("\n");
706     printf(
707 "Note, the names of encoders and decoders do not always match, so there are\n"
708 "several cases where the above table shows encoder only or decoder only entries\n"
709 "even though both encoding and decoding are supported. For example, the h263\n"
710 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
711 "worse.\n");
712     return 0;
713 }
714
715 int opt_bsfs(const char *opt, const char *arg)
716 {
717     AVBitStreamFilter *bsf=NULL;
718
719     printf("Bitstream filters:\n");
720     while((bsf = av_bitstream_filter_next(bsf)))
721         printf("%s\n", bsf->name);
722     printf("\n");
723     return 0;
724 }
725
726 int opt_protocols(const char *opt, const char *arg)
727 {
728     URLProtocol *up=NULL;
729
730     printf("Supported file protocols:\n"
731            "I.. = Input  supported\n"
732            ".O. = Output supported\n"
733            "..S = Seek   supported\n"
734            "FLAGS NAME\n"
735            "----- \n");
736     while((up = av_protocol_next(up)))
737         printf("%c%c%c   %s\n",
738                up->url_read  ? 'I' : '.',
739                up->url_write ? 'O' : '.',
740                up->url_seek  ? 'S' : '.',
741                up->name);
742     return 0;
743 }
744
745 int opt_filters(const char *opt, const char *arg)
746 {
747     AVFilter av_unused(**filter) = NULL;
748
749     printf("Filters:\n");
750 #if CONFIG_AVFILTER
751     while ((filter = av_filter_next(filter)) && *filter)
752         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
753 #endif
754     return 0;
755 }
756
757 int opt_pix_fmts(const char *opt, const char *arg)
758 {
759     enum PixelFormat pix_fmt;
760
761     printf(
762         "Pixel formats:\n"
763         "I.... = Supported Input  format for conversion\n"
764         ".O... = Supported Output format for conversion\n"
765         "..H.. = Hardware accelerated format\n"
766         "...P. = Paletted format\n"
767         "....B = Bitstream format\n"
768         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
769         "-----\n");
770
771 #if !CONFIG_SWSCALE
772 #   define sws_isSupportedInput(x)  0
773 #   define sws_isSupportedOutput(x) 0
774 #endif
775
776     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
777         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
778         if(!pix_desc->name)
779             continue;
780         printf("%c%c%c%c%c %-16s       %d            %2d\n",
781                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
782                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
783                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
784                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
785                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
786                pix_desc->name,
787                pix_desc->nb_components,
788                av_get_bits_per_pixel(pix_desc));
789     }
790     return 0;
791 }
792
793 int show_sample_fmts(const char *opt, const char *arg)
794 {
795     int i;
796     char fmt_str[128];
797     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
798         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
799     return 0;
800 }
801
802 int read_yesno(void)
803 {
804     int c = getchar();
805     int yesno = (toupper(c) == 'Y');
806
807     while (c != '\n' && c != EOF)
808         c = getchar();
809
810     return yesno;
811 }
812
813 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
814 {
815     int ret;
816     FILE *f = fopen(filename, "rb");
817
818     if (!f) {
819         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
820         return AVERROR(errno);
821     }
822     fseek(f, 0, SEEK_END);
823     *size = ftell(f);
824     fseek(f, 0, SEEK_SET);
825     *bufptr = av_malloc(*size + 1);
826     if (!*bufptr) {
827         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
828         fclose(f);
829         return AVERROR(ENOMEM);
830     }
831     ret = fread(*bufptr, 1, *size, f);
832     if (ret < *size) {
833         av_free(*bufptr);
834         if (ferror(f)) {
835             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
836                    filename, strerror(errno));
837             ret = AVERROR(errno);
838         } else
839             ret = AVERROR_EOF;
840     } else {
841         ret = 0;
842         (*bufptr)[*size++] = '\0';
843     }
844
845     fclose(f);
846     return ret;
847 }
848
849 FILE *get_preset_file(char *filename, size_t filename_size,
850                       const char *preset_name, int is_path, const char *codec_name)
851 {
852     FILE *f = NULL;
853     int i;
854     const char *base[3]= { getenv("FFMPEG_DATADIR"),
855                            getenv("HOME"),
856                            FFMPEG_DATADIR,
857                          };
858
859     if (is_path) {
860         av_strlcpy(filename, preset_name, filename_size);
861         f = fopen(filename, "r");
862     } else {
863 #ifdef _WIN32
864         char datadir[MAX_PATH], *ls;
865         base[2] = NULL;
866
867         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
868         {
869             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
870                 if (*ls == '\\') *ls = '/';
871
872             if (ls = strrchr(datadir, '/'))
873             {
874                 *ls = 0;
875                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
876                 base[2] = datadir;
877             }
878         }
879 #endif
880         for (i = 0; i < 3 && !f; i++) {
881             if (!base[i])
882                 continue;
883             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
884             f = fopen(filename, "r");
885             if (!f && codec_name) {
886                 snprintf(filename, filename_size,
887                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
888                 f = fopen(filename, "r");
889             }
890         }
891     }
892
893     return f;
894 }
895
896 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
897 {
898     if (*spec <= '9' && *spec >= '0')                                        /* opt:index */
899         return strtol(spec, NULL, 0) == st->index;
900     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
901         enum AVMediaType type;
902
903         switch (*spec++) {
904         case 'v': type = AVMEDIA_TYPE_VIDEO;    break;
905         case 'a': type = AVMEDIA_TYPE_AUDIO;    break;
906         case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
907         case 'd': type = AVMEDIA_TYPE_DATA;     break;
908         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
909         default: abort(); // never reached, silence warning
910         }
911         if (type != st->codec->codec_type)
912             return 0;
913         if (*spec++ == ':') {                                   /* possibly followed by :index */
914             int i, index = strtol(spec, NULL, 0);
915             for (i = 0; i < s->nb_streams; i++)
916                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
917                    return i == st->index;
918             return 0;
919         }
920         return 1;
921     } else if (*spec == 'p' && *(spec + 1) == ':') {
922         int prog_id, i, j;
923         char *endptr;
924         spec += 2;
925         prog_id = strtol(spec, &endptr, 0);
926         for (i = 0; i < s->nb_programs; i++) {
927             if (s->programs[i]->id != prog_id)
928                 continue;
929
930             if (*endptr++ == ':') {
931                 int stream_idx = strtol(endptr, NULL, 0);
932                 return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
933                         st->index == s->programs[i]->stream_index[stream_idx]);
934             }
935
936             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
937                 if (st->index == s->programs[i]->stream_index[j])
938                     return 1;
939         }
940         return 0;
941     } else if (!*spec) /* empty specifier, matches everything */
942         return 1;
943
944     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
945     return AVERROR(EINVAL);
946 }
947
948 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
949 {
950     AVDictionary    *ret = NULL;
951     AVDictionaryEntry *t = NULL;
952     AVCodec       *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
953     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
954     char          prefix = 0;
955     const AVClass    *cc = avcodec_get_class();
956
957     if (!codec)
958         return NULL;
959
960     switch (codec->type) {
961     case AVMEDIA_TYPE_VIDEO:    prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM;    break;
962     case AVMEDIA_TYPE_AUDIO:    prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM;    break;
963     case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
964     }
965
966     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
967         char *p = strchr(t->key, ':');
968
969         /* check stream specification in opt name */
970         if (p)
971             switch (check_stream_specifier(s, st, p + 1)) {
972             case  1: *p = 0; break;
973             case  0:         continue;
974             default:         return NULL;
975             }
976
977         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
978             (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
979             av_dict_set(&ret, t->key, t->value, 0);
980         else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
981             av_dict_set(&ret, t->key+1, t->value, 0);
982
983         if (p)
984             *p = ':';
985     }
986     return ret;
987 }
988
989 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
990 {
991     int i;
992     AVDictionary **opts;
993
994     if (!s->nb_streams)
995         return NULL;
996     opts = av_mallocz(s->nb_streams * sizeof(*opts));
997     if (!opts) {
998         av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
999         return NULL;
1000     }
1001     for (i = 0; i < s->nb_streams; i++)
1002         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
1003     return opts;
1004 }
1005
1006 void *grow_array(void *array, int elem_size, int *size, int new_size)
1007 {
1008     if (new_size >= INT_MAX / elem_size) {
1009         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1010         exit_program(1);
1011     }
1012     if (*size < new_size) {
1013         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1014         if (!tmp) {
1015             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1016             exit_program(1);
1017         }
1018         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1019         *size = new_size;
1020         return tmp;
1021     }
1022     return array;
1023 }