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