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