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