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