5fdb1a6ba245f9a212215c096b0b41da6826524d
[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 "libavresample/avresample.h"
36 #include "libswscale/swscale.h"
37 #include "libswresample/swresample.h"
38 #if CONFIG_POSTPROC
39 #include "libpostproc/postprocess.h"
40 #endif
41 #include "libavutil/avassert.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/imgutils.h"
45 #include "libavutil/parseutils.h"
46 #include "libavutil/pixdesc.h"
47 #include "libavutil/eval.h"
48 #include "libavutil/dict.h"
49 #include "libavutil/opt.h"
50 #include "cmdutils.h"
51 #include "version.h"
52 #if CONFIG_NETWORK
53 #include "libavformat/network.h"
54 #endif
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/resource.h>
57 #endif
58
59 struct SwsContext *sws_opts;
60 SwrContext *swr_opts;
61 AVDictionary *format_opts, *codec_opts;
62
63 const int this_year = 2012;
64
65 static FILE *report_file;
66
67 void init_opts(void)
68 {
69
70     if(CONFIG_SWSCALE)
71         sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
72                               NULL, NULL, NULL);
73
74     if(CONFIG_SWRESAMPLE)
75         swr_opts = swr_alloc();
76 }
77
78 void uninit_opts(void)
79 {
80 #if CONFIG_SWSCALE
81     sws_freeContext(sws_opts);
82     sws_opts = NULL;
83 #endif
84
85     if(CONFIG_SWRESAMPLE)
86         swr_free(&swr_opts);
87
88     av_dict_free(&format_opts);
89     av_dict_free(&codec_opts);
90 }
91
92 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
93 {
94     vfprintf(stdout, fmt, vl);
95 }
96
97 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
98 {
99     va_list vl2;
100     char line[1024];
101     static int print_prefix = 1;
102
103     va_copy(vl2, vl);
104     av_log_default_callback(ptr, level, fmt, vl);
105     av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
106     va_end(vl2);
107     fputs(line, report_file);
108     fflush(report_file);
109 }
110
111 double parse_number_or_die(const char *context, const char *numstr, int type,
112                            double min, double max)
113 {
114     char *tail;
115     const char *error;
116     double d = av_strtod(numstr, &tail);
117     if (*tail)
118         error = "Expected number for %s but found: %s\n";
119     else if (d < min || d > max)
120         error = "The value for %s was %s which is not within %f - %f\n";
121     else if (type == OPT_INT64 && (int64_t)d != d)
122         error = "Expected int64 for %s but found %s\n";
123     else if (type == OPT_INT && (int)d != d)
124         error = "Expected int for %s but found %s\n";
125     else
126         return d;
127     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
128     exit_program(1);
129     return 0;
130 }
131
132 int64_t parse_time_or_die(const char *context, const char *timestr,
133                           int is_duration)
134 {
135     int64_t us;
136     if (av_parse_time(&us, timestr, is_duration) < 0) {
137         av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
138                is_duration ? "duration" : "date", context, timestr);
139         exit_program(1);
140     }
141     return us;
142 }
143
144 void show_help_options(const OptionDef *options, const char *msg, int mask,
145                        int value)
146 {
147     const OptionDef *po;
148     int first;
149
150     first = 1;
151     for (po = options; po->name != NULL; po++) {
152         char buf[64];
153         if ((po->flags & mask) == value) {
154             if (first) {
155                 printf("%s", msg);
156                 first = 0;
157             }
158             av_strlcpy(buf, po->name, sizeof(buf));
159             if (po->flags & HAS_ARG) {
160                 av_strlcat(buf, " ", sizeof(buf));
161                 av_strlcat(buf, po->argname, sizeof(buf));
162             }
163             printf("-%-17s  %s\n", buf, po->help);
164         }
165     }
166 }
167
168 void show_help_children(const AVClass *class, int flags)
169 {
170     const AVClass *child = NULL;
171     av_opt_show2(&class, NULL, flags, 0);
172     printf("\n");
173
174     while (child = av_opt_child_class_next(class, child))
175         show_help_children(child, flags);
176 }
177
178 static const OptionDef *find_option(const OptionDef *po, const char *name)
179 {
180     const char *p = strchr(name, ':');
181     int len = p ? p - name : strlen(name);
182
183     while (po->name != NULL) {
184         if (!strncmp(name, po->name, len) && strlen(po->name) == len)
185             break;
186         po++;
187     }
188     return po;
189 }
190
191 #if defined(_WIN32) && !defined(__MINGW32CE__)
192 #include <windows.h>
193 #include <shellapi.h>
194 /* Will be leaked on exit */
195 static char** win32_argv_utf8 = NULL;
196 static int win32_argc = 0;
197
198 /**
199  * Prepare command line arguments for executable.
200  * For Windows - perform wide-char to UTF-8 conversion.
201  * Input arguments should be main() function arguments.
202  * @param argc_ptr Arguments number (including executable)
203  * @param argv_ptr Arguments list.
204  */
205 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
206 {
207     char *argstr_flat;
208     wchar_t **argv_w;
209     int i, buffsize = 0, offset = 0;
210
211     if (win32_argv_utf8) {
212         *argc_ptr = win32_argc;
213         *argv_ptr = win32_argv_utf8;
214         return;
215     }
216
217     win32_argc = 0;
218     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
219     if (win32_argc <= 0 || !argv_w)
220         return;
221
222     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
223     for (i = 0; i < win32_argc; i++)
224         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
225                                         NULL, 0, NULL, NULL);
226
227     win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
228     argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
229     if (win32_argv_utf8 == NULL) {
230         LocalFree(argv_w);
231         return;
232     }
233
234     for (i = 0; i < win32_argc; i++) {
235         win32_argv_utf8[i] = &argstr_flat[offset];
236         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
237                                       &argstr_flat[offset],
238                                       buffsize - offset, NULL, NULL);
239     }
240     win32_argv_utf8[i] = NULL;
241     LocalFree(argv_w);
242
243     *argc_ptr = win32_argc;
244     *argv_ptr = win32_argv_utf8;
245 }
246 #else
247 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
248 {
249     /* nothing to do */
250 }
251 #endif /* WIN32 && !__MINGW32CE__ */
252
253 int parse_option(void *optctx, const char *opt, const char *arg,
254                  const OptionDef *options)
255 {
256     const OptionDef *po;
257     int bool_val = 1;
258     int *dstcount;
259     void *dst;
260
261     po = find_option(options, opt);
262     if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
263         /* handle 'no' bool option */
264         po = find_option(options, opt + 2);
265         if ((po->name && (po->flags & OPT_BOOL)))
266             bool_val = 0;
267     }
268     if (!po->name)
269         po = find_option(options, "default");
270     if (!po->name) {
271         av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
272         return AVERROR(EINVAL);
273     }
274     if (po->flags & HAS_ARG && !arg) {
275         av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
276         return AVERROR(EINVAL);
277     }
278
279     /* new-style options contain an offset into optctx, old-style address of
280      * a global var*/
281     dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
282                                               : po->u.dst_ptr;
283
284     if (po->flags & OPT_SPEC) {
285         SpecifierOpt **so = dst;
286         char *p = strchr(opt, ':');
287
288         dstcount = (int *)(so + 1);
289         *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
290         (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
291         dst = &(*so)[*dstcount - 1].u;
292     }
293
294     if (po->flags & OPT_STRING) {
295         char *str;
296         str = av_strdup(arg);
297         *(char **)dst = str;
298     } else if (po->flags & OPT_BOOL) {
299         *(int *)dst = bool_val;
300     } else if (po->flags & OPT_INT) {
301         *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
302     } else if (po->flags & OPT_INT64) {
303         *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
304     } else if (po->flags & OPT_TIME) {
305         *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
306     } else if (po->flags & OPT_FLOAT) {
307         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
308     } else if (po->flags & OPT_DOUBLE) {
309         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
310     } else if (po->u.func_arg) {
311         int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
312                                         : po->u.func_arg(opt, arg);
313         if (ret < 0) {
314             av_log(NULL, AV_LOG_ERROR,
315                    "Failed to set value '%s' for option '%s'\n", arg, opt);
316             return ret;
317         }
318     }
319     if (po->flags & OPT_EXIT)
320         exit_program(0);
321     return !!(po->flags & HAS_ARG);
322 }
323
324 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
325                    void (*parse_arg_function)(void *, const char*))
326 {
327     const char *opt;
328     int optindex, handleoptions = 1, ret;
329
330     /* perform system-dependent conversions for arguments list */
331     prepare_app_arguments(&argc, &argv);
332
333     /* parse options */
334     optindex = 1;
335     while (optindex < argc) {
336         opt = argv[optindex++];
337
338         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
339             if (opt[1] == '-' && opt[2] == '\0') {
340                 handleoptions = 0;
341                 continue;
342             }
343             opt++;
344
345             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
346                 exit_program(1);
347             optindex += ret;
348         } else {
349             if (parse_arg_function)
350                 parse_arg_function(optctx, opt);
351         }
352     }
353 }
354
355 int locate_option(int argc, char **argv, const OptionDef *options,
356                   const char *optname)
357 {
358     const OptionDef *po;
359     int i;
360
361     for (i = 1; i < argc; i++) {
362         const char *cur_opt = argv[i];
363
364         if (*cur_opt++ != '-')
365             continue;
366
367         po = find_option(options, cur_opt);
368         if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
369             po = find_option(options, cur_opt + 2);
370
371         if ((!po->name && !strcmp(cur_opt, optname)) ||
372              (po->name && !strcmp(optname, po->name)))
373             return i;
374
375         if (!po || po->flags & HAS_ARG)
376             i++;
377     }
378     return 0;
379 }
380
381 static void dump_argument(const char *a)
382 {
383     const unsigned char *p;
384
385     for (p = a; *p; p++)
386         if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
387               *p == '_' || (*p >= 'a' && *p <= 'z')))
388             break;
389     if (!*p) {
390         fputs(a, report_file);
391         return;
392     }
393     fputc('"', report_file);
394     for (p = a; *p; p++) {
395         if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
396             fprintf(report_file, "\\%c", *p);
397         else if (*p < ' ' || *p > '~')
398             fprintf(report_file, "\\x%02x", *p);
399         else
400             fputc(*p, report_file);
401     }
402     fputc('"', report_file);
403 }
404
405 void parse_loglevel(int argc, char **argv, const OptionDef *options)
406 {
407     int idx = locate_option(argc, argv, options, "loglevel");
408     if (!idx)
409         idx = locate_option(argc, argv, options, "v");
410     if (idx && argv[idx + 1])
411         opt_loglevel("loglevel", argv[idx + 1]);
412     idx = locate_option(argc, argv, options, "report");
413     if (idx || getenv("FFREPORT")) {
414         opt_report("report");
415         if (report_file) {
416             int i;
417             fprintf(report_file, "Command line:\n");
418             for (i = 0; i < argc; i++) {
419                 dump_argument(argv[i]);
420                 fputc(i < argc - 1 ? ' ' : '\n', report_file);
421             }
422             fflush(report_file);
423         }
424     }
425 }
426
427 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
428 int opt_default(const char *opt, const char *arg)
429 {
430     const AVOption *o;
431     char opt_stripped[128];
432     const char *p;
433     const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc, *swr_class;
434
435     if (!(p = strchr(opt, ':')))
436         p = opt + strlen(opt);
437     av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
438
439     if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
440                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
441         ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
442          (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
443         av_dict_set(&codec_opts, opt, arg, FLAGS);
444     else if ((o = av_opt_find(&fc, opt, NULL, 0,
445                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
446         av_dict_set(&format_opts, opt, arg, FLAGS);
447 #if CONFIG_SWSCALE
448     sc = sws_get_class();
449     if (!o && (o = av_opt_find(&sc, opt, NULL, 0,
450                          AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
451         // XXX we only support sws_flags, not arbitrary sws options
452         int ret = av_opt_set(sws_opts, opt, arg, 0);
453         if (ret < 0) {
454             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
455             return ret;
456         }
457     }
458 #endif
459 #if CONFIG_SWRESAMPLE
460     swr_class = swr_get_class();
461     if (!o && (o = av_opt_find(&swr_class, opt, NULL, 0,
462                                AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
463         int ret = av_opt_set(swr_opts, opt, arg, 0);
464         if (ret < 0) {
465             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
466             return ret;
467         }
468     }
469 #endif
470
471     if (o)
472         return 0;
473     av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
474     return AVERROR_OPTION_NOT_FOUND;
475 }
476
477 int opt_loglevel(const char *opt, const char *arg)
478 {
479     const struct { const char *name; int level; } log_levels[] = {
480         { "quiet"  , AV_LOG_QUIET   },
481         { "panic"  , AV_LOG_PANIC   },
482         { "fatal"  , AV_LOG_FATAL   },
483         { "error"  , AV_LOG_ERROR   },
484         { "warning", AV_LOG_WARNING },
485         { "info"   , AV_LOG_INFO    },
486         { "verbose", AV_LOG_VERBOSE },
487         { "debug"  , AV_LOG_DEBUG   },
488     };
489     char *tail;
490     int level;
491     int i;
492
493     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
494         if (!strcmp(log_levels[i].name, arg)) {
495             av_log_set_level(log_levels[i].level);
496             return 0;
497         }
498     }
499
500     level = strtol(arg, &tail, 10);
501     if (*tail) {
502         av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
503                "Possible levels are numbers or:\n", arg);
504         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
505             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
506         exit_program(1);
507     }
508     av_log_set_level(level);
509     return 0;
510 }
511
512 int opt_report(const char *opt)
513 {
514     char filename[64];
515     time_t now;
516     struct tm *tm;
517
518     if (report_file) /* already opened */
519         return 0;
520     time(&now);
521     tm = localtime(&now);
522     snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
523              program_name,
524              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
525              tm->tm_hour, tm->tm_min, tm->tm_sec);
526     report_file = fopen(filename, "w");
527     if (!report_file) {
528         av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
529                filename, strerror(errno));
530         return AVERROR(errno);
531     }
532     av_log_set_callback(log_callback_report);
533     av_log(NULL, AV_LOG_INFO,
534            "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
535            "Report written to \"%s\"\n",
536            program_name,
537            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
538            tm->tm_hour, tm->tm_min, tm->tm_sec,
539            filename);
540     av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
541     return 0;
542 }
543
544 int opt_max_alloc(const char *opt, const char *arg)
545 {
546     char *tail;
547     size_t max;
548
549     max = strtol(arg, &tail, 10);
550     if (*tail) {
551         av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
552         exit_program(1);
553     }
554     av_max_alloc(max);
555     return 0;
556 }
557
558 int opt_cpuflags(const char *opt, const char *arg)
559 {
560     int ret;
561     unsigned flags = av_get_cpu_flags();
562
563     if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
564         return ret;
565
566     av_force_cpu_flags(flags);
567     return 0;
568 }
569
570 int opt_codec_debug(const char *opt, const char *arg)
571 {
572     av_log_set_level(AV_LOG_DEBUG);
573     return opt_default(opt, arg);
574 }
575
576 int opt_timelimit(const char *opt, const char *arg)
577 {
578 #if HAVE_SETRLIMIT
579     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
580     struct rlimit rl = { lim, lim + 1 };
581     if (setrlimit(RLIMIT_CPU, &rl))
582         perror("setrlimit");
583 #else
584     av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
585 #endif
586     return 0;
587 }
588
589 void print_error(const char *filename, int err)
590 {
591     char errbuf[128];
592     const char *errbuf_ptr = errbuf;
593
594     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
595         errbuf_ptr = strerror(AVUNERROR(err));
596     av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
597 }
598
599 static int warned_cfg = 0;
600
601 #define INDENT        1
602 #define SHOW_VERSION  2
603 #define SHOW_CONFIG   4
604 #define SHOW_COPYRIGHT 8
605
606 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
607     if (CONFIG_##LIBNAME) {                                             \
608         const char *indent = flags & INDENT? "  " : "";                 \
609         if (flags & SHOW_VERSION) {                                     \
610             unsigned int version = libname##_version();                 \
611             av_log(NULL, level,                                         \
612                    "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
613                    indent, #libname,                                    \
614                    LIB##LIBNAME##_VERSION_MAJOR,                        \
615                    LIB##LIBNAME##_VERSION_MINOR,                        \
616                    LIB##LIBNAME##_VERSION_MICRO,                        \
617                    version >> 16, version >> 8 & 0xff, version & 0xff); \
618         }                                                               \
619         if (flags & SHOW_CONFIG) {                                      \
620             const char *cfg = libname##_configuration();                \
621             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
622                 if (!warned_cfg) {                                      \
623                     av_log(NULL, level,                                 \
624                             "%sWARNING: library configuration mismatch\n", \
625                             indent);                                    \
626                     warned_cfg = 1;                                     \
627                 }                                                       \
628                 av_log(NULL, level, "%s%-11s configuration: %s\n",      \
629                         indent, #libname, cfg);                         \
630             }                                                           \
631         }                                                               \
632     }                                                                   \
633
634 static void print_all_libs_info(int flags, int level)
635 {
636     PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
637     PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
638     PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
639     PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
640     PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
641 //    PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
642     PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
643     PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
644 #if CONFIG_POSTPROC
645     PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
646 #endif
647 }
648
649 static void print_program_info(int flags, int level)
650 {
651     const char *indent = flags & INDENT? "  " : "";
652
653     av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
654     if (flags & SHOW_COPYRIGHT)
655         av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
656                program_birth_year, this_year);
657     av_log(NULL, level, "\n");
658     av_log(NULL, level, "%sbuilt on %s %s with %s\n",
659            indent, __DATE__, __TIME__, CC_IDENT);
660
661     av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
662 }
663
664 void show_banner(int argc, char **argv, const OptionDef *options)
665 {
666     int idx = locate_option(argc, argv, options, "version");
667     if (idx)
668         return;
669
670     print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
671     print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
672     print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
673 }
674
675 int opt_version(const char *opt, const char *arg) {
676     av_log_set_callback(log_callback_help);
677     print_program_info (0           , AV_LOG_INFO);
678     print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
679     return 0;
680 }
681
682 int opt_license(const char *opt, const char *arg)
683 {
684     printf(
685 #if CONFIG_NONFREE
686     "This version of %s has nonfree parts compiled in.\n"
687     "Therefore it is not legally redistributable.\n",
688     program_name
689 #elif CONFIG_GPLV3
690     "%s is free software; you can redistribute it and/or modify\n"
691     "it under the terms of the GNU General Public License as published by\n"
692     "the Free Software Foundation; either version 3 of the License, or\n"
693     "(at your option) any later version.\n"
694     "\n"
695     "%s is distributed in the hope that it will be useful,\n"
696     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
697     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
698     "GNU General Public License for more details.\n"
699     "\n"
700     "You should have received a copy of the GNU General Public License\n"
701     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
702     program_name, program_name, program_name
703 #elif CONFIG_GPL
704     "%s is free software; you can redistribute it and/or modify\n"
705     "it under the terms of the GNU General Public License as published by\n"
706     "the Free Software Foundation; either version 2 of the License, or\n"
707     "(at your option) any later version.\n"
708     "\n"
709     "%s is distributed in the hope that it will be useful,\n"
710     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
711     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
712     "GNU General Public License for more details.\n"
713     "\n"
714     "You should have received a copy of the GNU General Public License\n"
715     "along with %s; if not, write to the Free Software\n"
716     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
717     program_name, program_name, program_name
718 #elif CONFIG_LGPLV3
719     "%s is free software; you can redistribute it and/or modify\n"
720     "it under the terms of the GNU Lesser General Public License as published by\n"
721     "the Free Software Foundation; either version 3 of the License, or\n"
722     "(at your option) any later version.\n"
723     "\n"
724     "%s is distributed in the hope that it will be useful,\n"
725     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
726     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
727     "GNU Lesser General Public License for more details.\n"
728     "\n"
729     "You should have received a copy of the GNU Lesser General Public License\n"
730     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
731     program_name, program_name, program_name
732 #else
733     "%s is free software; you can redistribute it and/or\n"
734     "modify it under the terms of the GNU Lesser General Public\n"
735     "License as published by the Free Software Foundation; either\n"
736     "version 2.1 of the License, or (at your option) any later version.\n"
737     "\n"
738     "%s is distributed in the hope that it will be useful,\n"
739     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
740     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
741     "Lesser General Public License for more details.\n"
742     "\n"
743     "You should have received a copy of the GNU Lesser General Public\n"
744     "License along with %s; if not, write to the Free Software\n"
745     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
746     program_name, program_name, program_name
747 #endif
748     );
749     return 0;
750 }
751
752 int opt_formats(const char *opt, const char *arg)
753 {
754     AVInputFormat *ifmt  = NULL;
755     AVOutputFormat *ofmt = NULL;
756     const char *last_name;
757
758     printf("File formats:\n"
759            " D. = Demuxing supported\n"
760            " .E = Muxing supported\n"
761            " --\n");
762     last_name = "000";
763     for (;;) {
764         int decode = 0;
765         int encode = 0;
766         const char *name      = NULL;
767         const char *long_name = NULL;
768
769         while ((ofmt = av_oformat_next(ofmt))) {
770             if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
771                 strcmp(ofmt->name, last_name) > 0) {
772                 name      = ofmt->name;
773                 long_name = ofmt->long_name;
774                 encode    = 1;
775             }
776         }
777         while ((ifmt = av_iformat_next(ifmt))) {
778             if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
779                 strcmp(ifmt->name, last_name) > 0) {
780                 name      = ifmt->name;
781                 long_name = ifmt->long_name;
782                 encode    = 0;
783             }
784             if (name && strcmp(ifmt->name, name) == 0)
785                 decode = 1;
786         }
787         if (name == NULL)
788             break;
789         last_name = name;
790
791         printf(" %s%s %-15s %s\n",
792                decode ? "D" : " ",
793                encode ? "E" : " ",
794                name,
795             long_name ? long_name:" ");
796     }
797     return 0;
798 }
799
800 static char get_media_type_char(enum AVMediaType type)
801 {
802     static const char map[AVMEDIA_TYPE_NB] = {
803         [AVMEDIA_TYPE_VIDEO]      = 'V',
804         [AVMEDIA_TYPE_AUDIO]      = 'A',
805         [AVMEDIA_TYPE_DATA]       = 'D',
806         [AVMEDIA_TYPE_SUBTITLE]   = 'S',
807         [AVMEDIA_TYPE_ATTACHMENT] = 'T',
808     };
809     return type >= 0 && type < AVMEDIA_TYPE_NB && map[type] ? map[type] : '?';
810 }
811
812 int opt_codecs(const char *opt, const char *arg)
813 {
814     AVCodec *p = NULL, *p2;
815     const char *last_name;
816     printf("Codecs:\n"
817            " D....... = Decoding supported\n"
818            " .E...... = Encoding supported\n"
819            " ..V..... = Video codec\n"
820            " ..A..... = Audio codec\n"
821            " ..S..... = Subtitle codec\n"
822            " ...S.... = Supports draw_horiz_band\n"
823            " ....D... = Supports direct rendering method 1\n"
824            " .....T.. = Supports weird frame truncation\n"
825            " ......F. = Supports frame-based multi-threaded decoding\n"
826            " ......S. = Supports slice-based multi-threaded decoding\n"
827            " ......B. = Supports both frame-based and slice-based multi-threaded decoding\n"
828            " .......F = Supports frame-based multi-threaded encoding\n"
829            " .......S = Supports slice-based multi-threaded encoding\n"
830            " .......B = Supports both frame-based and slice-based multi-threaded encoding\n"
831            " --------\n");
832     last_name= "000";
833     for (;;) {
834         int decode = 0;
835         int encode = 0;
836         int cap    = 0;
837
838         p2 = NULL;
839         while ((p = av_codec_next(p))) {
840             if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
841                 strcmp(p->name, last_name) > 0) {
842                 p2 = p;
843                 decode = encode = cap = 0;
844             }
845             if (p2 && strcmp(p->name, p2->name) == 0) {
846                 if (av_codec_is_decoder(p))
847                     decode = 1;
848                 if (av_codec_is_encoder(p))
849                     encode = 1;
850                 cap |= p->capabilities;
851             }
852         }
853         if (p2 == NULL)
854             break;
855         last_name = p2->name;
856
857         printf(" %s%s%c%s%s%s%s%s %-15s %s",
858                decode ? "D" : (/* p2->decoder ? "d" : */ " "),
859                encode ? "E" : " ",
860                get_media_type_char(p2->type),
861                cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
862                cap & CODEC_CAP_DR1 ? "D" : " ",
863                cap & CODEC_CAP_TRUNCATED ? "T" : " ",
864                decode ?
865                cap & CODEC_CAP_FRAME_THREADS ? cap & CODEC_CAP_SLICE_THREADS ? "B" : "F" :
866                                                cap & CODEC_CAP_SLICE_THREADS ? "S" : " "
867                : " ",
868                encode ?
869                cap & CODEC_CAP_FRAME_THREADS ? cap & CODEC_CAP_SLICE_THREADS ? "B" : "F" :
870                                                cap & CODEC_CAP_SLICE_THREADS ? "S" : " "
871                : " ",
872                p2->name,
873                p2->long_name ? p2->long_name : "");
874 #if 0
875             if (p2->decoder && decode == 0)
876                 printf(" use %s for decoding", p2->decoder->name);
877 #endif
878         printf("\n");
879     }
880     printf("\n");
881     printf("Note, the names of encoders and decoders do not always match, so there are\n"
882            "several cases where the above table shows encoder only or decoder only entries\n"
883            "even though both encoding and decoding are supported. For example, the h263\n"
884            "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
885            "worse.\n");
886     return 0;
887 }
888
889 int opt_bsfs(const char *opt, const char *arg)
890 {
891     AVBitStreamFilter *bsf = NULL;
892
893     printf("Bitstream filters:\n");
894     while ((bsf = av_bitstream_filter_next(bsf)))
895         printf("%s\n", bsf->name);
896     printf("\n");
897     return 0;
898 }
899
900 int opt_protocols(const char *opt, const char *arg)
901 {
902     void *opaque = NULL;
903     const char *name;
904
905     printf("Supported file protocols:\n"
906            "Input:\n");
907     while ((name = avio_enum_protocols(&opaque, 0)))
908         printf("%s\n", name);
909     printf("Output:\n");
910     while ((name = avio_enum_protocols(&opaque, 1)))
911         printf("%s\n", name);
912     return 0;
913 }
914
915 int opt_filters(const char *opt, const char *arg)
916 {
917     AVFilter av_unused(**filter) = NULL;
918     char descr[64], *descr_cur;
919     int i, j;
920     const AVFilterPad *pad;
921
922     printf("Filters:\n");
923 #if CONFIG_AVFILTER
924     while ((filter = av_filter_next(filter)) && *filter) {
925         descr_cur = descr;
926         for (i = 0; i < 2; i++) {
927             if (i) {
928                 *(descr_cur++) = '-';
929                 *(descr_cur++) = '>';
930             }
931             pad = i ? (*filter)->outputs : (*filter)->inputs;
932             for (j = 0; pad[j].name; j++) {
933                 if (descr_cur >= descr + sizeof(descr) - 4)
934                     break;
935                 *(descr_cur++) = get_media_type_char(pad[j].type);
936             }
937             if (!j)
938                 *(descr_cur++) = '|';
939         }
940         *descr_cur = 0;
941         printf("%-16s %-10s %s\n", (*filter)->name, descr, (*filter)->description);
942     }
943 #endif
944     return 0;
945 }
946
947 int opt_pix_fmts(const char *opt, const char *arg)
948 {
949     enum PixelFormat pix_fmt;
950
951     printf("Pixel formats:\n"
952            "I.... = Supported Input  format for conversion\n"
953            ".O... = Supported Output format for conversion\n"
954            "..H.. = Hardware accelerated format\n"
955            "...P. = Paletted format\n"
956            "....B = Bitstream format\n"
957            "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
958            "-----\n");
959
960 #if !CONFIG_SWSCALE
961 #   define sws_isSupportedInput(x)  0
962 #   define sws_isSupportedOutput(x) 0
963 #endif
964
965     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
966         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
967         if(!pix_desc->name)
968             continue;
969         printf("%c%c%c%c%c %-16s       %d            %2d\n",
970                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
971                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
972                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
973                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
974                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
975                pix_desc->name,
976                pix_desc->nb_components,
977                av_get_bits_per_pixel(pix_desc));
978     }
979     return 0;
980 }
981
982 int show_sample_fmts(const char *opt, const char *arg)
983 {
984     int i;
985     char fmt_str[128];
986     for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
987         printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
988     return 0;
989 }
990
991 int read_yesno(void)
992 {
993     int c = getchar();
994     int yesno = (toupper(c) == 'Y');
995
996     while (c != '\n' && c != EOF)
997         c = getchar();
998
999     return yesno;
1000 }
1001
1002 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
1003 {
1004     int ret;
1005     FILE *f = fopen(filename, "rb");
1006
1007     if (!f) {
1008         av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
1009                strerror(errno));
1010         return AVERROR(errno);
1011     }
1012     fseek(f, 0, SEEK_END);
1013     *size = ftell(f);
1014     fseek(f, 0, SEEK_SET);
1015     *bufptr = av_malloc(*size + 1);
1016     if (!*bufptr) {
1017         av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
1018         fclose(f);
1019         return AVERROR(ENOMEM);
1020     }
1021     ret = fread(*bufptr, 1, *size, f);
1022     if (ret < *size) {
1023         av_free(*bufptr);
1024         if (ferror(f)) {
1025             av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1026                    filename, strerror(errno));
1027             ret = AVERROR(errno);
1028         } else
1029             ret = AVERROR_EOF;
1030     } else {
1031         ret = 0;
1032         (*bufptr)[*size++] = '\0';
1033     }
1034
1035     fclose(f);
1036     return ret;
1037 }
1038
1039 FILE *get_preset_file(char *filename, size_t filename_size,
1040                       const char *preset_name, int is_path,
1041                       const char *codec_name)
1042 {
1043     FILE *f = NULL;
1044     int i;
1045     const char *base[3] = { getenv("FFMPEG_DATADIR"),
1046                             getenv("HOME"),
1047                             FFMPEG_DATADIR, };
1048
1049     if (is_path) {
1050         av_strlcpy(filename, preset_name, filename_size);
1051         f = fopen(filename, "r");
1052     } else {
1053 #ifdef _WIN32
1054         char datadir[MAX_PATH], *ls;
1055         base[2] = NULL;
1056
1057         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1058         {
1059             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1060                 if (*ls == '\\') *ls = '/';
1061
1062             if (ls = strrchr(datadir, '/'))
1063             {
1064                 *ls = 0;
1065                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
1066                 base[2] = datadir;
1067             }
1068         }
1069 #endif
1070         for (i = 0; i < 3 && !f; i++) {
1071             if (!base[i])
1072                 continue;
1073             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1074                      i != 1 ? "" : "/.ffmpeg", preset_name);
1075             f = fopen(filename, "r");
1076             if (!f && codec_name) {
1077                 snprintf(filename, filename_size,
1078                          "%s%s/%s-%s.ffpreset",
1079                          base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1080                          preset_name);
1081                 f = fopen(filename, "r");
1082             }
1083         }
1084     }
1085
1086     return f;
1087 }
1088
1089 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1090 {
1091     if (*spec <= '9' && *spec >= '0') /* opt:index */
1092         return strtol(spec, NULL, 0) == st->index;
1093     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
1094              *spec == 't') { /* opt:[vasdt] */
1095         enum AVMediaType type;
1096
1097         switch (*spec++) {
1098         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
1099         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
1100         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
1101         case 'd': type = AVMEDIA_TYPE_DATA;       break;
1102         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
1103         default:  av_assert0(0);
1104         }
1105         if (type != st->codec->codec_type)
1106             return 0;
1107         if (*spec++ == ':') { /* possibly followed by :index */
1108             int i, index = strtol(spec, NULL, 0);
1109             for (i = 0; i < s->nb_streams; i++)
1110                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
1111                    return i == st->index;
1112             return 0;
1113         }
1114         return 1;
1115     } else if (*spec == 'p' && *(spec + 1) == ':') {
1116         int prog_id, i, j;
1117         char *endptr;
1118         spec += 2;
1119         prog_id = strtol(spec, &endptr, 0);
1120         for (i = 0; i < s->nb_programs; i++) {
1121             if (s->programs[i]->id != prog_id)
1122                 continue;
1123
1124             if (*endptr++ == ':') {
1125                 int stream_idx = strtol(endptr, NULL, 0);
1126                 return stream_idx >= 0 &&
1127                     stream_idx < s->programs[i]->nb_stream_indexes &&
1128                     st->index == s->programs[i]->stream_index[stream_idx];
1129             }
1130
1131             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
1132                 if (st->index == s->programs[i]->stream_index[j])
1133                     return 1;
1134         }
1135         return 0;
1136     } else if (*spec == '#') {
1137         int sid;
1138         char *endptr;
1139         sid = strtol(spec + 1, &endptr, 0);
1140         if (!*endptr)
1141             return st->id == sid;
1142     } else if (!*spec) /* empty specifier, matches everything */
1143         return 1;
1144
1145     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1146     return AVERROR(EINVAL);
1147 }
1148
1149 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
1150                                 AVFormatContext *s, AVStream *st, AVCodec *codec)
1151 {
1152     AVDictionary    *ret = NULL;
1153     AVDictionaryEntry *t = NULL;
1154     int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1155                                       : AV_OPT_FLAG_DECODING_PARAM;
1156     char          prefix = 0;
1157     const AVClass    *cc = avcodec_get_class();
1158
1159     if (!codec)
1160         codec            = s->oformat ? avcodec_find_encoder(codec_id)
1161                                       : avcodec_find_decoder(codec_id);
1162     if (!codec)
1163         return NULL;
1164
1165     switch (codec->type) {
1166     case AVMEDIA_TYPE_VIDEO:
1167         prefix  = 'v';
1168         flags  |= AV_OPT_FLAG_VIDEO_PARAM;
1169         break;
1170     case AVMEDIA_TYPE_AUDIO:
1171         prefix  = 'a';
1172         flags  |= AV_OPT_FLAG_AUDIO_PARAM;
1173         break;
1174     case AVMEDIA_TYPE_SUBTITLE:
1175         prefix  = 's';
1176         flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
1177         break;
1178     }
1179
1180     while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1181         char *p = strchr(t->key, ':');
1182
1183         /* check stream specification in opt name */
1184         if (p)
1185             switch (check_stream_specifier(s, st, p + 1)) {
1186             case  1: *p = 0; break;
1187             case  0:         continue;
1188             default:         return NULL;
1189             }
1190
1191         if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1192             (codec && codec->priv_class &&
1193              av_opt_find(&codec->priv_class, t->key, NULL, flags,
1194                          AV_OPT_SEARCH_FAKE_OBJ)))
1195             av_dict_set(&ret, t->key, t->value, 0);
1196         else if (t->key[0] == prefix &&
1197                  av_opt_find(&cc, t->key + 1, NULL, flags,
1198                              AV_OPT_SEARCH_FAKE_OBJ))
1199             av_dict_set(&ret, t->key + 1, t->value, 0);
1200
1201         if (p)
1202             *p = ':';
1203     }
1204     return ret;
1205 }
1206
1207 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1208                                            AVDictionary *codec_opts)
1209 {
1210     int i;
1211     AVDictionary **opts;
1212
1213     if (!s->nb_streams)
1214         return NULL;
1215     opts = av_mallocz(s->nb_streams * sizeof(*opts));
1216     if (!opts) {
1217         av_log(NULL, AV_LOG_ERROR,
1218                "Could not alloc memory for stream options.\n");
1219         return NULL;
1220     }
1221     for (i = 0; i < s->nb_streams; i++)
1222         opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1223                                     s, s->streams[i], NULL);
1224     return opts;
1225 }
1226
1227 void *grow_array(void *array, int elem_size, int *size, int new_size)
1228 {
1229     if (new_size >= INT_MAX / elem_size) {
1230         av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1231         exit_program(1);
1232     }
1233     if (*size < new_size) {
1234         uint8_t *tmp = av_realloc(array, new_size*elem_size);
1235         if (!tmp) {
1236             av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1237             exit_program(1);
1238         }
1239         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1240         *size = new_size;
1241         return tmp;
1242     }
1243     return array;
1244 }
1245
1246 static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1247 {
1248     FrameBuffer  *buf = av_mallocz(sizeof(*buf));
1249     int i, ret;
1250     const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1251     int h_chroma_shift, v_chroma_shift;
1252     int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1253     int w = s->width, h = s->height;
1254
1255     if (!buf)
1256         return AVERROR(ENOMEM);
1257
1258     avcodec_align_dimensions(s, &w, &h);
1259
1260     if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1261         w += 2*edge;
1262         h += 2*edge;
1263     }
1264
1265     if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1266                               s->pix_fmt, 32)) < 0) {
1267         av_freep(&buf);
1268         av_log(s, AV_LOG_ERROR, "alloc_buffer: av_image_alloc() failed\n");
1269         return ret;
1270     }
1271     /* XXX this shouldn't be needed, but some tests break without this line
1272      * those decoders are buggy and need to be fixed.
1273      * the following tests fail:
1274      * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1275      */
1276     memset(buf->base[0], 128, ret);
1277
1278     avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1279     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1280         const int h_shift = i==0 ? 0 : h_chroma_shift;
1281         const int v_shift = i==0 ? 0 : v_chroma_shift;
1282         if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
1283             buf->data[i] = buf->base[i];
1284         else
1285             buf->data[i] = buf->base[i] +
1286                            FFALIGN((buf->linesize[i]*edge >> v_shift) +
1287                                    (pixel_size*edge >> h_shift), 32);
1288     }
1289     buf->w       = s->width;
1290     buf->h       = s->height;
1291     buf->pix_fmt = s->pix_fmt;
1292     buf->pool    = pool;
1293
1294     *pbuf = buf;
1295     return 0;
1296 }
1297
1298 int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1299 {
1300     FrameBuffer **pool = s->opaque;
1301     FrameBuffer *buf;
1302     int ret, i;
1303
1304     if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0) {
1305         av_log(s, AV_LOG_ERROR, "codec_get_buffer: image parameters invalid\n");
1306         return -1;
1307     }
1308
1309     if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1310         return ret;
1311
1312     buf              = *pool;
1313     *pool            = buf->next;
1314     buf->next        = NULL;
1315     if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1316         av_freep(&buf->base[0]);
1317         av_free(buf);
1318         if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1319             return ret;
1320     }
1321     av_assert0(!buf->refcount);
1322     buf->refcount++;
1323
1324     frame->opaque        = buf;
1325     frame->type          = FF_BUFFER_TYPE_USER;
1326     frame->extended_data = frame->data;
1327     frame->pkt_pts       = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1328     frame->width         = buf->w;
1329     frame->height        = buf->h;
1330     frame->format        = buf->pix_fmt;
1331     frame->sample_aspect_ratio = s->sample_aspect_ratio;
1332
1333     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1334         frame->base[i]     = buf->base[i];  // XXX h264.c uses base though it shouldn't
1335         frame->data[i]     = buf->data[i];
1336         frame->linesize[i] = buf->linesize[i];
1337     }
1338
1339     return 0;
1340 }
1341
1342 static void unref_buffer(FrameBuffer *buf)
1343 {
1344     FrameBuffer **pool = buf->pool;
1345
1346     av_assert0(buf->refcount > 0);
1347     buf->refcount--;
1348     if (!buf->refcount) {
1349         FrameBuffer *tmp;
1350         for(tmp= *pool; tmp; tmp= tmp->next)
1351             av_assert1(tmp != buf);
1352
1353         buf->next = *pool;
1354         *pool = buf;
1355     }
1356 }
1357
1358 void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1359 {
1360     FrameBuffer *buf = frame->opaque;
1361     int i;
1362
1363     if(frame->type!=FF_BUFFER_TYPE_USER) {
1364         avcodec_default_release_buffer(s, frame);
1365         return;
1366     }
1367
1368     for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1369         frame->data[i] = NULL;
1370
1371     unref_buffer(buf);
1372 }
1373
1374 void filter_release_buffer(AVFilterBuffer *fb)
1375 {
1376     FrameBuffer *buf = fb->priv;
1377     av_free(fb);
1378     unref_buffer(buf);
1379 }
1380
1381 void free_buffer_pool(FrameBuffer **pool)
1382 {
1383     FrameBuffer *buf = *pool;
1384     while (buf) {
1385         *pool = buf->next;
1386         av_freep(&buf->base[0]);
1387         av_free(buf);
1388         buf = *pool;
1389     }
1390 }