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