projects / libav.git / blob
? search:


b375378af9a189d335d7413c4ae429450aaedc49
[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/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/eval.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/opt.h"
43 #include "cmdutils.h"
44 #include "version.h"
45 #if CONFIG_NETWORK
46 #include "libavformat/network.h"
47 #endif
48 #if HAVE_SYS_RESOURCE_H
49 #include <sys/resource.h>
50 #endif
51
52 const char **opt_names;
53 const char **opt_values;
54 static int opt_name_count;
55 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
56 AVFormatContext *avformat_opts;
57 struct SwsContext *sws_opts;
58 AVDictionary *format_opts, *codec_opts;
59
60 static const int this_year = 2011;
61
62 void init_opts(void)
63 {
64 int i;
65 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
66 avcodec_opts[i] = avcodec_alloc_context3(NULL);
67 avformat_opts = avformat_alloc_context();
68 #if CONFIG_SWSCALE
69 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
70 #endif
71 }
72
73 void uninit_opts(void)
74 {
75 int i;
76 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
77 av_freep(&avcodec_opts[i]);
78 av_freep(&avformat_opts->key);
79 av_freep(&avformat_opts);
80 #if CONFIG_SWSCALE
81 sws_freeContext(sws_opts);
82 sws_opts = NULL;
83 #endif
84 for (i = 0; i < opt_name_count; i++) {
85 //opt_values are only stored for codec-specific options in which case
86 //both the name and value are dup'd
87 if (opt_values[i]) {
88 av_freep(&opt_names[i]);
89 av_freep(&opt_values[i]);
90 }
91 }
92 av_freep(&opt_names);
93 av_freep(&opt_values);
94 opt_name_count = 0;
95 av_dict_free(&format_opts);
96 av_dict_free(&codec_opts);
97 }
98
99 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
100 {
101 vfprintf(stdout, fmt, vl);
102 }
103
104 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
105 {
106 char *tail;
107 const char *error;
108 double d = av_strtod(numstr, &tail);
109 if (*tail)
110 error= "Expected number for %s but found: %s\n";
111 else if (d < min || d > max)
112 error= "The value for %s was %s which is not within %f - %f\n";
113 else if(type == OPT_INT64 && (int64_t)d != d)
114 error= "Expected int64 for %s but found %s\n";
115 else if (type == OPT_INT && (int)d != d)
116 error= "Expected int for %s but found %s\n";
117 else
118 return d;
119 fprintf(stderr, error, context, numstr, min, max);
120 exit(1);
121 }
122
123 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
124 {
125 int64_t us;
126 if (av_parse_time(&us, timestr, is_duration) < 0) {
127 fprintf(stderr, "Invalid %s specification for %s: %s\n",
128 is_duration ? "duration" : "date", context, timestr);
129 exit(1);
130 }
131 return us;
132 }
133
134 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
135 {
136 const OptionDef *po;
137 int first;
138
139 first = 1;
140 for(po = options; po->name != NULL; po++) {
141 char buf[64];
142 if ((po->flags & mask) == value) {
143 if (first) {
144 printf("%s", msg);
145 first = 0;
146 }
147 av_strlcpy(buf, po->name, sizeof(buf));
148 if (po->flags & HAS_ARG) {
149 av_strlcat(buf, " ", sizeof(buf));
150 av_strlcat(buf, po->argname, sizeof(buf));
151 }
152 printf("-%-17s %s\n", buf, po->help);
153 }
154 }
155 }
156
157 static const OptionDef* find_option(const OptionDef *po, const char *name){
158 while (po->name != NULL) {
159 if (!strcmp(name, po->name))
160 break;
161 po++;
162 }
163 return po;
164 }
165
166 #if defined(_WIN32) && !defined(__MINGW32CE__)
167 #include <windows.h>
168 /* Will be leaked on exit */
169 static char** win32_argv_utf8 = NULL;
170 static int win32_argc = 0;
171
172 /**
173 * Prepare command line arguments for executable.
174 * For Windows - perform wide-char to UTF-8 conversion.
175 * Input arguments should be main() function arguments.
176 * @param argc_ptr Arguments number (including executable)
177 * @param argv_ptr Arguments list.
178 */
179 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
180 {
181 char *argstr_flat;
182 wchar_t **argv_w;
183 int i, buffsize = 0, offset = 0;
184
185 if (win32_argv_utf8) {
186 *argc_ptr = win32_argc;
187 *argv_ptr = win32_argv_utf8;
188 return;
189 }
190
191 win32_argc = 0;
192 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
193 if (win32_argc <= 0 || !argv_w)
194 return;
195
196 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
197 for (i = 0; i < win32_argc; i++)
198 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
199 NULL, 0, NULL, NULL);
200
201 win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
202 argstr_flat = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
203 if (win32_argv_utf8 == NULL) {
204 LocalFree(argv_w);
205 return;
206 }
207
208 for (i = 0; i < win32_argc; i++) {
209 win32_argv_utf8[i] = &argstr_flat[offset];
210 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
211 &argstr_flat[offset],
212 buffsize - offset, NULL, NULL);
213 }
214 win32_argv_utf8[i] = NULL;
215 LocalFree(argv_w);
216
217 *argc_ptr = win32_argc;
218 *argv_ptr = win32_argv_utf8;
219 }
220 #else
221 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
222 {
223 /* nothing to do */
224 }
225 #endif /* WIN32 && !__MINGW32CE__ */
226
227 void parse_options(int argc, char **argv, const OptionDef *options,
228 void (* parse_arg_function)(const char*))
229 {
230 const char *opt, *arg;
231 int optindex, handleoptions=1;
232 const OptionDef *po;
233
234 /* perform system-dependent conversions for arguments list */
235 prepare_app_arguments(&argc, &argv);
236
237 /* parse options */
238 optindex = 1;
239 while (optindex < argc) {
240 opt = argv[optindex++];
241
242 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
243 int bool_val = 1;
244 if (opt[1] == '-' && opt[2] == '\0') {
245 handleoptions = 0;
246 continue;
247 }
248 opt++;
249 po= find_option(options, opt);
250 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
251 /* handle 'no' bool option */
252 po = find_option(options, opt + 2);
253 if (!(po->name && (po->flags & OPT_BOOL)))
254 goto unknown_opt;
255 bool_val = 0;
256 }
257 if (!po->name)
258 po= find_option(options, "default");
259 if (!po->name) {
260 unknown_opt:
261 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
262 exit(1);
263 }
264 arg = NULL;
265 if (po->flags & HAS_ARG) {
266 arg = argv[optindex++];
267 if (!arg) {
268 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
269 exit(1);
270 }
271 }
272 if (po->flags & OPT_STRING) {
273 char *str;
274 str = av_strdup(arg);
275 *po->u.str_arg = str;
276 } else if (po->flags & OPT_BOOL) {
277 *po->u.int_arg = bool_val;
278 } else if (po->flags & OPT_INT) {
279 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
280 } else if (po->flags & OPT_INT64) {
281 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
282 } else if (po->flags & OPT_FLOAT) {
283 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
284 } else if (po->u.func_arg) {
285 if (po->u.func_arg(opt, arg) < 0) {
286 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
287 exit(1);
288 }
289 }
290 if(po->flags & OPT_EXIT)
291 exit(0);
292 } else {
293 if (parse_arg_function)
294 parse_arg_function(opt);
295 }
296 }
297 }
298
299 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
300 static int opt_default2(const char *opt, const char *arg)
301 {
302 const AVOption *o;
303 if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)) ||
304 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
305 (o = av_opt_find(avcodec_opts[0], opt+1, NULL, 0, 0))))
306 av_dict_set(&codec_opts, opt, arg, FLAGS);
307 else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
308 av_dict_set(&format_opts, opt, arg, FLAGS);
309 else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
310 // XXX we only support sws_flags, not arbitrary sws options
311 int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
312 if (ret < 0) {
313 av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
314 return ret;
315 }
316 }
317
318 if (o)
319 return 0;
320 fprintf(stderr, "Unrecognized option '%s'\n", opt);
321 return AVERROR_OPTION_NOT_FOUND;
322 }
323
324 int opt_default(const char *opt, const char *arg){
325 int type;
326 int ret= 0;
327 const AVOption *o= NULL;
328 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
329
330 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
331 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
332 if(o2)
333 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
334 }
335 if(!o && avformat_opts)
336 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
337 if(!o && sws_opts)
338 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
339 if(!o){
340 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
341 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
342 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
343 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
344 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
345 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
346 }
347 if (o && ret < 0) {
348 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
349 exit(1);
350 }
351 if (!o) {
352 AVCodec *p = NULL;
353 AVOutputFormat *oformat = NULL;
354 while ((p=av_codec_next(p))){
355 const AVClass *c = p->priv_class;
356 if(c && av_opt_find(&c, opt, NULL, 0, 0))
357 break;
358 }
359 if (!p) {
360 while ((oformat = av_oformat_next(oformat))) {
361 const AVClass *c = oformat->priv_class;
362 if (c && av_opt_find(&c, opt, NULL, 0, 0))
363 break;
364 }
365 }
366 }
367
368 if ((ret = opt_default2(opt, arg)) < 0)
369 return ret;
370
371 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
372
373 //FIXME we should always use avcodec_opts, ... for storing options so there will not be any need to keep track of what i set over this
374 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
375 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
376 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
377 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
378
379 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
380 av_log_set_level(AV_LOG_DEBUG);
381 return 0;
382 }
383
384 int opt_loglevel(const char *opt, const char *arg)
385 {
386 const struct { const char *name; int level; } log_levels[] = {
387 { "quiet" , AV_LOG_QUIET },
388 { "panic" , AV_LOG_PANIC },
389 { "fatal" , AV_LOG_FATAL },
390 { "error" , AV_LOG_ERROR },
391 { "warning", AV_LOG_WARNING },
392 { "info" , AV_LOG_INFO },
393 { "verbose", AV_LOG_VERBOSE },
394 { "debug" , AV_LOG_DEBUG },
395 };
396 char *tail;
397 int level;
398 int i;
399
400 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
401 if (!strcmp(log_levels[i].name, arg)) {
402 av_log_set_level(log_levels[i].level);
403 return 0;
404 }
405 }
406
407 level = strtol(arg, &tail, 10);
408 if (*tail) {
409 fprintf(stderr, "Invalid loglevel \"%s\". "
410 "Possible levels are numbers or:\n", arg);
411 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
412 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
413 exit(1);
414 }
415 av_log_set_level(level);
416 return 0;
417 }
418
419 int opt_timelimit(const char *opt, const char *arg)
420 {
421 #if HAVE_SETRLIMIT
422 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
423 struct rlimit rl = { lim, lim + 1 };
424 if (setrlimit(RLIMIT_CPU, &rl))
425 perror("setrlimit");
426 #else
427 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
428 #endif
429 return 0;
430 }
431
432 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
433 {
434 int i;
435 void *priv_ctx=NULL;
436 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
437 AVCodecContext *avctx= ctx;
438 if(codec && codec->priv_class && avctx->priv_data){
439 priv_ctx= avctx->priv_data;
440 }
441 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
442 AVFormatContext *avctx = ctx;
443 if (avctx->oformat && avctx->oformat->priv_class) {
444 priv_ctx = avctx->priv_data;
445 }
446 }
447
448 for(i=0; i<opt_name_count; i++){
449 char buf[256];
450 const AVOption *opt;
451 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
452 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
453 if(str && ((opt->flags & flags) == flags))
454 av_set_string3(ctx, opt_names[i], str, 1, NULL);
455 /* We need to use a differnt system to pass options to the private context because
456 it is not known which codec and thus context kind that will be when parsing options
457 we thus use opt_values directly instead of opts_ctx */
458 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
459 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
460 }
461 }
462 }
463
464 void print_error(const char *filename, int err)
465 {
466 char errbuf[128];
467 const char *errbuf_ptr = errbuf;
468
469 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
470 errbuf_ptr = strerror(AVUNERROR(err));
471 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
472 }
473
474 static int warned_cfg = 0;
475
476 #define INDENT 1
477 #define SHOW_VERSION 2
478 #define SHOW_CONFIG 4
479
480 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
481 if (CONFIG_##LIBNAME) { \
482 const char *indent = flags & INDENT? " " : ""; \
483 if (flags & SHOW_VERSION) { \
484 unsigned int version = libname##_version(); \
485 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
486 indent, #libname, \
487 LIB##LIBNAME##_VERSION_MAJOR, \
488 LIB##LIBNAME##_VERSION_MINOR, \
489 LIB##LIBNAME##_VERSION_MICRO, \
490 version >> 16, version >> 8 & 0xff, version & 0xff); \
491 } \
492 if (flags & SHOW_CONFIG) { \
493 const char *cfg = libname##_configuration(); \
494 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
495 if (!warned_cfg) { \
496 fprintf(outstream, \
497 "%sWARNING: library configuration mismatch\n", \
498 indent); \
499 warned_cfg = 1; \
500 } \
501 fprintf(stderr, "%s%-11s configuration: %s\n", \
502 indent, #libname, cfg); \
503 } \
504 } \
505 } \
506
507 static void print_all_libs_info(FILE* outstream, int flags)
508 {
509 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
510 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
511 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
512 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
513 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
514 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
515 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
516 }
517
518 void show_banner(void)
519 {
520 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
521 program_name, program_birth_year, this_year);
522 fprintf(stderr, " built on %s %s with %s %s\n",
523 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
524 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
525 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
526 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
527 }
528
529 void show_version(void) {
530 printf("%s " LIBAV_VERSION "\n", program_name);
531 print_all_libs_info(stdout, SHOW_VERSION);
532 }
533
534 void show_license(void)
535 {
536 printf(
537 #if CONFIG_NONFREE
538 "This version of %s has nonfree parts compiled in.\n"
539 "Therefore it is not legally redistributable.\n",
540 program_name
541 #elif CONFIG_GPLV3
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 3 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, see <http://www.gnu.org/licenses/>.\n",
554 program_name, program_name, program_name
555 #elif CONFIG_GPL
556 "%s is free software; you can redistribute it and/or modify\n"
557 "it under the terms of the GNU General Public License as published by\n"
558 "the Free Software Foundation; either version 2 of the License, or\n"
559 "(at your option) any later version.\n"
560 "\n"
561 "%s is distributed in the hope that it will be useful,\n"
562 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
563 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
564 "GNU General Public License for more details.\n"
565 "\n"
566 "You should have received a copy of the GNU General Public License\n"
567 "along with %s; if not, write to the Free Software\n"
568 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
569 program_name, program_name, program_name
570 #elif CONFIG_LGPLV3
571 "%s is free software; you can redistribute it and/or modify\n"
572 "it under the terms of the GNU Lesser General Public License as published by\n"
573 "the Free Software Foundation; either version 3 of the License, or\n"
574 "(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\n"
579 "GNU Lesser General Public License for more details.\n"
580 "\n"
581 "You should have received a copy of the GNU Lesser General Public License\n"
582 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
583 program_name, program_name, program_name
584 #else
585 "%s is free software; you can redistribute it and/or\n"
586 "modify it under the terms of the GNU Lesser General Public\n"
587 "License as published by the Free Software Foundation; either\n"
588 "version 2.1 of the License, or (at your option) any later version.\n"
589 "\n"
590 "%s is distributed in the hope that it will be useful,\n"
591 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
592 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
593 "Lesser General Public License for more details.\n"
594 "\n"
595 "You should have received a copy of the GNU Lesser General Public\n"
596 "License along with %s; if not, write to the Free Software\n"
597 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
598 program_name, program_name, program_name
599 #endif
600 );
601 }
602
603 void show_formats(void)
604 {
605 AVInputFormat *ifmt=NULL;
606 AVOutputFormat *ofmt=NULL;
607 const char *last_name;
608
609 printf(
610 "File formats:\n"
611 " D. = Demuxing supported\n"
612 " .E = Muxing supported\n"
613 " --\n");
614 last_name= "000";
615 for(;;){
616 int decode=0;
617 int encode=0;
618 const char *name=NULL;
619 const char *long_name=NULL;
620
621 while((ofmt= av_oformat_next(ofmt))) {
622 if((name == NULL || strcmp(ofmt->name, name)<0) &&
623 strcmp(ofmt->name, last_name)>0){
624 name= ofmt->name;
625 long_name= ofmt->long_name;
626 encode=1;
627 }
628 }
629 while((ifmt= av_iformat_next(ifmt))) {
630 if((name == NULL || strcmp(ifmt->name, name)<0) &&
631 strcmp(ifmt->name, last_name)>0){
632 name= ifmt->name;
633 long_name= ifmt->long_name;
634 encode=0;
635 }
636 if(name && strcmp(ifmt->name, name)==0)
637 decode=1;
638 }
639 if(name==NULL)
640 break;
641 last_name= name;
642
643 printf(
644 " %s%s %-15s %s\n",
645 decode ? "D":" ",
646 encode ? "E":" ",
647 name,
648 long_name ? long_name:" ");
649 }
650 }
651
652 void show_codecs(void)
653 {
654 AVCodec *p=NULL, *p2;
655 const char *last_name;
656 printf(
657 "Codecs:\n"
658 " D..... = Decoding supported\n"
659 " .E.... = Encoding supported\n"
660 " ..V... = Video codec\n"
661 " ..A... = Audio codec\n"
662 " ..S... = Subtitle codec\n"
663 " ...S.. = Supports draw_horiz_band\n"
664 " ....D. = Supports direct rendering method 1\n"
665 " .....T = Supports weird frame truncation\n"
666 " ------\n");
667 last_name= "000";
668 for(;;){
669 int decode=0;
670 int encode=0;
671 int cap=0;
672 const char *type_str;
673
674 p2=NULL;
675 while((p= av_codec_next(p))) {
676 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
677 strcmp(p->name, last_name)>0){
678 p2= p;
679 decode= encode= cap=0;
680 }
681 if(p2 && strcmp(p->name, p2->name)==0){
682 if(p->decode) decode=1;
683 if(p->encode) encode=1;
684 cap |= p->capabilities;
685 }
686 }
687 if(p2==NULL)
688 break;
689 last_name= p2->name;
690
691 switch(p2->type) {
692 case AVMEDIA_TYPE_VIDEO:
693 type_str = "V";
694 break;
695 case AVMEDIA_TYPE_AUDIO:
696 type_str = "A";
697 break;
698 case AVMEDIA_TYPE_SUBTITLE:
699 type_str = "S";
700 break;
701 default:
702 type_str = "?";
703 break;
704 }
705 printf(
706 " %s%s%s%s%s%s %-15s %s",
707 decode ? "D": (/*p2->decoder ? "d":*/" "),
708 encode ? "E":" ",
709 type_str,
710 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
711 cap & CODEC_CAP_DR1 ? "D":" ",
712 cap & CODEC_CAP_TRUNCATED ? "T":" ",
713 p2->name,
714 p2->long_name ? p2->long_name : "");
715 /* if(p2->decoder && decode==0)
716 printf(" use %s for decoding", p2->decoder->name);*/
717 printf("\n");
718 }
719 printf("\n");
720 printf(
721 "Note, the names of encoders and decoders do not always match, so there are\n"
722 "several cases where the above table shows encoder only or decoder only entries\n"
723 "even though both encoding and decoding are supported. For example, the h263\n"
724 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
725 "worse.\n");
726 }
727
728 void show_bsfs(void)
729 {
730 AVBitStreamFilter *bsf=NULL;
731
732 printf("Bitstream filters:\n");
733 while((bsf = av_bitstream_filter_next(bsf)))
734 printf("%s\n", bsf->name);
735 printf("\n");
736 }
737
738 void show_protocols(void)
739 {
740 void *opaque = NULL;
741 const char *name;
742
743 printf("Supported file protocols:\n"
744 "Input:\n");
745 while ((name = avio_enum_protocols(&opaque, 0)))
746 printf("%s\n", name);
747 printf("Output:\n");
748 while ((name = avio_enum_protocols(&opaque, 1)))
749 printf("%s\n", name);
750 }
751
752 void show_filters(void)
753 {
754 AVFilter av_unused(**filter) = NULL;
755
756 printf("Filters:\n");
757 #if CONFIG_AVFILTER
758 while ((filter = av_filter_next(filter)) && *filter)
759 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
760 #endif
761 }
762
763 void show_pix_fmts(void)
764 {
765 enum PixelFormat pix_fmt;
766
767 printf(
768 "Pixel formats:\n"
769 "I.... = Supported Input format for conversion\n"
770 ".O... = Supported Output format for conversion\n"
771 "..H.. = Hardware accelerated format\n"
772 "...P. = Paletted format\n"
773 "....B = Bitstream format\n"
774 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
775 "-----\n");
776
777 #if !CONFIG_SWSCALE
778 # define sws_isSupportedInput(x) 0
779 # define sws_isSupportedOutput(x) 0
780 #endif
781
782 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
783 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
784 printf("%c%c%c%c%c %-16s %d %2d\n",
785 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
786 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
787 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
788 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
789 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
790 pix_desc->name,
791 pix_desc->nb_components,
792 av_get_bits_per_pixel(pix_desc));
793 }
794 }
795
796 int read_yesno(void)
797 {
798 int c = getchar();
799 int yesno = (toupper(c) == 'Y');
800
801 while (c != '\n' && c != EOF)
802 c = getchar();
803
804 return yesno;
805 }
806
807 int read_file(const char *filename, char **bufptr, size_t *size)
808 {
809 FILE *f = fopen(filename, "rb");
810
811 if (!f) {
812 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
813 return AVERROR(errno);
814 }
815 fseek(f, 0, SEEK_END);
816 *size = ftell(f);
817 fseek(f, 0, SEEK_SET);
818 *bufptr = av_malloc(*size + 1);
819 if (!*bufptr) {
820 fprintf(stderr, "Could not allocate file buffer\n");
821 fclose(f);
822 return AVERROR(ENOMEM);
823 }
824 fread(*bufptr, 1, *size, f);
825 (*bufptr)[*size++] = '\0';
826
827 fclose(f);
828 return 0;
829 }
830
831 void init_pts_correction(PtsCorrectionContext *ctx)
832 {
833 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
834 ctx->last_pts = ctx->last_dts = INT64_MIN;
835 }
836
837 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
838 {
839 int64_t pts = AV_NOPTS_VALUE;
840
841 if (dts != AV_NOPTS_VALUE) {
842 ctx->num_faulty_dts += dts <= ctx->last_dts;
843 ctx->last_dts = dts;
844 }
845 if (reordered_pts != AV_NOPTS_VALUE) {
846 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
847 ctx->last_pts = reordered_pts;
848 }
849 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
850 && reordered_pts != AV_NOPTS_VALUE)
851 pts = reordered_pts;
852 else
853 pts = dts;
854
855 return pts;
856 }
857
858 FILE *get_preset_file(char *filename, size_t filename_size,
859 const char *preset_name, int is_path, const char *codec_name)
860 {
861 FILE *f = NULL;
862 int i;
863 const char *base[3]= { getenv("FFMPEG_DATADIR"),
864 getenv("HOME"),
865 FFMPEG_DATADIR,
866 };
867
868 if (is_path) {
869 av_strlcpy(filename, preset_name, filename_size);
870 f = fopen(filename, "r");
871 } else {
872 for (i = 0; i < 3 && !f; i++) {
873 if (!base[i])
874 continue;
875 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
876 f = fopen(filename, "r");
877 if (!f && codec_name) {
878 snprintf(filename, filename_size,
879 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
880 f = fopen(filename, "r");
881 }
882 }
883 }
884
885 return f;
886 }
887
888 AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, int encoder)
889 {
890 AVDictionary *ret = NULL;
891 AVDictionaryEntry *t = NULL;
892 AVCodec *codec = encoder ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
893 int flags = encoder ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
894 char prefix = 0;
895
896 if (!codec)
897 return NULL;
898
899 switch (codec->type) {
900 case AVMEDIA_TYPE_VIDEO: prefix = 'v'; flags |= AV_OPT_FLAG_VIDEO_PARAM; break;
901 case AVMEDIA_TYPE_AUDIO: prefix = 'a'; flags |= AV_OPT_FLAG_AUDIO_PARAM; break;
902 case AVMEDIA_TYPE_SUBTITLE: prefix = 's'; flags |= AV_OPT_FLAG_SUBTITLE_PARAM; break;
903 }
904
905 while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
906 if (av_opt_find(avcodec_opts[0], t->key, NULL, flags, 0) ||
907 (codec && codec->priv_class && av_opt_find(&codec->priv_class, t->key, NULL, flags, 0)))
908 av_dict_set(&ret, t->key, t->value, 0);
909 else if (t->key[0] == prefix && av_opt_find(avcodec_opts[0], t->key+1, NULL, flags, 0))
910 av_dict_set(&ret, t->key+1, t->value, 0);
911 }
912 return ret;
913 }
914
915 AVDictionary **setup_find_stream_info_opts(AVFormatContext *s)
916 {
917 int i;
918 AVDictionary **opts;
919
920 if (!s->nb_streams)
921 return NULL;
922 opts = av_mallocz(s->nb_streams * sizeof(*opts));
923 if (!opts) {
924 av_log(NULL, AV_LOG_ERROR, "Could not alloc memory for stream options.\n");
925 return NULL;
926 }
927 for (i = 0; i < s->nb_streams; i++)
928 opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, 0);
929 return opts;
930 }
931
932 #if CONFIG_AVFILTER
933
934 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
935 {
936 FFSinkContext *priv = ctx->priv;
937
938 if (!opaque)
939 return AVERROR(EINVAL);
940 *priv = *(FFSinkContext *)opaque;
941
942 return 0;
943 }
944
945 static void null_end_frame(AVFilterLink *inlink) { }
946
947 static int ffsink_query_formats(AVFilterContext *ctx)
948 {
949 FFSinkContext *priv = ctx->priv;
950 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
951
952 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
953 return 0;
954 }
955
956 AVFilter ffsink = {
957 .name = "ffsink",
958 .priv_size = sizeof(FFSinkContext),
959 .init = ffsink_init,
960
961 .query_formats = ffsink_query_formats,
962
963 .inputs = (AVFilterPad[]) {{ .name = "default",
964 .type = AVMEDIA_TYPE_VIDEO,
965 .end_frame = null_end_frame,
966 .min_perms = AV_PERM_READ, },
967 { .name = NULL }},
968 .outputs = (AVFilterPad[]) {{ .name = NULL }},
969 };
970
971 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
972 AVFilterBufferRef **picref_ptr, AVRational *tb)
973 {
974 int ret;
975 AVFilterBufferRef *picref;
976
977 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
978 return ret;
979 if (!(picref = ctx->inputs[0]->cur_buf))
980 return AVERROR(ENOENT);
981 *picref_ptr = picref;
982 ctx->inputs[0]->cur_buf = NULL;
983 *tb = ctx->inputs[0]->time_base;
984
985 memcpy(frame->data, picref->data, sizeof(frame->data));
986 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
987 frame->interlaced_frame = picref->video->interlaced;
988 frame->top_field_first = picref->video->top_field_first;
989 frame->key_frame = picref->video->key_frame;
990 frame->pict_type = picref->video->pict_type;
991
992 return 1;
993 }
994
995 #endif /* CONFIG_AVFILTER */
Libav master