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