rawdec: Support more QT 1bpp rawvideo files.
[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, NULL, NULL, NULL);
62 #endif
63 }
64
65 void uninit_opts(void)
66 {
67 #if CONFIG_SWSCALE
68 sws_freeContext(sws_opts);
69 sws_opts = NULL;
70 #endif
71 av_dict_free(&format_opts);
72 av_dict_free(&codec_opts);
73 }
74
75 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
76 {
77 vfprintf(stdout, fmt, vl);
78 }
79
80 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
81 {
82 char *tail;
83 const char *error;
84 double d = av_strtod(numstr, &tail);
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";
91 else if (type == OPT_INT && (int)d != d)
92 error= "Expected int for %s but found %s\n";
93 else
94 return d;
95 av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
96 exit_program(1);
97 return 0;
98 }
99
100 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
101 {
102 int64_t us;
103 if (av_parse_time(&us, timestr, is_duration) < 0) {
104 av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
105 is_duration ? "duration" : "date", context, timestr);
106 exit_program(1);
107 }
108 return us;
109 }
110
111 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
112 {
113 const OptionDef *po;
114 int first;
115
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 }
124 av_strlcpy(buf, po->name, sizeof(buf));
125 if (po->flags & HAS_ARG) {
126 av_strlcat(buf, " ", sizeof(buf));
127 av_strlcat(buf, po->argname, sizeof(buf));
128 }
129 printf("-%-17s %s\n", buf, po->help);
130 }
131 }
132 }
133
134 void 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
144 static const OptionDef* find_option(const OptionDef *po, const char *name){
145 const char *p = strchr(name, ':');
146 int len = p ? p - name : strlen(name);
147
148 while (po->name != NULL) {
149 if (!strncmp(name, po->name, len) && strlen(po->name) == len)
150 break;
151 po++;
152 }
153 return po;
154 }
155
156 #if defined(_WIN32) && !defined(__MINGW32CE__)
157 #include <windows.h>
158 /* Will be leaked on exit */
159 static char** win32_argv_utf8 = NULL;
160 static 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 */
169 static 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
211 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
212 {
213 /* nothing to do */
214 }
215 #endif /* WIN32 && !__MINGW32CE__ */
216
217 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
218 {
219 const OptionDef *po;
220 int bool_val = 1;
221 int *dstcount;
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) {
235 unknown_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*/
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 }
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);
268 } else if (po->flags & OPT_TIME) {
269 *(int64_t*)dst = parse_time_or_die(opt, arg, 1);
270 } else if (po->flags & OPT_FLOAT) {
271 *(float*)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
272 } else if (po->flags & OPT_DOUBLE) {
273 *(double*)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
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
287 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
288 void (* parse_arg_function)(void *, const char*))
289 {
290 const char *opt;
291 int optindex, handleoptions = 1, ret;
292
293 /* perform system-dependent conversions for arguments list */
294 prepare_app_arguments(&argc, &argv);
295
296 /* parse options */
297 optindex = 1;
298 while (optindex < argc) {
299 opt = argv[optindex++];
300
301 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
302 if (opt[1] == '-' && opt[2] == '\0') {
303 handleoptions = 0;
304 continue;
305 }
306 opt++;
307
308 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
309 exit_program(1);
310 optindex += ret;
311 } else {
312 if (parse_arg_function)
313 parse_arg_function(optctx, opt);
314 }
315 }
316 }
317
318 /*
319 * Return index of option opt in argv or 0 if not found.
320 */
321 static 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
346 void parse_loglevel(int argc, char **argv, const OptionDef *options)
347 {
348 int idx = locate_option(argc, argv, options, "loglevel");
349 if (!idx)
350 idx = locate_option(argc, argv, options, "v");
351 if (idx && argv[idx + 1])
352 opt_loglevel("loglevel", argv[idx + 1]);
353 }
354
355 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
356 int opt_default(const char *opt, const char *arg)
357 {
358 const AVOption *o;
359 char opt_stripped[128];
360 const char *p;
361 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
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
367 if ((o = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) ||
368 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
369 (o = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
370 av_dict_set(&codec_opts, opt, arg, FLAGS);
371 else if ((o = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
372 av_dict_set(&format_opts, opt, arg, FLAGS);
373 else if ((o = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
374 // XXX we only support sws_flags, not arbitrary sws options
375 int ret = av_opt_set(sws_opts, opt, arg, 0);
376 if (ret < 0) {
377 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
378 return ret;
379 }
380 }
381
382 if (o)
383 return 0;
384 av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
385 return AVERROR_OPTION_NOT_FOUND;
386 }
387
388 int opt_loglevel(const char *opt, const char *arg)
389 {
390 const struct { const char *name; int level; } log_levels[] = {
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) {
413 av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
414 "Possible levels are numbers or:\n", arg);
415 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
416 av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
417 exit_program(1);
418 }
419 av_log_set_level(level);
420 return 0;
421 }
422
423 int opt_timelimit(const char *opt, const char *arg)
424 {
425 #if HAVE_SETRLIMIT
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
431 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
432 #endif
433 return 0;
434 }
435
436 void print_error(const char *filename, int err)
437 {
438 char errbuf[128];
439 const char *errbuf_ptr = errbuf;
440
441 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
442 errbuf_ptr = strerror(AVUNERROR(err));
443 av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
444 }
445
446 static int warned_cfg = 0;
447
448 #define INDENT 1
449 #define SHOW_VERSION 2
450 #define SHOW_CONFIG 4
451
452 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
453 if (CONFIG_##LIBNAME) { \
454 const char *indent = flags & INDENT? " " : ""; \
455 if (flags & SHOW_VERSION) { \
456 unsigned int version = libname##_version(); \
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); \
463 } \
464 if (flags & SHOW_CONFIG) { \
465 const char *cfg = libname##_configuration(); \
466 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
467 if (!warned_cfg) { \
468 av_log(NULL, level, \
469 "%sWARNING: library configuration mismatch\n", \
470 indent); \
471 warned_cfg = 1; \
472 } \
473 av_log(NULL, level, "%s%-11s configuration: %s\n", \
474 indent, #libname, cfg); \
475 } \
476 } \
477 } \
478
479 static void print_all_libs_info(int flags, int level)
480 {
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);
488 }
489
490 void show_banner(void)
491 {
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);
499 }
500
501 void show_version(void) {
502 av_log_set_callback(log_callback_help);
503 printf("%s " LIBAV_VERSION "\n", program_name);
504 print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
505 }
506
507 void show_license(void)
508 {
509 printf(
510 #if CONFIG_NONFREE
511 "This version of %s has nonfree parts compiled in.\n"
512 "Therefore it is not legally redistributable.\n",
513 program_name
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
528 #elif CONFIG_GPL
529 "%s is free software; you can redistribute it and/or modify\n"
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"
534 "%s is distributed in the hope that it will be useful,\n"
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"
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
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
557 #else
558 "%s is free software; you can redistribute it and/or\n"
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"
563 "%s is distributed in the hope that it will be useful,\n"
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"
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
572 #endif
573 );
574 }
575
576 void show_formats(void)
577 {
578 AVInputFormat *ifmt=NULL;
579 AVOutputFormat *ofmt=NULL;
580 const char *last_name;
581
582 printf(
583 "File formats:\n"
584 " D. = Demuxing supported\n"
585 " .E = Muxing supported\n"
586 " --\n");
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 }
623 }
624
625 void show_codecs(void)
626 {
627 AVCodec *p=NULL, *p2;
628 const char *last_name;
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");
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) {
665 case AVMEDIA_TYPE_VIDEO:
666 type_str = "V";
667 break;
668 case AVMEDIA_TYPE_AUDIO:
669 type_str = "A";
670 break;
671 case AVMEDIA_TYPE_SUBTITLE:
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");
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
701 void show_bsfs(void)
702 {
703 AVBitStreamFilter *bsf=NULL;
704
705 printf("Bitstream filters:\n");
706 while((bsf = av_bitstream_filter_next(bsf)))
707 printf("%s\n", bsf->name);
708 printf("\n");
709 }
710
711 void show_protocols(void)
712 {
713 void *opaque = NULL;
714 const char *name;
715
716 printf("Supported file protocols:\n"
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);
723 }
724
725 void show_filters(void)
726 {
727 AVFilter av_unused(**filter) = NULL;
728
729 printf("Filters:\n");
730 #if CONFIG_AVFILTER
731 while ((filter = av_filter_next(filter)) && *filter)
732 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
733 #endif
734 }
735
736 void show_pix_fmts(void)
737 {
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
750 #if !CONFIG_SWSCALE
751 # define sws_isSupportedInput(x) 0
752 # define sws_isSupportedOutput(x) 0
753 #endif
754
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 }
767 }
768
769 int 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
778 int 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 }
788
789 int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
790 {
791 int ret;
792 FILE *f = fopen(filename, "rb");
793
794 if (!f) {
795 av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
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) {
803 av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
804 fclose(f);
805 return AVERROR(ENOMEM);
806 }
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 }
820
821 fclose(f);
822 return ret;
823 }
824
825 void 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
831 int64_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 }
843 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
844 && reordered_pts != AV_NOPTS_VALUE)
845 pts = reordered_pts;
846 else
847 pts = dts;
848
849 return pts;
850 }
851
852 FILE *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;
857 const char *base[3]= { getenv("AVCONV_DATADIR"),
858 getenv("HOME"),
859 AVCONV_DATADIR,
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;
869 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", preset_name);
870 f = fopen(filename, "r");
871 if (!f && codec_name) {
872 snprintf(filename, filename_size,
873 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.avconv", codec_name, preset_name);
874 f = fopen(filename, "r");
875 }
876 }
877 }
878
879 return f;
880 }
881
882 int 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;
886 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
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;
894 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
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;
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);
917 return stream_idx >= 0 &&
918 stream_idx < s->programs[i]->nb_stream_indexes &&
919 st->index == s->programs[i]->stream_index[stream_idx];
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;
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
934 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
935 {
936 AVDictionary *ret = NULL;
937 AVDictionaryEntry *t = NULL;
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;
940 char prefix = 0;
941 const AVClass *cc = avcodec_get_class();
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)) {
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
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)))
965 av_dict_set(&ret, t->key, t->value, 0);
966 else if (t->key[0] == prefix && av_opt_find(&cc, t->key+1, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ))
967 av_dict_set(&ret, t->key+1, t->value, 0);
968
969 if (p)
970 *p = ':';
971 }
972 return ret;
973 }
974
975 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
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++)
988 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
989 return opts;
990 }
991
992 #if CONFIG_AVFILTER
993
994 static 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
1005 static void null_end_frame(AVFilterLink *inlink) { }
1006
1007 static 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
1016 AVFilter 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
1031 int 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;
1049 frame->key_frame = picref->video->key_frame;
1050 frame->pict_type = picref->video->pict_type;
1051 frame->sample_aspect_ratio = picref->video->pixel_aspect;
1052
1053 return 1;
1054 }
1055
1056 #endif /* CONFIG_AVFILTER */
1057
1058 void *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 }