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