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