Fix a bunch of platform name and other typos.
[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"
db6d50c7 35#include "libswscale/swscale.h"
014f8d81 36#if CONFIG_POSTPROC
1981deaf 37#include "libpostproc/postprocess.h"
014f8d81 38#endif
245976da 39#include "libavutil/avstring.h"
85770d6e 40#include "libavutil/mathematics.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
3568853f 58static const int this_year = 2011;
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);
236 if (!(po->name && (po->flags & OPT_BOOL)))
237 goto unknown_opt;
238 bool_val = 0;
239 }
240 if (!po->name)
241 po = find_option(options, "default");
242 if (!po->name) {
243unknown_opt:
244 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
245 return AVERROR(EINVAL);
246 }
247 if (po->flags & HAS_ARG && !arg) {
248 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
249 return AVERROR(EINVAL);
250 }
251
252 /* new-style options contain an offset into optctx, old-style address of
253 * a global var*/
cbaef7d1
AD
254 dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off
255 : po->u.dst_ptr;
6361c5e1
AK
256
257 if (po->flags & OPT_SPEC) {
258 SpecifierOpt **so = dst;
259 char *p = strchr(opt, ':');
260
cbaef7d1 261 dstcount = (int *)(so + 1);
6361c5e1
AK
262 *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
263 (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
264 dst = &(*so)[*dstcount - 1].u;
265 }
2f8e586d
AK
266
267 if (po->flags & OPT_STRING) {
268 char *str;
269 str = av_strdup(arg);
cbaef7d1 270 *(char **)dst = str;
2f8e586d 271 } else if (po->flags & OPT_BOOL) {
cbaef7d1 272 *(int *)dst = bool_val;
2f8e586d 273 } else if (po->flags & OPT_INT) {
cbaef7d1 274 *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2f8e586d 275 } else if (po->flags & OPT_INT64) {
cbaef7d1 276 *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
6b779ccc 277 } else if (po->flags & OPT_TIME) {
cbaef7d1 278 *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
2f8e586d 279 } else if (po->flags & OPT_FLOAT) {
cbaef7d1 280 *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
33f75d72 281 } else if (po->flags & OPT_DOUBLE) {
cbaef7d1 282 *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
2f8e586d 283 } else if (po->u.func_arg) {
cbaef7d1
AD
284 int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
285 : po->u.func_arg(opt, arg);
2f8e586d 286 if (ret < 0) {
cbaef7d1
AD
287 av_log(NULL, AV_LOG_ERROR,
288 "Failed to set value '%s' for option '%s'\n", arg, opt);
2f8e586d
AK
289 return ret;
290 }
291 }
292 if (po->flags & OPT_EXIT)
293 exit_program(0);
294 return !!(po->flags & HAS_ARG);
295}
296
7cc8d638 297void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
cbaef7d1 298 void (*parse_arg_function)(void *, const char*))
01310af2 299{
2f8e586d
AK
300 const char *opt;
301 int optindex, handleoptions = 1, ret;
01310af2 302
b1ac139d
KG
303 /* perform system-dependent conversions for arguments list */
304 prepare_app_arguments(&argc, &argv);
305
01310af2
FB
306 /* parse options */
307 optindex = 1;
308 while (optindex < argc) {
309 opt = argv[optindex++];
115329f1 310
84bf226b 311 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
3749076c
SS
312 if (opt[1] == '-' && opt[2] == '\0') {
313 handleoptions = 0;
314 continue;
315 }
c3c78324 316 opt++;
2f8e586d
AK
317
318 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
dad09ff9 319 exit_program(1);
2f8e586d 320 optindex += ret;
01310af2 321 } else {
60a9966e 322 if (parse_arg_function)
7cc8d638 323 parse_arg_function(optctx, opt);
01310af2
FB
324 }
325 }
326}
327
182cbe43
AK
328/*
329 * Return index of option opt in argv or 0 if not found.
330 */
cbaef7d1
AD
331static int locate_option(int argc, char **argv, const OptionDef *options,
332 const char *optname)
182cbe43
AK
333{
334 const OptionDef *po;
335 int i;
336
337 for (i = 1; i < argc; i++) {
338 const char *cur_opt = argv[i];
339
340 if (*cur_opt++ != '-')
341 continue;
342
343 po = find_option(options, cur_opt);
344 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
345 po = find_option(options, cur_opt + 2);
346
347 if ((!po->name && !strcmp(cur_opt, optname)) ||
348 (po->name && !strcmp(optname, po->name)))
349 return i;
350
351 if (!po || po->flags & HAS_ARG)
352 i++;
353 }
354 return 0;
355}
356
357void parse_loglevel(int argc, char **argv, const OptionDef *options)
358{
359 int idx = locate_option(argc, argv, options, "loglevel");
8124d8ad
MR
360 if (!idx)
361 idx = locate_option(argc, argv, options, "v");
182cbe43
AK
362 if (idx && argv[idx + 1])
363 opt_loglevel("loglevel", argv[idx + 1]);
364}
365
145f741e 366#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
35d2e4e5 367int opt_default(const char *opt, const char *arg)
9ba38229
AK
368{
369 const AVOption *o;
d4863fc1
AK
370 char opt_stripped[128];
371 const char *p;
20c21f8b 372 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
d4863fc1
AK
373
374 if (!(p = strchr(opt, ':')))
375 p = opt + strlen(opt);
376 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
377
cbaef7d1
AD
378 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
379 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
380 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
381 (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
8c8eab8b 382 av_dict_set(&codec_opts, opt, arg, FLAGS);
cbaef7d1
AD
383 else if ((o = av_opt_find(&fc, opt, NULL, 0,
384 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
9ba38229 385 av_dict_set(&format_opts, opt, arg, FLAGS);
cbaef7d1
AD
386 else if ((o = av_opt_find(&sc, opt, NULL, 0,
387 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
9ba38229 388 // XXX we only support sws_flags, not arbitrary sws options
3b3ea346 389 int ret = av_opt_set(sws_opts, opt, arg, 0);
9ba38229
AK
390 if (ret < 0) {
391 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
392 return ret;
393 }
394 }
395
9ba38229
AK
396 if (o)
397 return 0;
1c5e9551 398 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
9ba38229
AK
399 return AVERROR_OPTION_NOT_FOUND;
400}
401
4c97a6fa
SS
402int opt_loglevel(const char *opt, const char *arg)
403{
da4c2dab 404 const struct { const char *name; int level; } log_levels[] = {
4c97a6fa
SS
405 { "quiet" , AV_LOG_QUIET },
406 { "panic" , AV_LOG_PANIC },
407 { "fatal" , AV_LOG_FATAL },
408 { "error" , AV_LOG_ERROR },
409 { "warning", AV_LOG_WARNING },
410 { "info" , AV_LOG_INFO },
411 { "verbose", AV_LOG_VERBOSE },
412 { "debug" , AV_LOG_DEBUG },
413 };
414 char *tail;
415 int level;
416 int i;
417
418 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
419 if (!strcmp(log_levels[i].name, arg)) {
420 av_log_set_level(log_levels[i].level);
421 return 0;
422 }
423 }
424
425 level = strtol(arg, &tail, 10);
426 if (*tail) {
1c5e9551
AK
427 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
428 "Possible levels are numbers or:\n", arg);
4c97a6fa 429 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1c5e9551 430 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
dad09ff9 431 exit_program(1);
4c97a6fa
SS
432 }
433 av_log_set_level(level);
434 return 0;
435}
436
ffcc6e24
MR
437int opt_timelimit(const char *opt, const char *arg)
438{
0104b608 439#if HAVE_SETRLIMIT
ffcc6e24
MR
440 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
441 struct rlimit rl = { lim, lim + 1 };
442 if (setrlimit(RLIMIT_CPU, &rl))
443 perror("setrlimit");
444#else
1c5e9551 445 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
ffcc6e24
MR
446#endif
447 return 0;
448}
449
01310af2
FB
450void print_error(const char *filename, int err)
451{
7a5bdd79 452 char errbuf[128];
735ef67b 453 const char *errbuf_ptr = errbuf;
7a5bdd79 454
9e94bd3e
SS
455 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
456 errbuf_ptr = strerror(AVUNERROR(err));
1c5e9551 457 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
01310af2 458}
f35917b2 459
d101e731
SS
460static int warned_cfg = 0;
461
208749a0
SS
462#define INDENT 1
463#define SHOW_VERSION 2
d101e731 464#define SHOW_CONFIG 4
208749a0 465
1c5e9551 466#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
5116571d 467 if (CONFIG_##LIBNAME) { \
65dd2ded 468 const char *indent = flags & INDENT? " " : ""; \
208749a0 469 if (flags & SHOW_VERSION) { \
b6525b4b 470 unsigned int version = libname##_version(); \
1c5e9551
AK
471 av_log(NULL, level, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n",\
472 indent, #libname, \
473 LIB##LIBNAME##_VERSION_MAJOR, \
474 LIB##LIBNAME##_VERSION_MINOR, \
475 LIB##LIBNAME##_VERSION_MICRO, \
476 version >> 16, version >> 8 & 0xff, version & 0xff); \
208749a0 477 } \
d101e731
SS
478 if (flags & SHOW_CONFIG) { \
479 const char *cfg = libname##_configuration(); \
29ba0911 480 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
d101e731 481 if (!warned_cfg) { \
1c5e9551 482 av_log(NULL, level, \
d101e731 483 "%sWARNING: library configuration mismatch\n", \
65dd2ded 484 indent); \
d101e731
SS
485 warned_cfg = 1; \
486 } \
1c5e9551 487 av_log(NULL, level, "%s%-11s configuration: %s\n", \
65dd2ded 488 indent, #libname, cfg); \
d101e731
SS
489 } \
490 } \
208749a0 491 } \
9a109272 492
1c5e9551 493static void print_all_libs_info(int flags, int level)
9a109272 494{
1c5e9551
AK
495 PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
496 PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
497 PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
498 PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
499 PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
500 PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
014f8d81 501#if CONFIG_POSTPROC
1c5e9551 502 PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
014f8d81 503#endif
9a109272
SS
504}
505
ea9c581f 506void show_banner(void)
86074ed1 507{
cbaef7d1
AD
508 av_log(NULL, AV_LOG_INFO,
509 "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
1c5e9551
AK
510 program_name, program_birth_year, this_year);
511 av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
512 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
513 av_log(NULL, AV_LOG_VERBOSE, " configuration: " LIBAV_CONFIGURATION "\n");
514 print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_VERBOSE);
515 print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
86074ed1
SS
516}
517
64555bd9 518void show_version(void) {
1c5e9551 519 av_log_set_callback(log_callback_help);
a03be6e1 520 printf("%s " LIBAV_VERSION "\n", program_name);
1c5e9551 521 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
86074ed1
SS
522}
523
f35917b2
SS
524void show_license(void)
525{
7ead693b 526 printf(
3bf28f9d 527#if CONFIG_NONFREE
304ba23a
SS
528 "This version of %s has nonfree parts compiled in.\n"
529 "Therefore it is not legally redistributable.\n",
530 program_name
9cad0e4e
DB
531#elif CONFIG_GPLV3
532 "%s is free software; you can redistribute it and/or modify\n"
533 "it under the terms of the GNU General Public License as published by\n"
534 "the Free Software Foundation; either version 3 of the License, or\n"
535 "(at your option) any later version.\n"
536 "\n"
537 "%s is distributed in the hope that it will be useful,\n"
538 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
539 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
540 "GNU General Public License for more details.\n"
541 "\n"
542 "You should have received a copy of the GNU General Public License\n"
543 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
544 program_name, program_name, program_name
7ead693b 545#elif CONFIG_GPL
304ba23a 546 "%s is free software; you can redistribute it and/or modify\n"
f35917b2
SS
547 "it under the terms of the GNU General Public License as published by\n"
548 "the Free Software Foundation; either version 2 of the License, or\n"
549 "(at your option) any later version.\n"
550 "\n"
304ba23a 551 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
552 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
553 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
554 "GNU General Public License for more details.\n"
555 "\n"
556 "You should have received a copy of the GNU General Public License\n"
304ba23a
SS
557 "along with %s; if not, write to the Free Software\n"
558 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
559 program_name, program_name, program_name
9cad0e4e
DB
560#elif CONFIG_LGPLV3
561 "%s is free software; you can redistribute it and/or modify\n"
562 "it under the terms of the GNU Lesser General Public License as published by\n"
563 "the Free Software Foundation; either version 3 of the License, or\n"
564 "(at your option) any later version.\n"
565 "\n"
566 "%s is distributed in the hope that it will be useful,\n"
567 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
568 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
569 "GNU Lesser General Public License for more details.\n"
570 "\n"
571 "You should have received a copy of the GNU Lesser General Public License\n"
572 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
573 program_name, program_name, program_name
f35917b2 574#else
304ba23a 575 "%s is free software; you can redistribute it and/or\n"
f35917b2
SS
576 "modify it under the terms of the GNU Lesser General Public\n"
577 "License as published by the Free Software Foundation; either\n"
578 "version 2.1 of the License, or (at your option) any later version.\n"
579 "\n"
304ba23a 580 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
581 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
582 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
583 "Lesser General Public License for more details.\n"
584 "\n"
585 "You should have received a copy of the GNU Lesser General Public\n"
304ba23a
SS
586 "License along with %s; if not, write to the Free Software\n"
587 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
588 program_name, program_name, program_name
f35917b2 589#endif
3bf28f9d 590 );
f35917b2 591}
ba9880c1
SS
592
593void show_formats(void)
594{
cbaef7d1
AD
595 AVInputFormat *ifmt = NULL;
596 AVOutputFormat *ofmt = NULL;
ba9880c1
SS
597 const char *last_name;
598
cbaef7d1
AD
599 printf("File formats:\n"
600 " D. = Demuxing supported\n"
601 " .E = Muxing supported\n"
602 " --\n");
603 last_name = "000";
604 for (;;) {
605 int decode = 0;
606 int encode = 0;
607 const char *name = NULL;
608 const char *long_name = NULL;
609
610 while ((ofmt = av_oformat_next(ofmt))) {
611 if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
612 strcmp(ofmt->name, last_name) > 0) {
613 name = ofmt->name;
614 long_name = ofmt->long_name;
615 encode = 1;
ba9880c1
SS
616 }
617 }
cbaef7d1
AD
618 while ((ifmt = av_iformat_next(ifmt))) {
619 if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
620 strcmp(ifmt->name, last_name) > 0) {
621 name = ifmt->name;
622 long_name = ifmt->long_name;
623 encode = 0;
ba9880c1 624 }
cbaef7d1
AD
625 if (name && strcmp(ifmt->name, name) == 0)
626 decode = 1;
ba9880c1 627 }
cbaef7d1 628 if (name == NULL)
ba9880c1 629 break;
cbaef7d1 630 last_name = name;
ba9880c1 631
cbaef7d1
AD
632 printf(" %s%s %-15s %s\n",
633 decode ? "D" : " ",
634 encode ? "E" : " ",
635 name,
ba9880c1
SS
636 long_name ? long_name:" ");
637 }
8447f0bd 638}
ba9880c1 639
8447f0bd
MN
640void show_codecs(void)
641{
cbaef7d1 642 AVCodec *p = NULL, *p2;
8447f0bd 643 const char *last_name;
cbaef7d1
AD
644 printf("Codecs:\n"
645 " D..... = Decoding supported\n"
646 " .E.... = Encoding supported\n"
647 " ..V... = Video codec\n"
648 " ..A... = Audio codec\n"
649 " ..S... = Subtitle codec\n"
650 " ...S.. = Supports draw_horiz_band\n"
651 " ....D. = Supports direct rendering method 1\n"
652 " .....T = Supports weird frame truncation\n"
653 " ------\n");
ba9880c1 654 last_name= "000";
cbaef7d1
AD
655 for (;;) {
656 int decode = 0;
657 int encode = 0;
658 int cap = 0;
ba9880c1
SS
659 const char *type_str;
660
cbaef7d1
AD
661 p2 = NULL;
662 while ((p = av_codec_next(p))) {
663 if ((p2 == NULL || strcmp(p->name, p2->name) < 0) &&
664 strcmp(p->name, last_name) > 0) {
665 p2 = p;
666 decode = encode = cap = 0;
ba9880c1 667 }
cbaef7d1
AD
668 if (p2 && strcmp(p->name, p2->name) == 0) {
669 if (p->decode)
670 decode = 1;
671 if (p->encode)
672 encode = 1;
ba9880c1
SS
673 cap |= p->capabilities;
674 }
675 }
cbaef7d1 676 if (p2 == NULL)
ba9880c1 677 break;
cbaef7d1 678 last_name = p2->name;
ba9880c1 679
cbaef7d1 680 switch (p2->type) {
72415b2a 681 case AVMEDIA_TYPE_VIDEO:
ba9880c1
SS
682 type_str = "V";
683 break;
72415b2a 684 case AVMEDIA_TYPE_AUDIO:
ba9880c1
SS
685 type_str = "A";
686 break;
72415b2a 687 case AVMEDIA_TYPE_SUBTITLE:
ba9880c1
SS
688 type_str = "S";
689 break;
690 default:
691 type_str = "?";
692 break;
693 }
cbaef7d1
AD
694 printf(" %s%s%s%s%s%s %-15s %s",
695 decode ? "D" : (/* p2->decoder ? "d" : */ " "),
696 encode ? "E" : " ",
697 type_str,
698 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S" : " ",
699 cap & CODEC_CAP_DR1 ? "D" : " ",
700 cap & CODEC_CAP_TRUNCATED ? "T" : " ",
701 p2->name,
702 p2->long_name ? p2->long_name : "");
703#if 0
704 if (p2->decoder && decode == 0)
705 printf(" use %s for decoding", p2->decoder->name);
706#endif
ba9880c1
SS
707 printf("\n");
708 }
709 printf("\n");
cbaef7d1
AD
710 printf("Note, the names of encoders and decoders do not always match, so there are\n"
711 "several cases where the above table shows encoder only or decoder only entries\n"
712 "even though both encoding and decoding are supported. For example, the h263\n"
713 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
714 "worse.\n");
8447f0bd
MN
715}
716
717void show_bsfs(void)
718{
cbaef7d1 719 AVBitStreamFilter *bsf = NULL;
ba9880c1
SS
720
721 printf("Bitstream filters:\n");
cbaef7d1 722 while ((bsf = av_bitstream_filter_next(bsf)))
2091b27b 723 printf("%s\n", bsf->name);
ba9880c1 724 printf("\n");
8447f0bd
MN
725}
726
727void show_protocols(void)
728{
cdc6a87f
AK
729 void *opaque = NULL;
730 const char *name;
ba9880c1 731
2ee5c789 732 printf("Supported file protocols:\n"
cdc6a87f
AK
733 "Input:\n");
734 while ((name = avio_enum_protocols(&opaque, 0)))
735 printf("%s\n", name);
736 printf("Output:\n");
737 while ((name = avio_enum_protocols(&opaque, 1)))
738 printf("%s\n", name);
ba9880c1 739}
090b61b2 740
62d75662
SS
741void show_filters(void)
742{
78638628 743 AVFilter av_unused(**filter) = NULL;
62d75662
SS
744
745 printf("Filters:\n");
663c2edf 746#if CONFIG_AVFILTER
62d75662
SS
747 while ((filter = av_filter_next(filter)) && *filter)
748 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
663c2edf 749#endif
62d75662
SS
750}
751
3f7bb426
SS
752void show_pix_fmts(void)
753{
9cb5c760
SS
754 enum PixelFormat pix_fmt;
755
cbaef7d1
AD
756 printf("Pixel formats:\n"
757 "I.... = Supported Input format for conversion\n"
758 ".O... = Supported Output format for conversion\n"
759 "..H.. = Hardware accelerated format\n"
760 "...P. = Paletted format\n"
761 "....B = Bitstream format\n"
762 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
763 "-----\n");
9cb5c760 764
e24db3e3
MR
765#if !CONFIG_SWSCALE
766# define sws_isSupportedInput(x) 0
767# define sws_isSupportedOutput(x) 0
768#endif
769
9cb5c760
SS
770 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
771 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
772 printf("%c%c%c%c%c %-16s %d %2d\n",
773 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
774 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
775 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
776 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
777 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
778 pix_desc->name,
779 pix_desc->nb_components,
780 av_get_bits_per_pixel(pix_desc));
781 }
3f7bb426
SS
782}
783
05bffc12
AK
784int show_sample_fmts(const char *opt, const char *arg)
785{
786 int i;
787 char fmt_str[128];
788 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
789 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
790 return 0;
791}
792
090b61b2
SS
793int read_yesno(void)
794{
795 int c = getchar();
796 int yesno = (toupper(c) == 'Y');
797
798 while (c != '\n' && c != EOF)
799 c = getchar();
800
801 return yesno;
802}
458b062d 803
02170990 804int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
458b062d 805{
d94c577d 806 int ret;
c56e9e05 807 FILE *f = fopen(filename, "rb");
458b062d
SS
808
809 if (!f) {
cbaef7d1
AD
810 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
811 strerror(errno));
458b062d
SS
812 return AVERROR(errno);
813 }
814 fseek(f, 0, SEEK_END);
815 *size = ftell(f);
816 fseek(f, 0, SEEK_SET);
817 *bufptr = av_malloc(*size + 1);
818 if (!*bufptr) {
1c5e9551 819 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
458b062d
SS
820 fclose(f);
821 return AVERROR(ENOMEM);
822 }
d94c577d
JG
823 ret = fread(*bufptr, 1, *size, f);
824 if (ret < *size) {
825 av_free(*bufptr);
826 if (ferror(f)) {
827 av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
828 filename, strerror(errno));
829 ret = AVERROR(errno);
830 } else
831 ret = AVERROR_EOF;
832 } else {
833 ret = 0;
834 (*bufptr)[*size++] = '\0';
835 }
458b062d
SS
836
837 fclose(f);
d94c577d 838 return ret;
458b062d 839}
7a8bfa5d
AS
840
841void init_pts_correction(PtsCorrectionContext *ctx)
842{
843 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
844 ctx->last_pts = ctx->last_dts = INT64_MIN;
845}
846
cbaef7d1
AD
847int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
848 int64_t dts)
7a8bfa5d
AS
849{
850 int64_t pts = AV_NOPTS_VALUE;
851
852 if (dts != AV_NOPTS_VALUE) {
853 ctx->num_faulty_dts += dts <= ctx->last_dts;
854 ctx->last_dts = dts;
855 }
856 if (reordered_pts != AV_NOPTS_VALUE) {
857 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
858 ctx->last_pts = reordered_pts;
859 }
01d46198 860 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
cbaef7d1 861 && reordered_pts != AV_NOPTS_VALUE)
7a8bfa5d
AS
862 pts = reordered_pts;
863 else
864 pts = dts;
865
866 return pts;
867}
f7ead94c 868
6e872935 869FILE *get_preset_file(char *filename, size_t filename_size,
cbaef7d1
AD
870 const char *preset_name, int is_path,
871 const char *codec_name)
6e872935
SS
872{
873 FILE *f = NULL;
874 int i;
cbaef7d1
AD
875 const char *base[3] = { getenv("AVCONV_DATADIR"),
876 getenv("HOME"),
877 AVCONV_DATADIR, };
6e872935
SS
878
879 if (is_path) {
880 av_strlcpy(filename, preset_name, filename_size);
881 f = fopen(filename, "r");
882 } else {
883 for (i = 0; i < 3 && !f; i++) {
884 if (!base[i])
885 continue;
cbaef7d1
AD
886 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
887 i != 1 ? "" : "/.avconv", preset_name);
6e872935
SS
888 f = fopen(filename, "r");
889 if (!f && codec_name) {
890 snprintf(filename, filename_size,
cbaef7d1
AD
891 "%s%s/%s-%s.ffpreset",
892 base[i], i != 1 ? "" : "/.avconv", codec_name,
893 preset_name);
6e872935
SS
894 f = fopen(filename, "r");
895 }
896 }
897 }
898
899 return f;
900}
901
d4863fc1
AK
902int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
903{
cbaef7d1 904 if (*spec <= '9' && *spec >= '0') /* opt:index */
d4863fc1 905 return strtol(spec, NULL, 0) == st->index;
cbaef7d1
AD
906 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
907 *spec == 't') { /* opt:[vasdt] */
d4863fc1
AK
908 enum AVMediaType type;
909
910 switch (*spec++) {
cbaef7d1
AD
911 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
912 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
913 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
914 case 'd': type = AVMEDIA_TYPE_DATA; break;
3ccd1580 915 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
d4863fc1
AK
916 }
917 if (type != st->codec->codec_type)
918 return 0;
cbaef7d1 919 if (*spec++ == ':') { /* possibly followed by :index */
d4863fc1
AK
920 int i, index = strtol(spec, NULL, 0);
921 for (i = 0; i < s->nb_streams; i++)
922 if (s->streams[i]->codec->codec_type == type && index-- == 0)
923 return i == st->index;
924 return 0;
925 }
926 return 1;
2c474ddb
AK
927 } else if (*spec == 'p' && *(spec + 1) == ':') {
928 int prog_id, i, j;
929 char *endptr;
930 spec += 2;
931 prog_id = strtol(spec, &endptr, 0);
932 for (i = 0; i < s->nb_programs; i++) {
933 if (s->programs[i]->id != prog_id)
934 continue;
935
936 if (*endptr++ == ':') {
937 int stream_idx = strtol(endptr, NULL, 0);
d4b63054
DB
938 return stream_idx >= 0 &&
939 stream_idx < s->programs[i]->nb_stream_indexes &&
940 st->index == s->programs[i]->stream_index[stream_idx];
2c474ddb
AK
941 }
942
943 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
944 if (st->index == s->programs[i]->stream_index[j])
945 return 1;
946 }
947 return 0;
d4863fc1
AK
948 } else if (!*spec) /* empty specifier, matches everything */
949 return 1;
950
951 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
952 return AVERROR(EINVAL);
953}
954
cbaef7d1
AD
955AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id,
956 AVFormatContext *s, AVStream *st)
8c8eab8b
AK
957{
958 AVDictionary *ret = NULL;
959 AVDictionaryEntry *t = NULL;
cbaef7d1
AD
960 AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id)
961 : avcodec_find_decoder(codec_id);
962 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
963 : AV_OPT_FLAG_DECODING_PARAM;
8c8eab8b 964 char prefix = 0;
20c21f8b 965 const AVClass *cc = avcodec_get_class();
8c8eab8b
AK
966
967 if (!codec)
968 return NULL;
969
970 switch (codec->type) {
cbaef7d1
AD
971 case AVMEDIA_TYPE_VIDEO:
972 prefix = 'v';
973 flags |= AV_OPT_FLAG_VIDEO_PARAM;
974 break;
975 case AVMEDIA_TYPE_AUDIO:
976 prefix = 'a';
977 flags |= AV_OPT_FLAG_AUDIO_PARAM;
978 break;
979 case AVMEDIA_TYPE_SUBTITLE:
980 prefix = 's';
981 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
982 break;
8c8eab8b
AK
983 }
984
985 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
d4863fc1
AK
986 char *p = strchr(t->key, ':');
987
988 /* check stream specification in opt name */
989 if (p)
990 switch (check_stream_specifier(s, st, p + 1)) {
991 case 1: *p = 0; break;
992 case 0: continue;
993 default: return NULL;
994 }
995
20c21f8b 996 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
cbaef7d1
AD
997 (codec && codec->priv_class &&
998 av_opt_find(&codec->priv_class, t->key, NULL, flags,
999 AV_OPT_SEARCH_FAKE_OBJ)))
8c8eab8b 1000 av_dict_set(&ret, t->key, t->value, 0);
cbaef7d1
AD
1001 else if (t->key[0] == prefix &&
1002 av_opt_find(&cc, t->key + 1, NULL, flags,
1003 AV_OPT_SEARCH_FAKE_OBJ))
1004 av_dict_set(&ret, t->key + 1, t->value, 0);
d4863fc1
AK
1005
1006 if (p)
1007 *p = ':';
8c8eab8b
AK
1008 }
1009 return ret;
1010}
1011
cbaef7d1
AD
1012AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1013 AVDictionary *codec_opts)
3009f521
AK
1014{
1015 int i;
1016 AVDictionary **opts;
1017
1018 if (!s->nb_streams)
1019 return NULL;
1020 opts = av_mallocz(s->nb_streams * sizeof(*opts));
1021 if (!opts) {
cbaef7d1
AD
1022 av_log(NULL, AV_LOG_ERROR,
1023 "Could not alloc memory for stream options.\n");
3009f521
AK
1024 return NULL;
1025 }
1026 for (i = 0; i < s->nb_streams; i++)
cbaef7d1
AD
1027 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1028 s, s->streams[i]);
3009f521
AK
1029 return opts;
1030}
1031
f7ead94c
SS
1032#if CONFIG_AVFILTER
1033
1034static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
1035{
1036 FFSinkContext *priv = ctx->priv;
1037
1038 if (!opaque)
1039 return AVERROR(EINVAL);
1040 *priv = *(FFSinkContext *)opaque;
1041
1042 return 0;
1043}
1044
1045static void null_end_frame(AVFilterLink *inlink) { }
1046
1047static int ffsink_query_formats(AVFilterContext *ctx)
1048{
1049 FFSinkContext *priv = ctx->priv;
1050 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
1051
1052 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
1053 return 0;
1054}
1055
1056AVFilter ffsink = {
1057 .name = "ffsink",
1058 .priv_size = sizeof(FFSinkContext),
1059 .init = ffsink_init,
1060
1061 .query_formats = ffsink_query_formats,
1062
1063 .inputs = (AVFilterPad[]) {{ .name = "default",
1064 .type = AVMEDIA_TYPE_VIDEO,
1065 .end_frame = null_end_frame,
1066 .min_perms = AV_PERM_READ, },
1067 { .name = NULL }},
1068 .outputs = (AVFilterPad[]) {{ .name = NULL }},
1069};
1070
ff0652e5
SS
1071int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1072 AVFilterBufferRef **picref_ptr, AVRational *tb)
1073{
1074 int ret;
1075 AVFilterBufferRef *picref;
1076
1077 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1078 return ret;
1079 if (!(picref = ctx->inputs[0]->cur_buf))
1080 return AVERROR(ENOENT);
1081 *picref_ptr = picref;
1082 ctx->inputs[0]->cur_buf = NULL;
1083 *tb = ctx->inputs[0]->time_base;
1084
1085 memcpy(frame->data, picref->data, sizeof(frame->data));
1086 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
cbaef7d1
AD
1087 frame->interlaced_frame = picref->video->interlaced;
1088 frame->top_field_first = picref->video->top_field_first;
1089 frame->key_frame = picref->video->key_frame;
1090 frame->pict_type = picref->video->pict_type;
b58dbb5b 1091 frame->sample_aspect_ratio = picref->video->pixel_aspect;
ff0652e5
SS
1092
1093 return 1;
1094}
1095
e1b10155
JG
1096#endif /* CONFIG_AVFILTER */
1097
cac651c8
AK
1098void *grow_array(void *array, int elem_size, int *size, int new_size)
1099{
1100 if (new_size >= INT_MAX / elem_size) {
1101 av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1102 exit_program(1);
1103 }
1104 if (*size < new_size) {
1105 uint8_t *tmp = av_realloc(array, new_size*elem_size);
1106 if (!tmp) {
1107 av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1108 exit_program(1);
1109 }
1110 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1111 *size = new_size;
1112 return tmp;
1113 }
1114 return array;
1115}