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