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