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