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