ffmpeg: check experimental flag after codec is opened.
[libav.git] / cmdutils.c
CommitLineData
01310af2
FB
1/*
2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
01310af2
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
01310af2 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
01310af2
FB
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
01310af2 20 */
364a9607 21
0f4e8165
RB
22#include <string.h>
23#include <stdlib.h>
24#include <errno.h>
7c84b8bc 25#include <math.h>
0f4e8165 26
2cd39dbf
DP
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
63d026b1 31#include "config.h"
245976da
DB
32#include "libavformat/avformat.h"
33#include "libavfilter/avfilter.h"
34#include "libavdevice/avdevice.h"
db6d50c7 35#include "libswscale/swscale.h"
1981deaf 36#include "libpostproc/postprocess.h"
245976da 37#include "libavutil/avstring.h"
f6c7375a 38#include "libavutil/parseutils.h"
9cb5c760 39#include "libavutil/pixdesc.h"
25e25617 40#include "libavutil/eval.h"
9ba38229 41#include "libavutil/dict.h"
41d0eb1c 42#include "libavutil/opt.h"
01310af2 43#include "cmdutils.h"
86074ed1 44#include "version.h"
da2dc39e 45#if CONFIG_NETWORK
245976da 46#include "libavformat/network.h"
da2dc39e 47#endif
ffcc6e24
MR
48#if HAVE_SYS_RESOURCE_H
49#include <sys/resource.h>
50#endif
01310af2 51
85663ef3 52const char **opt_names;
0093ebc2 53const char **opt_values;
85663ef3 54static int opt_name_count;
72415b2a 55AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
85663ef3
MN
56AVFormatContext *avformat_opts;
57struct SwsContext *sws_opts;
9ba38229 58AVDictionary *format_opts, *video_opts, *audio_opts, *sub_opts;
086ab001 59
3568853f 60static const int this_year = 2011;
ef4c0bb1 61
a5c33faa
RD
62void init_opts(void)
63{
64 int i;
65 for (i = 0; i < AVMEDIA_TYPE_NB; i++)
71a861cf 66 avcodec_opts[i] = avcodec_alloc_context3(NULL);
a5c33faa 67 avformat_opts = avformat_alloc_context();
be4876ea 68#if CONFIG_SWSCALE
a5c33faa 69 sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
be4876ea 70#endif
a5c33faa
RD
71}
72
73void 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);
be4876ea 80#if CONFIG_SWSCALE
faf8d3dd
RB
81 sws_freeContext(sws_opts);
82 sws_opts = NULL;
be4876ea 83#endif
60ff9de6
JZ
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 }
3a6a9cdf
JZ
92 av_freep(&opt_names);
93 av_freep(&opt_values);
19615089 94 opt_name_count = 0;
9ba38229
AK
95 av_dict_free(&format_opts);
96 av_dict_free(&video_opts);
97 av_dict_free(&audio_opts);
98 av_dict_free(&sub_opts);
a5c33faa
RD
99}
100
1790d3b3
SS
101void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
102{
103 vfprintf(stdout, fmt, vl);
104}
105
086ab001
MN
106double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
107{
108 char *tail;
109 const char *error;
25e25617 110 double d = av_strtod(numstr, &tail);
086ab001
MN
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";
3372ec32
SS
117 else if (type == OPT_INT && (int)d != d)
118 error= "Expected int for %s but found %s\n";
086ab001
MN
119 else
120 return d;
121 fprintf(stderr, error, context, numstr, min, max);
122 exit(1);
123}
124
7542157d
SS
125int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
126{
f6c7375a
SS
127 int64_t us;
128 if (av_parse_time(&us, timestr, is_duration) < 0) {
7542157d
SS
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
02d504a7 136void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
01310af2
FB
137{
138 const OptionDef *po;
02d504a7 139 int first;
01310af2 140
02d504a7
FB
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 }
f7d78f36 149 av_strlcpy(buf, po->name, sizeof(buf));
02d504a7 150 if (po->flags & HAS_ARG) {
f7d78f36
MR
151 av_strlcat(buf, " ", sizeof(buf));
152 av_strlcat(buf, po->argname, sizeof(buf));
01310af2 153 }
02d504a7 154 printf("-%-17s %s\n", buf, po->help);
01310af2
FB
155 }
156 }
157}
158
fccfc475 159static const OptionDef* find_option(const OptionDef *po, const char *name){
8bbf6db9
MN
160 while (po->name != NULL) {
161 if (!strcmp(name, po->name))
162 break;
163 po++;
164 }
165 return po;
166}
167
b1ac139d 168#if defined(_WIN32) && !defined(__MINGW32CE__)
ba9327ea 169#include <windows.h>
b1ac139d
KG
170/* Will be leaked on exit */
171static char** win32_argv_utf8 = NULL;
172static 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 */
181static 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
223static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
224{
225 /* nothing to do */
226}
227#endif /* WIN32 && !__MINGW32CE__ */
228
60a9966e
SS
229void parse_options(int argc, char **argv, const OptionDef *options,
230 void (* parse_arg_function)(const char*))
01310af2
FB
231{
232 const char *opt, *arg;
b0d7bc1e 233 int optindex, handleoptions=1;
01310af2
FB
234 const OptionDef *po;
235
b1ac139d
KG
236 /* perform system-dependent conversions for arguments list */
237 prepare_app_arguments(&argc, &argv);
238
01310af2
FB
239 /* parse options */
240 optindex = 1;
241 while (optindex < argc) {
242 opt = argv[optindex++];
115329f1 243
84bf226b 244 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
b1d6e5e8 245 int bool_val = 1;
3749076c
SS
246 if (opt[1] == '-' && opt[2] == '\0') {
247 handleoptions = 0;
248 continue;
249 }
c3c78324
SS
250 opt++;
251 po= find_option(options, opt);
252 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
b1d6e5e8 253 /* handle 'no' bool option */
c3c78324 254 po = find_option(options, opt + 2);
b1d6e5e8
BF
255 if (!(po->name && (po->flags & OPT_BOOL)))
256 goto unknown_opt;
257 bool_val = 0;
258 }
8bbf6db9
MN
259 if (!po->name)
260 po= find_option(options, "default");
01310af2 261 if (!po->name) {
8bbf6db9 262unknown_opt:
01310af2
FB
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;
02d504a7 276 str = av_strdup(arg);
01310af2
FB
277 *po->u.str_arg = str;
278 } else if (po->flags & OPT_BOOL) {
b1d6e5e8 279 *po->u.int_arg = bool_val;
26d4f26b 280 } else if (po->flags & OPT_INT) {
c3c78324 281 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
ffdf9a1f 282 } else if (po->flags & OPT_INT64) {
c3c78324 283 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
1f631450 284 } else if (po->flags & OPT_FLOAT) {
324e7ee2 285 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
de859358 286 } else if (po->u.func_arg) {
26513856 287 if (po->u.func_arg(opt, arg) < 0) {
330d86f5 288 fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
9e5381a2
SS
289 exit(1);
290 }
01310af2 291 }
a0b3bcd9
MN
292 if(po->flags & OPT_EXIT)
293 exit(0);
01310af2 294 } else {
60a9966e
SS
295 if (parse_arg_function)
296 parse_arg_function(opt);
01310af2
FB
297 }
298 }
299}
300
9ba38229
AK
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);
305static 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
85663ef3
MN
338int opt_default(const char *opt, const char *arg){
339 int type;
5c3383e5 340 int ret= 0;
85663ef3
MN
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
d860aaf8 344 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
dc59ec5e 345 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
85663ef3 346 if(o2)
636f1c4c 347 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
85663ef3 348 }
d860aaf8 349 if(!o && avformat_opts)
5c3383e5 350 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
da033b05 351 if(!o && sws_opts)
5c3383e5 352 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
85663ef3 353 if(!o){
819e2ab0 354 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
72415b2a 355 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
819e2ab0 356 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
72415b2a 357 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
819e2ab0 358 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
72415b2a 359 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
5c3383e5
SS
360 }
361 if (o && ret < 0) {
362 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
363 exit(1);
85663ef3 364 }
33bc7947 365 if (!o) {
0093ebc2 366 AVCodec *p = NULL;
ef2b2243 367 AVOutputFormat *oformat = NULL;
0093ebc2 368 while ((p=av_codec_next(p))){
42abb9a8 369 const AVClass *c = p->priv_class;
dc59ec5e 370 if(c && av_opt_find(&c, opt, NULL, 0, 0))
0093ebc2
MN
371 break;
372 }
ef2b2243
AH
373 if (!p) {
374 while ((oformat = av_oformat_next(oformat))) {
375 const AVClass *c = oformat->priv_class;
dc59ec5e 376 if (c && av_opt_find(&c, opt, NULL, 0, 0))
ef2b2243
AH
377 break;
378 }
379 }
33bc7947 380 }
85663ef3 381
9ba38229
AK
382 if ((ret = opt_default2(opt, arg)) < 0)
383 return ret;
384
636f1c4c 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));
85663ef3 386
636f1c4c 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
0093ebc2 388 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
60ff9de6 389 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
85663ef3 390 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
60ff9de6 391 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
85663ef3 392
20e021c7 393 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
85663ef3
MN
394 av_log_set_level(AV_LOG_DEBUG);
395 return 0;
396}
397
4c97a6fa
SS
398int opt_loglevel(const char *opt, const char *arg)
399{
da4c2dab 400 const struct { const char *name; int level; } log_levels[] = {
4c97a6fa
SS
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
ffcc6e24
MR
433int opt_timelimit(const char *opt, const char *arg)
434{
0104b608 435#if HAVE_SETRLIMIT
ffcc6e24
MR
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
0093ebc2 446void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
85663ef3
MN
447{
448 int i;
0093ebc2
MN
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 }
ef2b2243
AH
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 }
0093ebc2 460 }
ef2b2243 461
85663ef3
MN
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))
f16dd7e6 468 av_set_string3(ctx, opt_names[i], str, 1, NULL);
0093ebc2
MN
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 }
85663ef3
MN
475 }
476}
477
01310af2
FB
478void print_error(const char *filename, int err)
479{
7a5bdd79 480 char errbuf[128];
735ef67b 481 const char *errbuf_ptr = errbuf;
7a5bdd79 482
9e94bd3e
SS
483 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
484 errbuf_ptr = strerror(AVUNERROR(err));
485 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
01310af2 486}
f35917b2 487
d101e731
SS
488static int warned_cfg = 0;
489
208749a0
SS
490#define INDENT 1
491#define SHOW_VERSION 2
d101e731 492#define SHOW_CONFIG 4
208749a0 493
1044a92a 494#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
5116571d 495 if (CONFIG_##LIBNAME) { \
65dd2ded 496 const char *indent = flags & INDENT? " " : ""; \
208749a0 497 if (flags & SHOW_VERSION) { \
b6525b4b 498 unsigned int version = libname##_version(); \
c0dd5653 499 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
65dd2ded 500 indent, #libname, \
b6525b4b
SS
501 LIB##LIBNAME##_VERSION_MAJOR, \
502 LIB##LIBNAME##_VERSION_MINOR, \
503 LIB##LIBNAME##_VERSION_MICRO, \
504 version >> 16, version >> 8 & 0xff, version & 0xff); \
208749a0 505 } \
d101e731
SS
506 if (flags & SHOW_CONFIG) { \
507 const char *cfg = libname##_configuration(); \
29ba0911 508 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
d101e731
SS
509 if (!warned_cfg) { \
510 fprintf(outstream, \
511 "%sWARNING: library configuration mismatch\n", \
65dd2ded 512 indent); \
d101e731
SS
513 warned_cfg = 1; \
514 } \
515 fprintf(stderr, "%s%-11s configuration: %s\n", \
65dd2ded 516 indent, #libname, cfg); \
d101e731
SS
517 } \
518 } \
208749a0 519 } \
9a109272 520
1044a92a 521static void print_all_libs_info(FILE* outstream, int flags)
9a109272 522{
1044a92a 523 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
1044a92a
SS
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);
9a109272
SS
530}
531
ea9c581f 532void show_banner(void)
86074ed1 533{
a03be6e1 534 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
ef4c0bb1 535 program_name, program_birth_year, this_year);
a3d7c197
DB
536 fprintf(stderr, " built on %s %s with %s %s\n",
537 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
29ba0911 538 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
d101e731 539 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
1044a92a 540 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
86074ed1
SS
541}
542
64555bd9 543void show_version(void) {
a03be6e1 544 printf("%s " LIBAV_VERSION "\n", program_name);
1044a92a 545 print_all_libs_info(stdout, SHOW_VERSION);
86074ed1
SS
546}
547
f35917b2
SS
548void show_license(void)
549{
7ead693b 550 printf(
3bf28f9d 551#if CONFIG_NONFREE
304ba23a
SS
552 "This version of %s has nonfree parts compiled in.\n"
553 "Therefore it is not legally redistributable.\n",
554 program_name
9cad0e4e
DB
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
7ead693b 569#elif CONFIG_GPL
304ba23a 570 "%s is free software; you can redistribute it and/or modify\n"
f35917b2
SS
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"
304ba23a 575 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
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"
304ba23a
SS
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
9cad0e4e
DB
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
f35917b2 598#else
304ba23a 599 "%s is free software; you can redistribute it and/or\n"
f35917b2
SS
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"
304ba23a 604 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
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"
304ba23a
SS
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
f35917b2 613#endif
3bf28f9d 614 );
f35917b2 615}
ba9880c1
SS
616
617void show_formats(void)
618{
619 AVInputFormat *ifmt=NULL;
620 AVOutputFormat *ofmt=NULL;
ba9880c1
SS
621 const char *last_name;
622
5a8597a0
WZ
623 printf(
624 "File formats:\n"
625 " D. = Demuxing supported\n"
626 " .E = Muxing supported\n"
627 " --\n");
ba9880c1
SS
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 }
8447f0bd 664}
ba9880c1 665
8447f0bd
MN
666void show_codecs(void)
667{
668 AVCodec *p=NULL, *p2;
669 const char *last_name;
5a8597a0
WZ
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");
ba9880c1
SS
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) {
72415b2a 706 case AVMEDIA_TYPE_VIDEO:
ba9880c1
SS
707 type_str = "V";
708 break;
72415b2a 709 case AVMEDIA_TYPE_AUDIO:
ba9880c1
SS
710 type_str = "A";
711 break;
72415b2a 712 case AVMEDIA_TYPE_SUBTITLE:
ba9880c1
SS
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");
8447f0bd
MN
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
742void show_bsfs(void)
743{
744 AVBitStreamFilter *bsf=NULL;
ba9880c1
SS
745
746 printf("Bitstream filters:\n");
747 while((bsf = av_bitstream_filter_next(bsf)))
2091b27b 748 printf("%s\n", bsf->name);
ba9880c1 749 printf("\n");
8447f0bd
MN
750}
751
752void show_protocols(void)
753{
cdc6a87f
AK
754 void *opaque = NULL;
755 const char *name;
ba9880c1 756
2ee5c789 757 printf("Supported file protocols:\n"
cdc6a87f
AK
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);
ba9880c1 764}
090b61b2 765
62d75662
SS
766void show_filters(void)
767{
78638628 768 AVFilter av_unused(**filter) = NULL;
62d75662
SS
769
770 printf("Filters:\n");
663c2edf 771#if CONFIG_AVFILTER
62d75662
SS
772 while ((filter = av_filter_next(filter)) && *filter)
773 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
663c2edf 774#endif
62d75662
SS
775}
776
3f7bb426
SS
777void show_pix_fmts(void)
778{
9cb5c760
SS
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
e24db3e3
MR
791#if !CONFIG_SWSCALE
792# define sws_isSupportedInput(x) 0
793# define sws_isSupportedOutput(x) 0
794#endif
795
9cb5c760
SS
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 }
3f7bb426
SS
808}
809
090b61b2
SS
810int 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}
458b062d
SS
820
821int read_file(const char *filename, char **bufptr, size_t *size)
822{
c56e9e05 823 FILE *f = fopen(filename, "rb");
458b062d
SS
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}
7a8bfa5d
AS
844
845void 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
851int64_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 }
01d46198 863 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
7a8bfa5d
AS
864 && reordered_pts != AV_NOPTS_VALUE)
865 pts = reordered_pts;
866 else
867 pts = dts;
868
869 return pts;
870}
f7ead94c 871
6e872935
SS
872FILE *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
f7ead94c
SS
902#if CONFIG_AVFILTER
903
904static 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
915static void null_end_frame(AVFilterLink *inlink) { }
916
917static 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
926AVFilter 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
ff0652e5
SS
941int 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;
10d39405
RPM
959 frame->key_frame = picref->video->key_frame;
960 frame->pict_type = picref->video->pict_type;
ff0652e5
SS
961
962 return 1;
963}
964
f7ead94c 965#endif /* CONFIG_AVFILTER */