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