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