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