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