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