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