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