cmdutils: use sws_freeContext() instead of av_freep().
[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->flags & OPT_FUNC2) {
281 if (po->u.func2_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 } else if (po->u.func_arg) {
286 po->u.func_arg(arg);
287 }
288 if(po->flags & OPT_EXIT)
289 exit(0);
290 } else {
291 if (parse_arg_function)
292 parse_arg_function(opt);
293 }
294 }
295 }
296
297 int opt_default(const char *opt, const char *arg){
298 int type;
299 int ret= 0;
300 const AVOption *o= NULL;
301 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
302
303 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
304 const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
305 if(o2)
306 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
307 }
308 if(!o && avformat_opts)
309 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
310 if(!o && sws_opts)
311 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
312 if(!o){
313 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
314 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
315 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
316 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
317 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
318 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
319 }
320 if (o && ret < 0) {
321 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
322 exit(1);
323 }
324 if (!o) {
325 AVCodec *p = NULL;
326 AVOutputFormat *oformat = NULL;
327 while ((p=av_codec_next(p))){
328 AVClass *c= p->priv_class;
329 if(c && av_find_opt(&c, opt, NULL, 0, 0))
330 break;
331 }
332 if (!p) {
333 while ((oformat = av_oformat_next(oformat))) {
334 const AVClass *c = oformat->priv_class;
335 if (c && av_find_opt(&c, opt, NULL, 0, 0))
336 break;
337 }
338 }
339 if(!p && !oformat){
340 fprintf(stderr, "Unrecognized option '%s'\n", opt);
341 exit(1);
342 }
343 }
344
345 // 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));
346
347 //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
348 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
349 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
350 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
351 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
352
353 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
354 av_log_set_level(AV_LOG_DEBUG);
355 return 0;
356 }
357
358 int opt_loglevel(const char *opt, const char *arg)
359 {
360 const struct { const char *name; int level; } log_levels[] = {
361 { "quiet" , AV_LOG_QUIET },
362 { "panic" , AV_LOG_PANIC },
363 { "fatal" , AV_LOG_FATAL },
364 { "error" , AV_LOG_ERROR },
365 { "warning", AV_LOG_WARNING },
366 { "info" , AV_LOG_INFO },
367 { "verbose", AV_LOG_VERBOSE },
368 { "debug" , AV_LOG_DEBUG },
369 };
370 char *tail;
371 int level;
372 int i;
373
374 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
375 if (!strcmp(log_levels[i].name, arg)) {
376 av_log_set_level(log_levels[i].level);
377 return 0;
378 }
379 }
380
381 level = strtol(arg, &tail, 10);
382 if (*tail) {
383 fprintf(stderr, "Invalid loglevel \"%s\". "
384 "Possible levels are numbers or:\n", arg);
385 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
386 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
387 exit(1);
388 }
389 av_log_set_level(level);
390 return 0;
391 }
392
393 int opt_timelimit(const char *opt, const char *arg)
394 {
395 #if HAVE_SETRLIMIT
396 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
397 struct rlimit rl = { lim, lim + 1 };
398 if (setrlimit(RLIMIT_CPU, &rl))
399 perror("setrlimit");
400 #else
401 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
402 #endif
403 return 0;
404 }
405
406 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
407 {
408 int i;
409 void *priv_ctx=NULL;
410 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
411 AVCodecContext *avctx= ctx;
412 if(codec && codec->priv_class && avctx->priv_data){
413 priv_ctx= avctx->priv_data;
414 }
415 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
416 AVFormatContext *avctx = ctx;
417 if (avctx->oformat && avctx->oformat->priv_class) {
418 priv_ctx = avctx->priv_data;
419 }
420 }
421
422 for(i=0; i<opt_name_count; i++){
423 char buf[256];
424 const AVOption *opt;
425 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
426 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
427 if(str && ((opt->flags & flags) == flags))
428 av_set_string3(ctx, opt_names[i], str, 1, NULL);
429 /* We need to use a differnt system to pass options to the private context because
430 it is not known which codec and thus context kind that will be when parsing options
431 we thus use opt_values directly instead of opts_ctx */
432 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
433 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
434 }
435 }
436 }
437
438 void print_error(const char *filename, int err)
439 {
440 char errbuf[128];
441 const char *errbuf_ptr = errbuf;
442
443 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
444 errbuf_ptr = strerror(AVUNERROR(err));
445 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
446 }
447
448 static int warned_cfg = 0;
449
450 #define INDENT 1
451 #define SHOW_VERSION 2
452 #define SHOW_CONFIG 4
453
454 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
455 if (CONFIG_##LIBNAME) { \
456 const char *indent = flags & INDENT? " " : ""; \
457 if (flags & SHOW_VERSION) { \
458 unsigned int version = libname##_version(); \
459 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
460 indent, #libname, \
461 LIB##LIBNAME##_VERSION_MAJOR, \
462 LIB##LIBNAME##_VERSION_MINOR, \
463 LIB##LIBNAME##_VERSION_MICRO, \
464 version >> 16, version >> 8 & 0xff, version & 0xff); \
465 } \
466 if (flags & SHOW_CONFIG) { \
467 const char *cfg = libname##_configuration(); \
468 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
469 if (!warned_cfg) { \
470 fprintf(outstream, \
471 "%sWARNING: library configuration mismatch\n", \
472 indent); \
473 warned_cfg = 1; \
474 } \
475 fprintf(stderr, "%s%-11s configuration: %s\n", \
476 indent, #libname, cfg); \
477 } \
478 } \
479 } \
480
481 static void print_all_libs_info(FILE* outstream, int flags)
482 {
483 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
484 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
485 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
486 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
487 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
488 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
489 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
490 }
491
492 void show_banner(void)
493 {
494 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
495 program_name, program_birth_year, this_year);
496 fprintf(stderr, " built on %s %s with %s %s\n",
497 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
498 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
499 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
500 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
501 }
502
503 void show_version(void) {
504 printf("%s " LIBAV_VERSION "\n", program_name);
505 print_all_libs_info(stdout, SHOW_VERSION);
506 }
507
508 void show_license(void)
509 {
510 printf(
511 #if CONFIG_NONFREE
512 "This version of %s has nonfree parts compiled in.\n"
513 "Therefore it is not legally redistributable.\n",
514 program_name
515 #elif CONFIG_GPLV3
516 "%s is free software; you can redistribute it and/or modify\n"
517 "it under the terms of the GNU General Public License as published by\n"
518 "the Free Software Foundation; either version 3 of the License, or\n"
519 "(at your option) any later version.\n"
520 "\n"
521 "%s is distributed in the hope that it will be useful,\n"
522 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
523 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
524 "GNU General Public License for more details.\n"
525 "\n"
526 "You should have received a copy of the GNU General Public License\n"
527 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
528 program_name, program_name, program_name
529 #elif CONFIG_GPL
530 "%s is free software; you can redistribute it and/or modify\n"
531 "it under the terms of the GNU General Public License as published by\n"
532 "the Free Software Foundation; either version 2 of the License, or\n"
533 "(at your option) any later version.\n"
534 "\n"
535 "%s is distributed in the hope that it will be useful,\n"
536 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
537 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
538 "GNU General Public License for more details.\n"
539 "\n"
540 "You should have received a copy of the GNU General Public License\n"
541 "along with %s; if not, write to the Free Software\n"
542 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
543 program_name, program_name, program_name
544 #elif CONFIG_LGPLV3
545 "%s is free software; you can redistribute it and/or modify\n"
546 "it under the terms of the GNU Lesser General Public License as published by\n"
547 "the Free Software Foundation; either version 3 of the License, or\n"
548 "(at your option) any later version.\n"
549 "\n"
550 "%s is distributed in the hope that it will be useful,\n"
551 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
552 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
553 "GNU Lesser General Public License for more details.\n"
554 "\n"
555 "You should have received a copy of the GNU Lesser General Public License\n"
556 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
557 program_name, program_name, program_name
558 #else
559 "%s is free software; you can redistribute it and/or\n"
560 "modify it under the terms of the GNU Lesser General Public\n"
561 "License as published by the Free Software Foundation; either\n"
562 "version 2.1 of the License, or (at your option) any later version.\n"
563 "\n"
564 "%s is distributed in the hope that it will be useful,\n"
565 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
566 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
567 "Lesser General Public License for more details.\n"
568 "\n"
569 "You should have received a copy of the GNU Lesser General Public\n"
570 "License along with %s; if not, write to the Free Software\n"
571 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
572 program_name, program_name, program_name
573 #endif
574 );
575 }
576
577 void show_formats(void)
578 {
579 AVInputFormat *ifmt=NULL;
580 AVOutputFormat *ofmt=NULL;
581 const char *last_name;
582
583 printf(
584 "File formats:\n"
585 " D. = Demuxing supported\n"
586 " .E = Muxing supported\n"
587 " --\n");
588 last_name= "000";
589 for(;;){
590 int decode=0;
591 int encode=0;
592 const char *name=NULL;
593 const char *long_name=NULL;
594
595 while((ofmt= av_oformat_next(ofmt))) {
596 if((name == NULL || strcmp(ofmt->name, name)<0) &&
597 strcmp(ofmt->name, last_name)>0){
598 name= ofmt->name;
599 long_name= ofmt->long_name;
600 encode=1;
601 }
602 }
603 while((ifmt= av_iformat_next(ifmt))) {
604 if((name == NULL || strcmp(ifmt->name, name)<0) &&
605 strcmp(ifmt->name, last_name)>0){
606 name= ifmt->name;
607 long_name= ifmt->long_name;
608 encode=0;
609 }
610 if(name && strcmp(ifmt->name, name)==0)
611 decode=1;
612 }
613 if(name==NULL)
614 break;
615 last_name= name;
616
617 printf(
618 " %s%s %-15s %s\n",
619 decode ? "D":" ",
620 encode ? "E":" ",
621 name,
622 long_name ? long_name:" ");
623 }
624 }
625
626 void show_codecs(void)
627 {
628 AVCodec *p=NULL, *p2;
629 const char *last_name;
630 printf(
631 "Codecs:\n"
632 " D..... = Decoding supported\n"
633 " .E.... = Encoding supported\n"
634 " ..V... = Video codec\n"
635 " ..A... = Audio codec\n"
636 " ..S... = Subtitle codec\n"
637 " ...S.. = Supports draw_horiz_band\n"
638 " ....D. = Supports direct rendering method 1\n"
639 " .....T = Supports weird frame truncation\n"
640 " ------\n");
641 last_name= "000";
642 for(;;){
643 int decode=0;
644 int encode=0;
645 int cap=0;
646 const char *type_str;
647
648 p2=NULL;
649 while((p= av_codec_next(p))) {
650 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
651 strcmp(p->name, last_name)>0){
652 p2= p;
653 decode= encode= cap=0;
654 }
655 if(p2 && strcmp(p->name, p2->name)==0){
656 if(p->decode) decode=1;
657 if(p->encode) encode=1;
658 cap |= p->capabilities;
659 }
660 }
661 if(p2==NULL)
662 break;
663 last_name= p2->name;
664
665 switch(p2->type) {
666 case AVMEDIA_TYPE_VIDEO:
667 type_str = "V";
668 break;
669 case AVMEDIA_TYPE_AUDIO:
670 type_str = "A";
671 break;
672 case AVMEDIA_TYPE_SUBTITLE:
673 type_str = "S";
674 break;
675 default:
676 type_str = "?";
677 break;
678 }
679 printf(
680 " %s%s%s%s%s%s %-15s %s",
681 decode ? "D": (/*p2->decoder ? "d":*/" "),
682 encode ? "E":" ",
683 type_str,
684 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
685 cap & CODEC_CAP_DR1 ? "D":" ",
686 cap & CODEC_CAP_TRUNCATED ? "T":" ",
687 p2->name,
688 p2->long_name ? p2->long_name : "");
689 /* if(p2->decoder && decode==0)
690 printf(" use %s for decoding", p2->decoder->name);*/
691 printf("\n");
692 }
693 printf("\n");
694 printf(
695 "Note, the names of encoders and decoders do not always match, so there are\n"
696 "several cases where the above table shows encoder only or decoder only entries\n"
697 "even though both encoding and decoding are supported. For example, the h263\n"
698 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
699 "worse.\n");
700 }
701
702 void show_bsfs(void)
703 {
704 AVBitStreamFilter *bsf=NULL;
705
706 printf("Bitstream filters:\n");
707 while((bsf = av_bitstream_filter_next(bsf)))
708 printf("%s\n", bsf->name);
709 printf("\n");
710 }
711
712 void show_protocols(void)
713 {
714 void *opaque = NULL;
715 const char *name;
716
717 printf("Supported file protocols:\n"
718 "Input:\n");
719 while ((name = avio_enum_protocols(&opaque, 0)))
720 printf("%s\n", name);
721 printf("Output:\n");
722 while ((name = avio_enum_protocols(&opaque, 1)))
723 printf("%s\n", name);
724 }
725
726 void show_filters(void)
727 {
728 AVFilter av_unused(**filter) = NULL;
729
730 printf("Filters:\n");
731 #if CONFIG_AVFILTER
732 while ((filter = av_filter_next(filter)) && *filter)
733 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
734 #endif
735 }
736
737 void show_pix_fmts(void)
738 {
739 enum PixelFormat pix_fmt;
740
741 printf(
742 "Pixel formats:\n"
743 "I.... = Supported Input format for conversion\n"
744 ".O... = Supported Output format for conversion\n"
745 "..H.. = Hardware accelerated format\n"
746 "...P. = Paletted format\n"
747 "....B = Bitstream format\n"
748 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
749 "-----\n");
750
751 #if !CONFIG_SWSCALE
752 # define sws_isSupportedInput(x) 0
753 # define sws_isSupportedOutput(x) 0
754 #endif
755
756 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
757 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
758 printf("%c%c%c%c%c %-16s %d %2d\n",
759 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
760 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
761 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
762 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
763 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
764 pix_desc->name,
765 pix_desc->nb_components,
766 av_get_bits_per_pixel(pix_desc));
767 }
768 }
769
770 int read_yesno(void)
771 {
772 int c = getchar();
773 int yesno = (toupper(c) == 'Y');
774
775 while (c != '\n' && c != EOF)
776 c = getchar();
777
778 return yesno;
779 }
780
781 int read_file(const char *filename, char **bufptr, size_t *size)
782 {
783 FILE *f = fopen(filename, "rb");
784
785 if (!f) {
786 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
787 return AVERROR(errno);
788 }
789 fseek(f, 0, SEEK_END);
790 *size = ftell(f);
791 fseek(f, 0, SEEK_SET);
792 *bufptr = av_malloc(*size + 1);
793 if (!*bufptr) {
794 fprintf(stderr, "Could not allocate file buffer\n");
795 fclose(f);
796 return AVERROR(ENOMEM);
797 }
798 fread(*bufptr, 1, *size, f);
799 (*bufptr)[*size++] = '\0';
800
801 fclose(f);
802 return 0;
803 }
804
805 void init_pts_correction(PtsCorrectionContext *ctx)
806 {
807 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
808 ctx->last_pts = ctx->last_dts = INT64_MIN;
809 }
810
811 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
812 {
813 int64_t pts = AV_NOPTS_VALUE;
814
815 if (dts != AV_NOPTS_VALUE) {
816 ctx->num_faulty_dts += dts <= ctx->last_dts;
817 ctx->last_dts = dts;
818 }
819 if (reordered_pts != AV_NOPTS_VALUE) {
820 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
821 ctx->last_pts = reordered_pts;
822 }
823 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
824 && reordered_pts != AV_NOPTS_VALUE)
825 pts = reordered_pts;
826 else
827 pts = dts;
828
829 return pts;
830 }
831
832 FILE *get_preset_file(char *filename, size_t filename_size,
833 const char *preset_name, int is_path, const char *codec_name)
834 {
835 FILE *f = NULL;
836 int i;
837 const char *base[3]= { getenv("FFMPEG_DATADIR"),
838 getenv("HOME"),
839 FFMPEG_DATADIR,
840 };
841
842 if (is_path) {
843 av_strlcpy(filename, preset_name, filename_size);
844 f = fopen(filename, "r");
845 } else {
846 for (i = 0; i < 3 && !f; i++) {
847 if (!base[i])
848 continue;
849 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
850 f = fopen(filename, "r");
851 if (!f && codec_name) {
852 snprintf(filename, filename_size,
853 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
854 f = fopen(filename, "r");
855 }
856 }
857 }
858
859 return f;
860 }
861
862 #if CONFIG_AVFILTER
863
864 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
865 {
866 FFSinkContext *priv = ctx->priv;
867
868 if (!opaque)
869 return AVERROR(EINVAL);
870 *priv = *(FFSinkContext *)opaque;
871
872 return 0;
873 }
874
875 static void null_end_frame(AVFilterLink *inlink) { }
876
877 static int ffsink_query_formats(AVFilterContext *ctx)
878 {
879 FFSinkContext *priv = ctx->priv;
880 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
881
882 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
883 return 0;
884 }
885
886 AVFilter ffsink = {
887 .name = "ffsink",
888 .priv_size = sizeof(FFSinkContext),
889 .init = ffsink_init,
890
891 .query_formats = ffsink_query_formats,
892
893 .inputs = (AVFilterPad[]) {{ .name = "default",
894 .type = AVMEDIA_TYPE_VIDEO,
895 .end_frame = null_end_frame,
896 .min_perms = AV_PERM_READ, },
897 { .name = NULL }},
898 .outputs = (AVFilterPad[]) {{ .name = NULL }},
899 };
900
901 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
902 AVFilterBufferRef **picref_ptr, AVRational *tb)
903 {
904 int ret;
905 AVFilterBufferRef *picref;
906
907 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
908 return ret;
909 if (!(picref = ctx->inputs[0]->cur_buf))
910 return AVERROR(ENOENT);
911 *picref_ptr = picref;
912 ctx->inputs[0]->cur_buf = NULL;
913 *tb = ctx->inputs[0]->time_base;
914
915 memcpy(frame->data, picref->data, sizeof(frame->data));
916 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
917 frame->interlaced_frame = picref->video->interlaced;
918 frame->top_field_first = picref->video->top_field_first;
919 frame->key_frame = picref->video->key_frame;
920 frame->pict_type = picref->video->pict_type;
921
922 return 1;
923 }
924
925 #endif /* CONFIG_AVFILTER */