jack: update to new latency range API as the old one has been deprecated
[libav.git] / cmdutils.c
CommitLineData
01310af2
FB
1/*
2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
01310af2
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
01310af2 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
01310af2
FB
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
01310af2 20 */
364a9607 21
0f4e8165
RB
22#include <string.h>
23#include <stdlib.h>
24#include <errno.h>
7c84b8bc 25#include <math.h>
0f4e8165 26
2cd39dbf
DP
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
63d026b1 31#include "config.h"
245976da
DB
32#include "libavformat/avformat.h"
33#include "libavfilter/avfilter.h"
34#include "libavdevice/avdevice.h"
bcb82fe1 35#include "libavresample/avresample.h"
db6d50c7 36#include "libswscale/swscale.h"
7cf78b34 37#include "libavutil/avassert.h"
245976da 38#include "libavutil/avstring.h"
85770d6e 39#include "libavutil/mathematics.h"
d55c2e05 40#include "libavutil/imgutils.h"
f6c7375a 41#include "libavutil/parseutils.h"
9cb5c760 42#include "libavutil/pixdesc.h"
25e25617 43#include "libavutil/eval.h"
9ba38229 44#include "libavutil/dict.h"
41d0eb1c 45#include "libavutil/opt.h"
01310af2 46#include "cmdutils.h"
86074ed1 47#include "version.h"
da2dc39e 48#if CONFIG_NETWORK
245976da 49#include "libavformat/network.h"
da2dc39e 50#endif
ffcc6e24
MR
51#if HAVE_SYS_RESOURCE_H
52#include <sys/resource.h>
53#endif
01310af2 54
85663ef3 55struct SwsContext *sws_opts;
8c8eab8b 56AVDictionary *format_opts, *codec_opts;
086ab001 57
21d0d1d6 58static const int this_year = 2012;
ef4c0bb1 59
a5c33faa
RD
60void init_opts(void)
61{
be4876ea 62#if CONFIG_SWSCALE
cbaef7d1
AD
63 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
64 NULL, NULL, NULL);
be4876ea 65#endif
a5c33faa
RD
66}
67
68void uninit_opts(void)
69{
be4876ea 70#if CONFIG_SWSCALE
faf8d3dd
RB
71 sws_freeContext(sws_opts);
72 sws_opts = NULL;
be4876ea 73#endif
9ba38229 74 av_dict_free(&format_opts);
8c8eab8b 75 av_dict_free(&codec_opts);
a5c33faa
RD
76}
77
cbaef7d1 78void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
1790d3b3
SS
79{
80 vfprintf(stdout, fmt, vl);
81}
82
cbaef7d1
AD
83double parse_number_or_die(const char *context, const char *numstr, int type,
84 double min, double max)
086ab001
MN
85{
86 char *tail;
87 const char *error;
25e25617 88 double d = av_strtod(numstr, &tail);
086ab001 89 if (*tail)
cbaef7d1 90 error = "Expected number for %s but found: %s\n";
086ab001 91 else if (d < min || d > max)
cbaef7d1
AD
92 error = "The value for %s was %s which is not within %f - %f\n";
93 else if (type == OPT_INT64 && (int64_t)d != d)
94 error = "Expected int64 for %s but found %s\n";
3372ec32 95 else if (type == OPT_INT && (int)d != d)
cbaef7d1 96 error = "Expected int for %s but found %s\n";
086ab001
MN
97 else
98 return d;
1c5e9551 99 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
dad09ff9
AK
100 exit_program(1);
101 return 0;
086ab001
MN
102}
103
cbaef7d1
AD
104int64_t parse_time_or_die(const char *context, const char *timestr,
105 int is_duration)
7542157d 106{
f6c7375a
SS
107 int64_t us;
108 if (av_parse_time(&us, timestr, is_duration) < 0) {
1c5e9551
AK
109 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
110 is_duration ? "duration" : "date", context, timestr);
dad09ff9 111 exit_program(1);
7542157d
SS
112 }
113 return us;
114}
115
cbaef7d1
AD
116void show_help_options(const OptionDef *options, const char *msg, int mask,
117 int value)
01310af2
FB
118{
119 const OptionDef *po;
02d504a7 120 int first;
01310af2 121
02d504a7 122 first = 1;
cbaef7d1 123 for (po = options; po->name != NULL; po++) {
02d504a7
FB
124 char buf[64];
125 if ((po->flags & mask) == value) {
126 if (first) {
127 printf("%s", msg);
128 first = 0;
129 }
f7d78f36 130 av_strlcpy(buf, po->name, sizeof(buf));
02d504a7 131 if (po->flags & HAS_ARG) {
f7d78f36
MR
132 av_strlcat(buf, " ", sizeof(buf));
133 av_strlcat(buf, po->argname, sizeof(buf));
01310af2 134 }
02d504a7 135 printf("-%-17s %s\n", buf, po->help);
01310af2
FB
136 }
137 }
138}
139
7a6cd995
AK
140void show_help_children(const AVClass *class, int flags)
141{
142 const AVClass *child = NULL;
143 av_opt_show2(&class, NULL, flags, 0);
144 printf("\n");
145
146 while (child = av_opt_child_class_next(class, child))
147 show_help_children(child, flags);
148}
149
cbaef7d1
AD
150static const OptionDef *find_option(const OptionDef *po, const char *name)
151{
d70e5122
AK
152 const char *p = strchr(name, ':');
153 int len = p ? p - name : strlen(name);
154
8bbf6db9 155 while (po->name != NULL) {
d70e5122 156 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
8bbf6db9
MN
157 break;
158 po++;
159 }
160 return po;
161}
162
b1ac139d 163#if defined(_WIN32) && !defined(__MINGW32CE__)
ba9327ea 164#include <windows.h>
b1ac139d
KG
165/* Will be leaked on exit */
166static char** win32_argv_utf8 = NULL;
167static int win32_argc = 0;
168
169/**
170 * Prepare command line arguments for executable.
171 * For Windows - perform wide-char to UTF-8 conversion.
172 * Input arguments should be main() function arguments.
173 * @param argc_ptr Arguments number (including executable)
174 * @param argv_ptr Arguments list.
175 */
176static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
177{
178 char *argstr_flat;
179 wchar_t **argv_w;
180 int i, buffsize = 0, offset = 0;
181
182 if (win32_argv_utf8) {
183 *argc_ptr = win32_argc;
184 *argv_ptr = win32_argv_utf8;
185 return;
186 }
187
188 win32_argc = 0;
189 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
190 if (win32_argc <= 0 || !argv_w)
191 return;
192
193 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
194 for (i = 0; i < win32_argc; i++)
195 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
196 NULL, 0, NULL, NULL);
197
cbaef7d1
AD
198 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
199 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
b1ac139d
KG
200 if (win32_argv_utf8 == NULL) {
201 LocalFree(argv_w);
202 return;
203 }
204
205 for (i = 0; i < win32_argc; i++) {
206 win32_argv_utf8[i] = &argstr_flat[offset];
207 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
208 &argstr_flat[offset],
209 buffsize - offset, NULL, NULL);
210 }
211 win32_argv_utf8[i] = NULL;
212 LocalFree(argv_w);
213
214 *argc_ptr = win32_argc;
215 *argv_ptr = win32_argv_utf8;
216}
217#else
218static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
219{
220 /* nothing to do */
221}
222#endif /* WIN32 && !__MINGW32CE__ */
223
cbaef7d1
AD
224int parse_option(void *optctx, const char *opt, const char *arg,
225 const OptionDef *options)
2f8e586d
AK
226{
227 const OptionDef *po;
228 int bool_val = 1;
6361c5e1 229 int *dstcount;
2f8e586d
AK
230 void *dst;
231
232 po = find_option(options, opt);
233 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
234 /* handle 'no' bool option */
235 po = find_option(options, opt + 2);
570f6aaa
AK
236 if ((po->name && (po->flags & OPT_BOOL)))
237 bool_val = 0;
2f8e586d
AK
238 }
239 if (!po->name)
240 po = find_option(options, "default");
241 if (!po->name) {
2f8e586d
AK
242 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
243 return AVERROR(EINVAL);
244 }
245 if (po->flags & HAS_ARG && !arg) {
246 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
247 return AVERROR(EINVAL);
248 }
249
250 /* new-style options contain an offset into optctx, old-style address of
251 * a global var*/
cbaef7d1
AD
252 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
253 : po->u.dst_ptr;
6361c5e1
AK
254
255 if (po->flags & OPT_SPEC) {
256 SpecifierOpt **so = dst;
257 char *p = strchr(opt, ':');
258
cbaef7d1 259 dstcount = (int *)(so + 1);
6361c5e1
AK
260 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
261 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
262 dst = &(*so)[*dstcount - 1].u;
263 }
2f8e586d
AK
264
265 if (po->flags & OPT_STRING) {
266 char *str;
267 str = av_strdup(arg);
cbaef7d1 268 *(char **)dst = str;
2f8e586d 269 } else if (po->flags & OPT_BOOL) {
cbaef7d1 270 *(int *)dst = bool_val;
2f8e586d 271 } else if (po->flags & OPT_INT) {
cbaef7d1 272 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2f8e586d 273 } else if (po->flags & OPT_INT64) {
cbaef7d1 274 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
6b779ccc 275 } else if (po->flags & OPT_TIME) {
cbaef7d1 276 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
2f8e586d 277 } else if (po->flags & OPT_FLOAT) {
cbaef7d1 278 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
33f75d72 279 } else if (po->flags & OPT_DOUBLE) {
cbaef7d1 280 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
2f8e586d 281 } else if (po->u.func_arg) {
cbaef7d1
AD
282 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
283 : po->u.func_arg(opt, arg);
2f8e586d 284 if (ret < 0) {
cbaef7d1
AD
285 av_log(NULL, AV_LOG_ERROR,
286 "Failed to set value '%s' for option '%s'\n", arg, opt);
2f8e586d
AK
287 return ret;
288 }
289 }
290 if (po->flags & OPT_EXIT)
291 exit_program(0);
292 return !!(po->flags & HAS_ARG);
293}
294
7cc8d638 295void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
cbaef7d1 296 void (*parse_arg_function)(void *, const char*))
01310af2 297{
2f8e586d
AK
298 const char *opt;
299 int optindex, handleoptions = 1, ret;
01310af2 300
b1ac139d
KG
301 /* perform system-dependent conversions for arguments list */
302 prepare_app_arguments(&argc, &argv);
303
01310af2
FB
304 /* parse options */
305 optindex = 1;
306 while (optindex < argc) {
307 opt = argv[optindex++];
115329f1 308
84bf226b 309 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
3749076c
SS
310 if (opt[1] == '-' && opt[2] == '\0') {
311 handleoptions = 0;
312 continue;
313 }
c3c78324 314 opt++;
2f8e586d
AK
315
316 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
dad09ff9 317 exit_program(1);
2f8e586d 318 optindex += ret;
01310af2 319 } else {
60a9966e 320 if (parse_arg_function)
7cc8d638 321 parse_arg_function(optctx, opt);
01310af2
FB
322 }
323 }
324}
325
4138cd29
AK
326int locate_option(int argc, char **argv, const OptionDef *options,
327 const char *optname)
182cbe43
AK
328{
329 const OptionDef *po;
330 int i;
331
332 for (i = 1; i < argc; i++) {
333 const char *cur_opt = argv[i];
334
335 if (*cur_opt++ != '-')
336 continue;
337
338 po = find_option(options, cur_opt);
339 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
340 po = find_option(options, cur_opt + 2);
341
342 if ((!po->name && !strcmp(cur_opt, optname)) ||
343 (po->name && !strcmp(optname, po->name)))
344 return i;
345
346 if (!po || po->flags & HAS_ARG)
347 i++;
348 }
349 return 0;
350}
351
352void parse_loglevel(int argc, char **argv, const OptionDef *options)
353{
354 int idx = locate_option(argc, argv, options, "loglevel");
8124d8ad
MR
355 if (!idx)
356 idx = locate_option(argc, argv, options, "v");
182cbe43
AK
357 if (idx && argv[idx + 1])
358 opt_loglevel("loglevel", argv[idx + 1]);
359}
360
145f741e 361#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
35d2e4e5 362int opt_default(const char *opt, const char *arg)
9ba38229
AK
363{
364 const AVOption *o;
d4863fc1
AK
365 char opt_stripped[128];
366 const char *p;
20c21f8b 367 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
d4863fc1
AK
368
369 if (!(p = strchr(opt, ':')))
370 p = opt + strlen(opt);
371 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
372
cbaef7d1
AD
373 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
374 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
375 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
376 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
8c8eab8b 377 av_dict_set(&codec_opts, opt, arg, FLAGS);
cbaef7d1
AD
378 else if ((o = av_opt_find(&fc, opt, NULL, 0,
379 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
9ba38229 380 av_dict_set(&format_opts, opt, arg, FLAGS);
cbaef7d1
AD
381 else if ((o = av_opt_find(&sc, opt, NULL, 0,
382 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
9ba38229 383 // XXX we only support sws_flags, not arbitrary sws options
3b3ea346 384 int ret = av_opt_set(sws_opts, opt, arg, 0);
9ba38229
AK
385 if (ret < 0) {
386 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
387 return ret;
388 }
389 }
390
9ba38229
AK
391 if (o)
392 return 0;
1c5e9551 393 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
9ba38229
AK
394 return AVERROR_OPTION_NOT_FOUND;
395}
396
4c97a6fa
SS
397int opt_loglevel(const char *opt, const char *arg)
398{
da4c2dab 399 const struct { const char *name; int level; } log_levels[] = {
4c97a6fa
SS
400 { "quiet" , AV_LOG_QUIET },
401 { "panic" , AV_LOG_PANIC },
402 { "fatal" , AV_LOG_FATAL },
403 { "error" , AV_LOG_ERROR },
404 { "warning", AV_LOG_WARNING },
405 { "info" , AV_LOG_INFO },
406 { "verbose", AV_LOG_VERBOSE },
407 { "debug" , AV_LOG_DEBUG },
408 };
409 char *tail;
410 int level;
411 int i;
412
413 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
414 if (!strcmp(log_levels[i].name, arg)) {
415 av_log_set_level(log_levels[i].level);
416 return 0;
417 }
418 }
419
420 level = strtol(arg, &tail, 10);
421 if (*tail) {
1c5e9551
AK
422 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
423 "Possible levels are numbers or:\n", arg);
4c97a6fa 424 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1c5e9551 425 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
dad09ff9 426 exit_program(1);
4c97a6fa
SS
427 }
428 av_log_set_level(level);
429 return 0;
430}
431
ffcc6e24
MR
432int opt_timelimit(const char *opt, const char *arg)
433{
0104b608 434#if HAVE_SETRLIMIT
ffcc6e24
MR
435 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
436 struct rlimit rl = { lim, lim + 1 };
437 if (setrlimit(RLIMIT_CPU, &rl))
438 perror("setrlimit");
439#else
1c5e9551 440 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
ffcc6e24
MR
441#endif
442 return 0;
443}
444
01310af2
FB
445void print_error(const char *filename, int err)
446{
7a5bdd79 447 char errbuf[128];
735ef67b 448 const char *errbuf_ptr = errbuf;
7a5bdd79 449
9e94bd3e
SS
450 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
451 errbuf_ptr = strerror(AVUNERROR(err));
1c5e9551 452 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
01310af2 453}
f35917b2 454
d101e731
SS
455static int warned_cfg = 0;
456
208749a0
SS
457#define INDENT 1
458#define SHOW_VERSION 2
d101e731 459#define SHOW_CONFIG 4
208749a0 460
1c5e9551 461#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
5116571d 462 if (CONFIG_##LIBNAME) { \
65dd2ded 463 const char *indent = flags & INDENT? " " : ""; \
208749a0 464 if (flags & SHOW_VERSION) { \
b6525b4b 465 unsigned int version = libname##_version(); \
bcb82fe1
JR
466 av_log(NULL, level, \
467 "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n", \
1c5e9551
AK
468 indent, #libname, \
469 LIB##LIBNAME##_VERSION_MAJOR, \
470 LIB##LIBNAME##_VERSION_MINOR, \
471 LIB##LIBNAME##_VERSION_MICRO, \
472 version >> 16, version >> 8 & 0xff, version & 0xff); \
208749a0 473 } \
d101e731
SS
474 if (flags & SHOW_CONFIG) { \
475 const char *cfg = libname##_configuration(); \
29ba0911 476 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
d101e731 477 if (!warned_cfg) { \
1c5e9551 478 av_log(NULL, level, \
d101e731 479 "%sWARNING: library configuration mismatch\n", \
65dd2ded 480 indent); \
d101e731
SS
481 warned_cfg = 1; \
482 } \
1c5e9551 483 av_log(NULL, level, "%s%-11s configuration: %s\n", \
65dd2ded 484 indent, #libname, cfg); \
d101e731
SS
485 } \
486 } \
208749a0 487 } \
9a109272 488
1c5e9551 489static void print_all_libs_info(int flags, int level)
9a109272 490{
1c5e9551
AK
491 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
492 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
493 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
494 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
495 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
bcb82fe1 496 PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
1c5e9551 497 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
9a109272
SS
498}
499
ea9c581f 500void show_banner(void)
86074ed1 501{
cbaef7d1
AD
502 av_log(NULL, AV_LOG_INFO,
503 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
1c5e9551
AK
504 program_name, program_birth_year, this_year);
505 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
506 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
507 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
508 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
509 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
86074ed1
SS
510}
511
64555bd9 512void show_version(void) {
1c5e9551 513 av_log_set_callback(log_callback_help);
a03be6e1 514 printf("%s " LIBAV_VERSION "\n", program_name);
1c5e9551 515 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
86074ed1
SS
516}
517
f35917b2
SS
518void show_license(void)
519{
7ead693b 520 printf(
3bf28f9d 521#if CONFIG_NONFREE
304ba23a
SS
522 "This version of %s has nonfree parts compiled in.\n"
523 "Therefore it is not legally redistributable.\n",
524 program_name
9cad0e4e
DB
525#elif CONFIG_GPLV3
526 "%s is free software; you can redistribute it and/or modify\n"
527 "it under the terms of the GNU General Public License as published by\n"
528 "the Free Software Foundation; either version 3 of the License, or\n"
529 "(at your option) any later version.\n"
530 "\n"
531 "%s is distributed in the hope that it will be useful,\n"
532 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
533 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
534 "GNU General Public License for more details.\n"
535 "\n"
536 "You should have received a copy of the GNU General Public License\n"
537 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
538 program_name, program_name, program_name
7ead693b 539#elif CONFIG_GPL
304ba23a 540 "%s is free software; you can redistribute it and/or modify\n"
f35917b2
SS
541 "it under the terms of the GNU General Public License as published by\n"
542 "the Free Software Foundation; either version 2 of the License, or\n"
543 "(at your option) any later version.\n"
544 "\n"
304ba23a 545 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
546 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
547 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
548 "GNU General Public License for more details.\n"
549 "\n"
550 "You should have received a copy of the GNU General Public License\n"
304ba23a
SS
551 "along with %s; if not, write to the Free Software\n"
552 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
553 program_name, program_name, program_name
9cad0e4e
DB
554#elif CONFIG_LGPLV3
555 "%s is free software; you can redistribute it and/or modify\n"
556 "it under the terms of the GNU Lesser General Public License as published by\n"
557 "the Free Software Foundation; either version 3 of the License, or\n"
558 "(at your option) any later version.\n"
559 "\n"
560 "%s is distributed in the hope that it will be useful,\n"
561 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
562 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
563 "GNU Lesser General Public License for more details.\n"
564 "\n"
565 "You should have received a copy of the GNU Lesser General Public License\n"
566 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
567 program_name, program_name, program_name
f35917b2 568#else
304ba23a 569 "%s is free software; you can redistribute it and/or\n"
f35917b2
SS
570 "modify it under the terms of the GNU Lesser General Public\n"
571 "License as published by the Free Software Foundation; either\n"
572 "version 2.1 of the License, or (at your option) any later version.\n"
573 "\n"
304ba23a 574 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
575 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
576 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
577 "Lesser General Public License for more details.\n"
578 "\n"
579 "You should have received a copy of the GNU Lesser General Public\n"
304ba23a
SS
580 "License along with %s; if not, write to the Free Software\n"
581 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
582 program_name, program_name, program_name
f35917b2 583#endif
3bf28f9d 584 );
f35917b2 585}
ba9880c1
SS
586
587void show_formats(void)
588{
cbaef7d1
AD
589 AVInputFormat *ifmt = NULL;
590 AVOutputFormat *ofmt = NULL;
ba9880c1
SS
591 const char *last_name;
592
cbaef7d1
AD
593 printf("File formats:\n"
594 " D. = Demuxing supported\n"
595 " .E = Muxing supported\n"
596 " --\n");
597 last_name = "000";
598 for (;;) {
599 int decode = 0;
600 int encode = 0;
601 const char *name = NULL;
602 const char *long_name = NULL;
603
604 while ((ofmt = av_oformat_next(ofmt))) {
605 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
606 strcmp(ofmt->name, last_name) > 0) {
607 name = ofmt->name;
608 long_name = ofmt->long_name;
609 encode = 1;
ba9880c1
SS
610 }
611 }
cbaef7d1
AD
612 while ((ifmt = av_iformat_next(ifmt))) {
613 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
614 strcmp(ifmt->name, last_name) > 0) {
615 name = ifmt->name;
616 long_name = ifmt->long_name;
617 encode = 0;
ba9880c1 618 }
cbaef7d1
AD
619 if (name && strcmp(ifmt->name, name) == 0)
620 decode = 1;
ba9880c1 621 }
cbaef7d1 622 if (name == NULL)
ba9880c1 623 break;
cbaef7d1 624 last_name = name;
ba9880c1 625
cbaef7d1
AD
626 printf(" %s%s %-15s %s\n",
627 decode ? "D" : " ",
628 encode ? "E" : " ",
629 name,
ba9880c1
SS
630 long_name ? long_name:" ");
631 }
8447f0bd 632}
ba9880c1 633
8447f0bd
MN
634void show_codecs(void)
635{
cbaef7d1 636 AVCodec *p = NULL, *p2;
8447f0bd 637 const char *last_name;
cbaef7d1
AD
638 printf("Codecs:\n"
639 " D..... = Decoding supported\n"
640 " .E.... = Encoding supported\n"
641 " ..V... = Video codec\n"
642 " ..A... = Audio codec\n"
643 " ..S... = Subtitle codec\n"
644 " ...S.. = Supports draw_horiz_band\n"
645 " ....D. = Supports direct rendering method 1\n"
646 " .....T = Supports weird frame truncation\n"
647 " ------\n");
ba9880c1 648 last_name= "000";
cbaef7d1
AD
649 for (;;) {
650 int decode = 0;
651 int encode = 0;
652 int cap = 0;
ba9880c1
SS
653 const char *type_str;
654
cbaef7d1
AD
655 p2 = NULL;
656 while ((p = av_codec_next(p))) {
657 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
658 strcmp(p->name, last_name) > 0) {
659 p2 = p;
660 decode = encode = cap = 0;
ba9880c1 661 }
cbaef7d1 662 if (p2 && strcmp(p->name, p2->name) == 0) {
3faa141d 663 if (av_codec_is_decoder(p))
cbaef7d1 664 decode = 1;
3faa141d 665 if (av_codec_is_encoder(p))
cbaef7d1 666 encode = 1;
ba9880c1
SS
667 cap |= p->capabilities;
668 }
669 }
cbaef7d1 670 if (p2 == NULL)
ba9880c1 671 break;
cbaef7d1 672 last_name = p2->name;
ba9880c1 673
cbaef7d1 674 switch (p2->type) {
72415b2a 675 case AVMEDIA_TYPE_VIDEO:
ba9880c1
SS
676 type_str = "V";
677 break;
72415b2a 678 case AVMEDIA_TYPE_AUDIO:
ba9880c1
SS
679 type_str = "A";
680 break;
72415b2a 681 case AVMEDIA_TYPE_SUBTITLE:
ba9880c1
SS
682 type_str = "S";
683 break;
684 default:
685 type_str = "?";
686 break;
687 }
cbaef7d1
AD
688 printf(" %s%s%s%s%s%s %-15s %s",
689 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
690 encode ? "E" : " ",
691 type_str,
692 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
693 cap & CODEC_CAP_DR1 ? "D" : " ",
694 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
695 p2->name,
696 p2->long_name ? p2->long_name : "");
697#if 0
698 if (p2->decoder && decode == 0)
699 printf(" use %s for decoding", p2->decoder->name);
700#endif
ba9880c1
SS
701 printf("\n");
702 }
703 printf("\n");
cbaef7d1
AD
704 printf("Note, the names of encoders and decoders do not always match, so there are\n"
705 "several cases where the above table shows encoder only or decoder only entries\n"
706 "even though both encoding and decoding are supported. For example, the h263\n"
707 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
708 "worse.\n");
8447f0bd
MN
709}
710
711void show_bsfs(void)
712{
cbaef7d1 713 AVBitStreamFilter *bsf = NULL;
ba9880c1
SS
714
715 printf("Bitstream filters:\n");
cbaef7d1 716 while ((bsf = av_bitstream_filter_next(bsf)))
2091b27b 717 printf("%s\n", bsf->name);
ba9880c1 718 printf("\n");
8447f0bd
MN
719}
720
721void show_protocols(void)
722{
cdc6a87f
AK
723 void *opaque = NULL;
724 const char *name;
ba9880c1 725
2ee5c789 726 printf("Supported file protocols:\n"
cdc6a87f
AK
727 "Input:\n");
728 while ((name = avio_enum_protocols(&opaque, 0)))
729 printf("%s\n", name);
730 printf("Output:\n");
731 while ((name = avio_enum_protocols(&opaque, 1)))
732 printf("%s\n", name);
ba9880c1 733}
090b61b2 734
62d75662
SS
735void show_filters(void)
736{
78638628 737 AVFilter av_unused(**filter) = NULL;
62d75662
SS
738
739 printf("Filters:\n");
663c2edf 740#if CONFIG_AVFILTER
62d75662
SS
741 while ((filter = av_filter_next(filter)) && *filter)
742 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
663c2edf 743#endif
62d75662
SS
744}
745
3f7bb426
SS
746void show_pix_fmts(void)
747{
9cb5c760
SS
748 enum PixelFormat pix_fmt;
749
cbaef7d1
AD
750 printf("Pixel formats:\n"
751 "I.... = Supported Input format for conversion\n"
752 ".O... = Supported Output format for conversion\n"
753 "..H.. = Hardware accelerated format\n"
754 "...P. = Paletted format\n"
755 "....B = Bitstream format\n"
756 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
757 "-----\n");
9cb5c760 758
e24db3e3
MR
759#if !CONFIG_SWSCALE
760# define sws_isSupportedInput(x) 0
761# define sws_isSupportedOutput(x) 0
762#endif
763
9cb5c760
SS
764 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
765 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
766 printf("%c%c%c%c%c %-16s %d %2d\n",
767 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
768 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
769 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
770 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
771 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
772 pix_desc->name,
773 pix_desc->nb_components,
774 av_get_bits_per_pixel(pix_desc));
775 }
3f7bb426
SS
776}
777
05bffc12
AK
778int show_sample_fmts(const char *opt, const char *arg)
779{
780 int i;
781 char fmt_str[128];
782 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
783 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
784 return 0;
785}
786
090b61b2
SS
787int read_yesno(void)
788{
789 int c = getchar();
790 int yesno = (toupper(c) == 'Y');
791
792 while (c != '\n' && c != EOF)
793 c = getchar();
794
795 return yesno;
796}
458b062d 797
02170990 798int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
458b062d 799{
d94c577d 800 int ret;
c56e9e05 801 FILE *f = fopen(filename, "rb");
458b062d
SS
802
803 if (!f) {
cbaef7d1
AD
804 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
805 strerror(errno));
458b062d
SS
806 return AVERROR(errno);
807 }
808 fseek(f, 0, SEEK_END);
809 *size = ftell(f);
810 fseek(f, 0, SEEK_SET);
811 *bufptr = av_malloc(*size + 1);
812 if (!*bufptr) {
1c5e9551 813 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
458b062d
SS
814 fclose(f);
815 return AVERROR(ENOMEM);
816 }
d94c577d
JG
817 ret = fread(*bufptr, 1, *size, f);
818 if (ret < *size) {
819 av_free(*bufptr);
820 if (ferror(f)) {
821 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
822 filename, strerror(errno));
823 ret = AVERROR(errno);
824 } else
825 ret = AVERROR_EOF;
826 } else {
827 ret = 0;
828 (*bufptr)[*size++] = '\0';
829 }
458b062d
SS
830
831 fclose(f);
d94c577d 832 return ret;
458b062d 833}
7a8bfa5d
AS
834
835void init_pts_correction(PtsCorrectionContext *ctx)
836{
837 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
838 ctx->last_pts = ctx->last_dts = INT64_MIN;
839}
840
cbaef7d1
AD
841int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
842 int64_t dts)
7a8bfa5d
AS
843{
844 int64_t pts = AV_NOPTS_VALUE;
845
846 if (dts != AV_NOPTS_VALUE) {
847 ctx->num_faulty_dts += dts <= ctx->last_dts;
848 ctx->last_dts = dts;
849 }
850 if (reordered_pts != AV_NOPTS_VALUE) {
851 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
852 ctx->last_pts = reordered_pts;
853 }
01d46198 854 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
cbaef7d1 855 && reordered_pts != AV_NOPTS_VALUE)
7a8bfa5d
AS
856 pts = reordered_pts;
857 else
858 pts = dts;
859
860 return pts;
861}
f7ead94c 862
6e872935 863FILE *get_preset_file(char *filename, size_t filename_size,
cbaef7d1
AD
864 const char *preset_name, int is_path,
865 const char *codec_name)
6e872935
SS
866{
867 FILE *f = NULL;
868 int i;
cbaef7d1
AD
869 const char *base[3] = { getenv("AVCONV_DATADIR"),
870 getenv("HOME"),
871 AVCONV_DATADIR, };
6e872935
SS
872
873 if (is_path) {
874 av_strlcpy(filename, preset_name, filename_size);
875 f = fopen(filename, "r");
876 } else {
877 for (i = 0; i < 3 && !f; i++) {
878 if (!base[i])
879 continue;
050dc127 880 snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
cbaef7d1 881 i != 1 ? "" : "/.avconv", preset_name);
6e872935
SS
882 f = fopen(filename, "r");
883 if (!f && codec_name) {
884 snprintf(filename, filename_size,
050dc127 885 "%s%s/%s-%s.avpreset",
cbaef7d1
AD
886 base[i], i != 1 ? "" : "/.avconv", codec_name,
887 preset_name);
6e872935
SS
888 f = fopen(filename, "r");
889 }
890 }
891 }
892
893 return f;
894}
895
d4863fc1
AK
896int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
897{
cbaef7d1 898 if (*spec <= '9' && *spec >= '0') /* opt:index */
d4863fc1 899 return strtol(spec, NULL, 0) == st->index;
cbaef7d1
AD
900 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
901 *spec == 't') { /* opt:[vasdt] */
d4863fc1
AK
902 enum AVMediaType type;
903
904 switch (*spec++) {
cbaef7d1
AD
905 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
906 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
907 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
908 case 'd': type = AVMEDIA_TYPE_DATA; break;
3ccd1580 909 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
7cf78b34 910 default: av_assert0(0);
d4863fc1
AK
911 }
912 if (type != st->codec->codec_type)
913 return 0;
cbaef7d1 914 if (*spec++ == ':') { /* possibly followed by :index */
d4863fc1
AK
915 int i, index = strtol(spec, NULL, 0);
916 for (i = 0; i < s->nb_streams; i++)
917 if (s->streams[i]->codec->codec_type == type && index-- == 0)
918 return i == st->index;
919 return 0;
920 }
921 return 1;
2c474ddb
AK
922 } else if (*spec == 'p' && *(spec + 1) == ':') {
923 int prog_id, i, j;
924 char *endptr;
925 spec += 2;
926 prog_id = strtol(spec, &endptr, 0);
927 for (i = 0; i < s->nb_programs; i++) {
928 if (s->programs[i]->id != prog_id)
929 continue;
930
931 if (*endptr++ == ':') {
932 int stream_idx = strtol(endptr, NULL, 0);
d4b63054
DB
933 return stream_idx >= 0 &&
934 stream_idx < s->programs[i]->nb_stream_indexes &&
935 st->index == s->programs[i]->stream_index[stream_idx];
2c474ddb
AK
936 }
937
938 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
939 if (st->index == s->programs[i]->stream_index[j])
940 return 1;
941 }
942 return 0;
d4863fc1
AK
943 } else if (!*spec) /* empty specifier, matches everything */
944 return 1;
945
946 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
947 return AVERROR(EINVAL);
948}
949
cbaef7d1
AD
950AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
951 AVFormatContext *s, AVStream *st)
8c8eab8b
AK
952{
953 AVDictionary *ret = NULL;
954 AVDictionaryEntry *t = NULL;
cbaef7d1
AD
955 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
956 : avcodec_find_decoder(codec_id);
957 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
958 : AV_OPT_FLAG_DECODING_PARAM;
8c8eab8b 959 char prefix = 0;
20c21f8b 960 const AVClass *cc = avcodec_get_class();
8c8eab8b
AK
961
962 if (!codec)
963 return NULL;
964
965 switch (codec->type) {
cbaef7d1
AD
966 case AVMEDIA_TYPE_VIDEO:
967 prefix = 'v';
968 flags |= AV_OPT_FLAG_VIDEO_PARAM;
969 break;
970 case AVMEDIA_TYPE_AUDIO:
971 prefix = 'a';
972 flags |= AV_OPT_FLAG_AUDIO_PARAM;
973 break;
974 case AVMEDIA_TYPE_SUBTITLE:
975 prefix = 's';
976 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
977 break;
8c8eab8b
AK
978 }
979
980 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
d4863fc1
AK
981 char *p = strchr(t->key, ':');
982
983 /* check stream specification in opt name */
984 if (p)
985 switch (check_stream_specifier(s, st, p + 1)) {
986 case 1: *p = 0; break;
987 case 0: continue;
988 default: return NULL;
989 }
990
20c21f8b 991 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
cbaef7d1
AD
992 (codec && codec->priv_class &&
993 av_opt_find(&codec->priv_class, t->key, NULL, flags,
994 AV_OPT_SEARCH_FAKE_OBJ)))
8c8eab8b 995 av_dict_set(&ret, t->key, t->value, 0);
cbaef7d1
AD
996 else if (t->key[0] == prefix &&
997 av_opt_find(&cc, t->key + 1, NULL, flags,
998 AV_OPT_SEARCH_FAKE_OBJ))
999 av_dict_set(&ret, t->key + 1, t->value, 0);
d4863fc1
AK
1000
1001 if (p)
1002 *p = ':';
8c8eab8b
AK
1003 }
1004 return ret;
1005}
1006
cbaef7d1
AD
1007AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1008 AVDictionary *codec_opts)
3009f521
AK
1009{
1010 int i;
1011 AVDictionary **opts;
1012
1013 if (!s->nb_streams)
1014 return NULL;
1015 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1016 if (!opts) {
cbaef7d1
AD
1017 av_log(NULL, AV_LOG_ERROR,
1018 "Could not alloc memory for stream options.\n");
3009f521
AK
1019 return NULL;
1020 }
1021 for (i = 0; i < s->nb_streams; i++)
cbaef7d1
AD
1022 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1023 s, s->streams[i]);
3009f521
AK
1024 return opts;
1025}
1026
cac651c8
AK
1027void *grow_array(void *array, int elem_size, int *size, int new_size)
1028{
1029 if (new_size >= INT_MAX / elem_size) {
1030 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1031 exit_program(1);
1032 }
1033 if (*size < new_size) {
1034 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1035 if (!tmp) {
1036 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1037 exit_program(1);
1038 }
1039 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1040 *size = new_size;
1041 return tmp;
1042 }
1043 return array;
1044}
d55c2e05
AK
1045
1046static int alloc_buffer(FrameBuffer **pool, AVCodecContext *s, FrameBuffer **pbuf)
1047{
1048 FrameBuffer *buf = av_mallocz(sizeof(*buf));
1049 int i, ret;
1050 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
1051 int h_chroma_shift, v_chroma_shift;
1052 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
1053 int w = s->width, h = s->height;
1054
1055 if (!buf)
1056 return AVERROR(ENOMEM);
1057
1058 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1059 w += 2*edge;
1060 h += 2*edge;
1061 }
1062
1063 avcodec_align_dimensions(s, &w, &h);
1064 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
1065 s->pix_fmt, 32)) < 0) {
1066 av_freep(&buf);
1067 return ret;
1068 }
1069 /* XXX this shouldn't be needed, but some tests break without this line
1070 * those decoders are buggy and need to be fixed.
1071 * the following tests fail:
1072 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
1073 */
1074 memset(buf->base[0], 128, ret);
1075
1076 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1077 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1078 const int h_shift = i==0 ? 0 : h_chroma_shift;
1079 const int v_shift = i==0 ? 0 : v_chroma_shift;
1080 if (s->flags & CODEC_FLAG_EMU_EDGE)
1081 buf->data[i] = buf->base[i];
1082 else
1083 buf->data[i] = buf->base[i] +
1084 FFALIGN((buf->linesize[i]*edge >> v_shift) +
1085 (pixel_size*edge >> h_shift), 32);
1086 }
1087 buf->w = s->width;
1088 buf->h = s->height;
1089 buf->pix_fmt = s->pix_fmt;
1090 buf->pool = pool;
1091
1092 *pbuf = buf;
1093 return 0;
1094}
1095
1096int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
1097{
1098 FrameBuffer **pool = s->opaque;
1099 FrameBuffer *buf;
1100 int ret, i;
1101
1102 if (!*pool && (ret = alloc_buffer(pool, s, pool)) < 0)
1103 return ret;
1104
1105 buf = *pool;
1106 *pool = buf->next;
1107 buf->next = NULL;
1108 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
1109 av_freep(&buf->base[0]);
1110 av_free(buf);
1111 if ((ret = alloc_buffer(pool, s, &buf)) < 0)
1112 return ret;
1113 }
1114 buf->refcount++;
1115
1116 frame->opaque = buf;
1117 frame->type = FF_BUFFER_TYPE_USER;
1118 frame->extended_data = frame->data;
1119 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
1120 frame->width = buf->w;
1121 frame->height = buf->h;
1122 frame->format = buf->pix_fmt;
1123 frame->sample_aspect_ratio = s->sample_aspect_ratio;
1124
1125 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
1126 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
1127 frame->data[i] = buf->data[i];
1128 frame->linesize[i] = buf->linesize[i];
1129 }
1130
1131 return 0;
1132}
1133
1134static void unref_buffer(FrameBuffer *buf)
1135{
1136 FrameBuffer **pool = buf->pool;
1137
1138 av_assert0(buf->refcount);
1139 buf->refcount--;
1140 if (!buf->refcount) {
1141 buf->next = *pool;
1142 *pool = buf;
1143 }
1144}
1145
1146void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
1147{
1148 FrameBuffer *buf = frame->opaque;
1149 int i;
1150
1151 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
1152 frame->data[i] = NULL;
1153
1154 unref_buffer(buf);
1155}
1156
1157void filter_release_buffer(AVFilterBuffer *fb)
1158{
1159 FrameBuffer *buf = fb->priv;
1160 av_free(fb);
1161 unref_buffer(buf);
1162}
1163
1164void free_buffer_pool(FrameBuffer **pool)
1165{
1166 FrameBuffer *buf = *pool;
1167 while (buf) {
1168 *pool = buf->next;
1169 av_freep(&buf->base[0]);
1170 av_free(buf);
1171 buf = *pool;
1172 }
1173}