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