lavu: add av_get_alt_sample_fmt().
[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         printf("%c%c%c%c%c %-16s       %d            %2d\n",
779                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
780                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
781                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
782                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
783                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
784                pix_desc->name,
785                pix_desc->nb_components,
786                av_get_bits_per_pixel(pix_desc));
787     }
788     return 0;
789 }
790
791 int show_sample_fmts(const char *opt, const char *arg)
792 {
793     int i;
794     char fmt_str[128];
795     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
796         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
797     return 0;
798 }
799
800 int read_yesno(void)
801 {
802     int c = getchar();
803     int yesno = (toupper(c) == 'Y');
804
805     while (c != '\n' && c != EOF)
806         c = getchar();
807
808     return yesno;
809 }
810
811 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
812 {
813     int ret;
814     FILE *f = fopen(filename, "rb");
815
816     if (!f) {
817         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
818         return AVERROR(errno);
819     }
820     fseek(f, 0, SEEK_END);
821     *size = ftell(f);
822     fseek(f, 0, SEEK_SET);
823     *bufptr = av_malloc(*size + 1);
824     if (!*bufptr) {
825         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
826         fclose(f);
827         return AVERROR(ENOMEM);
828     }
829     ret = fread(*bufptr, 1, *size, f);
830     if (ret < *size) {
831         av_free(*bufptr);
832         if (ferror(f)) {
833             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
834                    filename, strerror(errno));
835             ret = AVERROR(errno);
836         } else
837             ret = AVERROR_EOF;
838     } else {
839         ret = 0;
840         (*bufptr)[*size++] = '\0';
841     }
842
843     fclose(f);
844     return ret;
845 }
846
847 FILE *get_preset_file(char *filename, size_t filename_size,
848                       const char *preset_name, int is_path, const char *codec_name)
849 {
850     FILE *f = NULL;
851     int i;
852     const char *base[3]= { getenv("FFMPEG_DATADIR"),
853                            getenv("HOME"),
854                            FFMPEG_DATADIR,
855                          };
856
857     if (is_path) {
858         av_strlcpy(filename, preset_name, filename_size);
859         f = fopen(filename, "r");
860     } else {
861 #ifdef _WIN32
862         char datadir[MAX_PATH], *ls;
863         base[2] = NULL;
864
865         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
866         {
867             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
868                 if (*ls == '\\') *ls = '/';
869
870             if (ls = strrchr(datadir, '/'))
871             {
872                 *ls = 0;
873                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
874                 base[2] = datadir;
875             }
876         }
877 #endif
878         for (i = 0; i < 3 && !f; i++) {
879             if (!base[i])
880                 continue;
881             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
882             f = fopen(filename, "r");
883             if (!f && codec_name) {
884                 snprintf(filename, filename_size,
885                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
886                 f = fopen(filename, "r");
887             }
888         }
889     }
890
891     return f;
892 }
893
894 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
895 {
896     if (*spec <= '9' && *spec >= '0')                                        /* opt:index */
897         return strtol(spec, NULL, 0) == st->index;
898     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
899         enum AVMediaType type;
900
901         switch (*spec++) {
902         case 'v': type = AVMEDIA_TYPE_VIDEO;    break;
903         case 'a': type = AVMEDIA_TYPE_AUDIO;    break;
904         case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
905         case 'd': type = AVMEDIA_TYPE_DATA;     break;
906         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
907         default: abort(); // never reached, silence warning
908         }
909         if (type != st->codec->codec_type)
910             return 0;
911         if (*spec++ == ':') {                                   /* possibly followed by :index */
912             int i, index = strtol(spec, NULL, 0);
913             for (i = 0; i < s->nb_streams; i++)
914                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
915                    return i == st->index;
916             return 0;
917         }
918         return 1;
919     } else if (*spec == 'p' && *(spec + 1) == ':') {
920         int prog_id, i, j;
921         char *endptr;
922         spec += 2;
923         prog_id = strtol(spec, &endptr, 0);
924         for (i = 0; i < s->nb_programs; i++) {
925             if (s->programs[i]->id != prog_id)
926                 continue;
927
928             if (*endptr++ == ':') {
929                 int stream_idx = strtol(endptr, NULL, 0);
930                 return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
931                         st->index == s->programs[i]->stream_index[stream_idx]);
932             }
933
934             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
935                 if (st->index == s->programs[i]->stream_index[j])
936                     return 1;
937         }
938         return 0;
939     } else if (!*spec) /* empty specifier, matches everything */
940         return 1;
941
942     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
943     return AVERROR(EINVAL);
944 }
945
946 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
947 {
948     AVDictionary    *ret = NULL;
949     AVDictionaryEntry *t = NULL;
950     AVCodec       *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
951     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
952     char          prefix = 0;
953     const AVClass    *cc = avcodec_get_class();
954
955     if (!codec)
956         return NULL;
957
958     switch (codec->type) {
959     case AVMEDIA_TYPE_VIDEO:    prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM;    break;
960     case AVMEDIA_TYPE_AUDIO:    prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM;    break;
961     case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
962     }
963
964     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
965         char *p = strchr(t->key, ':');
966
967         /* check stream specification in opt name */
968         if (p)
969             switch (check_stream_specifier(s, st, p + 1)) {
970             case  1: *p = 0; break;
971             case  0:         continue;
972             default:         return NULL;
973             }
974
975         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
976             (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ)))
977             av_dict_set(&ret, t->key, t->value, 0);
978         else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
979             av_dict_set(&ret, t->key+1, t->value, 0);
980
981         if (p)
982             *p = ':';
983     }
984     return ret;
985 }
986
987 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
988 {
989     int i;
990     AVDictionary **opts;
991
992     if (!s->nb_streams)
993         return NULL;
994     opts = av_mallocz(s->nb_streams * sizeof(*opts));
995     if (!opts) {
996         av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
997         return NULL;
998     }
999     for (i = 0; i < s->nb_streams; i++)
1000         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
1001     return opts;
1002 }
1003
1004 void *grow_array(void *array, int elem_size, int *size, int new_size)
1005 {
1006     if (new_size >= INT_MAX / elem_size) {
1007         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1008         exit_program(1);
1009     }
1010     if (*size < new_size) {
1011         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1012         if (!tmp) {
1013             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1014             exit_program(1);
1015         }
1016         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1017         *size = new_size;
1018         return tmp;
1019     }
1020     return array;
1021 }