dict: add AV_DICT_APPEND flag.
[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);
de859358 280 } else if (po->u.func_arg) {
26513856 281 if (po->u.func_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 }
01310af2 285 }
a0b3bcd9
MN
286 if(po->flags & OPT_EXIT)
287 exit(0);
01310af2 288 } else {
60a9966e
SS
289 if (parse_arg_function)
290 parse_arg_function(opt);
01310af2
FB
291 }
292 }
293}
294
85663ef3
MN
295int opt_default(const char *opt, const char *arg){
296 int type;
5c3383e5 297 int ret= 0;
85663ef3
MN
298 const AVOption *o= NULL;
299 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
300
d860aaf8 301 for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
dc59ec5e 302 const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
85663ef3 303 if(o2)
636f1c4c 304 ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
85663ef3 305 }
d860aaf8 306 if(!o && avformat_opts)
5c3383e5 307 ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
da033b05 308 if(!o && sws_opts)
5c3383e5 309 ret = av_set_string3(sws_opts, opt, arg, 1, &o);
85663ef3 310 if(!o){
819e2ab0 311 if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
72415b2a 312 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
819e2ab0 313 else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
72415b2a 314 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
819e2ab0 315 else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
72415b2a 316 ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
5c3383e5
SS
317 }
318 if (o && ret < 0) {
319 fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
320 exit(1);
85663ef3 321 }
33bc7947 322 if (!o) {
0093ebc2 323 AVCodec *p = NULL;
ef2b2243 324 AVOutputFormat *oformat = NULL;
0093ebc2 325 while ((p=av_codec_next(p))){
42abb9a8 326 const AVClass *c = p->priv_class;
dc59ec5e 327 if(c && av_opt_find(&c, opt, NULL, 0, 0))
0093ebc2
MN
328 break;
329 }
ef2b2243
AH
330 if (!p) {
331 while ((oformat = av_oformat_next(oformat))) {
332 const AVClass *c = oformat->priv_class;
dc59ec5e 333 if (c && av_opt_find(&c, opt, NULL, 0, 0))
ef2b2243
AH
334 break;
335 }
336 }
337 if(!p && !oformat){
f03424a7
MS
338 fprintf(stderr, "Unrecognized option '%s'\n", opt);
339 exit(1);
0093ebc2 340 }
33bc7947 341 }
85663ef3 342
636f1c4c 343// 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 344
636f1c4c 345 //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 346 opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
60ff9de6 347 opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
85663ef3 348 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
60ff9de6 349 opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
85663ef3 350
20e021c7 351 if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
85663ef3
MN
352 av_log_set_level(AV_LOG_DEBUG);
353 return 0;
354}
355
4c97a6fa
SS
356int opt_loglevel(const char *opt, const char *arg)
357{
da4c2dab 358 const struct { const char *name; int level; } log_levels[] = {
4c97a6fa
SS
359 { "quiet" , AV_LOG_QUIET },
360 { "panic" , AV_LOG_PANIC },
361 { "fatal" , AV_LOG_FATAL },
362 { "error" , AV_LOG_ERROR },
363 { "warning", AV_LOG_WARNING },
364 { "info" , AV_LOG_INFO },
365 { "verbose", AV_LOG_VERBOSE },
366 { "debug" , AV_LOG_DEBUG },
367 };
368 char *tail;
369 int level;
370 int i;
371
372 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
373 if (!strcmp(log_levels[i].name, arg)) {
374 av_log_set_level(log_levels[i].level);
375 return 0;
376 }
377 }
378
379 level = strtol(arg, &tail, 10);
380 if (*tail) {
381 fprintf(stderr, "Invalid loglevel \"%s\". "
382 "Possible levels are numbers or:\n", arg);
383 for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
384 fprintf(stderr, "\"%s\"\n", log_levels[i].name);
385 exit(1);
386 }
387 av_log_set_level(level);
388 return 0;
389}
390
ffcc6e24
MR
391int opt_timelimit(const char *opt, const char *arg)
392{
0104b608 393#if HAVE_SETRLIMIT
ffcc6e24
MR
394 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
395 struct rlimit rl = { lim, lim + 1 };
396 if (setrlimit(RLIMIT_CPU, &rl))
397 perror("setrlimit");
398#else
399 fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
400#endif
401 return 0;
402}
403
0093ebc2 404void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
85663ef3
MN
405{
406 int i;
0093ebc2
MN
407 void *priv_ctx=NULL;
408 if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
409 AVCodecContext *avctx= ctx;
410 if(codec && codec->priv_class && avctx->priv_data){
411 priv_ctx= avctx->priv_data;
412 }
ef2b2243
AH
413 } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
414 AVFormatContext *avctx = ctx;
415 if (avctx->oformat && avctx->oformat->priv_class) {
416 priv_ctx = avctx->priv_data;
417 }
0093ebc2 418 }
ef2b2243 419
85663ef3
MN
420 for(i=0; i<opt_name_count; i++){
421 char buf[256];
422 const AVOption *opt;
423 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
424 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
425 if(str && ((opt->flags & flags) == flags))
f16dd7e6 426 av_set_string3(ctx, opt_names[i], str, 1, NULL);
0093ebc2
MN
427 /* We need to use a differnt system to pass options to the private context because
428 it is not known which codec and thus context kind that will be when parsing options
429 we thus use opt_values directly instead of opts_ctx */
430 if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
431 av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
432 }
85663ef3
MN
433 }
434}
435
01310af2
FB
436void print_error(const char *filename, int err)
437{
7a5bdd79 438 char errbuf[128];
735ef67b 439 const char *errbuf_ptr = errbuf;
7a5bdd79 440
9e94bd3e
SS
441 if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
442 errbuf_ptr = strerror(AVUNERROR(err));
443 fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
01310af2 444}
f35917b2 445
d101e731
SS
446static int warned_cfg = 0;
447
208749a0
SS
448#define INDENT 1
449#define SHOW_VERSION 2
d101e731 450#define SHOW_CONFIG 4
208749a0 451
1044a92a 452#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
5116571d 453 if (CONFIG_##LIBNAME) { \
65dd2ded 454 const char *indent = flags & INDENT? " " : ""; \
208749a0 455 if (flags & SHOW_VERSION) { \
b6525b4b 456 unsigned int version = libname##_version(); \
c0dd5653 457 fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
65dd2ded 458 indent, #libname, \
b6525b4b
SS
459 LIB##LIBNAME##_VERSION_MAJOR, \
460 LIB##LIBNAME##_VERSION_MINOR, \
461 LIB##LIBNAME##_VERSION_MICRO, \
462 version >> 16, version >> 8 & 0xff, version & 0xff); \
208749a0 463 } \
d101e731
SS
464 if (flags & SHOW_CONFIG) { \
465 const char *cfg = libname##_configuration(); \
29ba0911 466 if (strcmp(LIBAV_CONFIGURATION, cfg)) { \
d101e731
SS
467 if (!warned_cfg) { \
468 fprintf(outstream, \
469 "%sWARNING: library configuration mismatch\n", \
65dd2ded 470 indent); \
d101e731
SS
471 warned_cfg = 1; \
472 } \
473 fprintf(stderr, "%s%-11s configuration: %s\n", \
65dd2ded 474 indent, #libname, cfg); \
d101e731
SS
475 } \
476 } \
208749a0 477 } \
9a109272 478
1044a92a 479static void print_all_libs_info(FILE* outstream, int flags)
9a109272 480{
1044a92a 481 PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
1044a92a
SS
482 PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
483 PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
484 PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
485 PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
486 PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
487 PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
9a109272
SS
488}
489
ea9c581f 490void show_banner(void)
86074ed1 491{
a03be6e1 492 fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
ef4c0bb1 493 program_name, program_birth_year, this_year);
a3d7c197
DB
494 fprintf(stderr, " built on %s %s with %s %s\n",
495 __DATE__, __TIME__, CC_TYPE, CC_VERSION);
29ba0911 496 fprintf(stderr, " configuration: " LIBAV_CONFIGURATION "\n");
d101e731 497 print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
1044a92a 498 print_all_libs_info(stderr, INDENT|SHOW_VERSION);
86074ed1
SS
499}
500
64555bd9 501void show_version(void) {
a03be6e1 502 printf("%s " LIBAV_VERSION "\n", program_name);
1044a92a 503 print_all_libs_info(stdout, SHOW_VERSION);
86074ed1
SS
504}
505
f35917b2
SS
506void show_license(void)
507{
7ead693b 508 printf(
3bf28f9d 509#if CONFIG_NONFREE
304ba23a
SS
510 "This version of %s has nonfree parts compiled in.\n"
511 "Therefore it is not legally redistributable.\n",
512 program_name
9cad0e4e
DB
513#elif CONFIG_GPLV3
514 "%s is free software; you can redistribute it and/or modify\n"
515 "it under the terms of the GNU General Public License as published by\n"
516 "the Free Software Foundation; either version 3 of the License, or\n"
517 "(at your option) any later version.\n"
518 "\n"
519 "%s is distributed in the hope that it will be useful,\n"
520 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
521 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
522 "GNU General Public License for more details.\n"
523 "\n"
524 "You should have received a copy of the GNU General Public License\n"
525 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
526 program_name, program_name, program_name
7ead693b 527#elif CONFIG_GPL
304ba23a 528 "%s is free software; you can redistribute it and/or modify\n"
f35917b2
SS
529 "it under the terms of the GNU General Public License as published by\n"
530 "the Free Software Foundation; either version 2 of the License, or\n"
531 "(at your option) any later version.\n"
532 "\n"
304ba23a 533 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
534 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
535 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
536 "GNU General Public License for more details.\n"
537 "\n"
538 "You should have received a copy of the GNU General Public License\n"
304ba23a
SS
539 "along with %s; if not, write to the Free Software\n"
540 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
541 program_name, program_name, program_name
9cad0e4e
DB
542#elif CONFIG_LGPLV3
543 "%s is free software; you can redistribute it and/or modify\n"
544 "it under the terms of the GNU Lesser General Public License as published by\n"
545 "the Free Software Foundation; either version 3 of the License, or\n"
546 "(at your option) any later version.\n"
547 "\n"
548 "%s is distributed in the hope that it will be useful,\n"
549 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
550 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
551 "GNU Lesser General Public License for more details.\n"
552 "\n"
553 "You should have received a copy of the GNU Lesser General Public License\n"
554 "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
555 program_name, program_name, program_name
f35917b2 556#else
304ba23a 557 "%s is free software; you can redistribute it and/or\n"
f35917b2
SS
558 "modify it under the terms of the GNU Lesser General Public\n"
559 "License as published by the Free Software Foundation; either\n"
560 "version 2.1 of the License, or (at your option) any later version.\n"
561 "\n"
304ba23a 562 "%s is distributed in the hope that it will be useful,\n"
f35917b2
SS
563 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
564 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
565 "Lesser General Public License for more details.\n"
566 "\n"
567 "You should have received a copy of the GNU Lesser General Public\n"
304ba23a
SS
568 "License along with %s; if not, write to the Free Software\n"
569 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
570 program_name, program_name, program_name
f35917b2 571#endif
3bf28f9d 572 );
f35917b2 573}
ba9880c1
SS
574
575void show_formats(void)
576{
577 AVInputFormat *ifmt=NULL;
578 AVOutputFormat *ofmt=NULL;
ba9880c1
SS
579 const char *last_name;
580
5a8597a0
WZ
581 printf(
582 "File formats:\n"
583 " D. = Demuxing supported\n"
584 " .E = Muxing supported\n"
585 " --\n");
ba9880c1
SS
586 last_name= "000";
587 for(;;){
588 int decode=0;
589 int encode=0;
590 const char *name=NULL;
591 const char *long_name=NULL;
592
593 while((ofmt= av_oformat_next(ofmt))) {
594 if((name == NULL || strcmp(ofmt->name, name)<0) &&
595 strcmp(ofmt->name, last_name)>0){
596 name= ofmt->name;
597 long_name= ofmt->long_name;
598 encode=1;
599 }
600 }
601 while((ifmt= av_iformat_next(ifmt))) {
602 if((name == NULL || strcmp(ifmt->name, name)<0) &&
603 strcmp(ifmt->name, last_name)>0){
604 name= ifmt->name;
605 long_name= ifmt->long_name;
606 encode=0;
607 }
608 if(name && strcmp(ifmt->name, name)==0)
609 decode=1;
610 }
611 if(name==NULL)
612 break;
613 last_name= name;
614
615 printf(
616 " %s%s %-15s %s\n",
617 decode ? "D":" ",
618 encode ? "E":" ",
619 name,
620 long_name ? long_name:" ");
621 }
8447f0bd 622}
ba9880c1 623
8447f0bd
MN
624void show_codecs(void)
625{
626 AVCodec *p=NULL, *p2;
627 const char *last_name;
5a8597a0
WZ
628 printf(
629 "Codecs:\n"
630 " D..... = Decoding supported\n"
631 " .E.... = Encoding supported\n"
632 " ..V... = Video codec\n"
633 " ..A... = Audio codec\n"
634 " ..S... = Subtitle codec\n"
635 " ...S.. = Supports draw_horiz_band\n"
636 " ....D. = Supports direct rendering method 1\n"
637 " .....T = Supports weird frame truncation\n"
638 " ------\n");
ba9880c1
SS
639 last_name= "000";
640 for(;;){
641 int decode=0;
642 int encode=0;
643 int cap=0;
644 const char *type_str;
645
646 p2=NULL;
647 while((p= av_codec_next(p))) {
648 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
649 strcmp(p->name, last_name)>0){
650 p2= p;
651 decode= encode= cap=0;
652 }
653 if(p2 && strcmp(p->name, p2->name)==0){
654 if(p->decode) decode=1;
655 if(p->encode) encode=1;
656 cap |= p->capabilities;
657 }
658 }
659 if(p2==NULL)
660 break;
661 last_name= p2->name;
662
663 switch(p2->type) {
72415b2a 664 case AVMEDIA_TYPE_VIDEO:
ba9880c1
SS
665 type_str = "V";
666 break;
72415b2a 667 case AVMEDIA_TYPE_AUDIO:
ba9880c1
SS
668 type_str = "A";
669 break;
72415b2a 670 case AVMEDIA_TYPE_SUBTITLE:
ba9880c1
SS
671 type_str = "S";
672 break;
673 default:
674 type_str = "?";
675 break;
676 }
677 printf(
678 " %s%s%s%s%s%s %-15s %s",
679 decode ? "D": (/*p2->decoder ? "d":*/" "),
680 encode ? "E":" ",
681 type_str,
682 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
683 cap & CODEC_CAP_DR1 ? "D":" ",
684 cap & CODEC_CAP_TRUNCATED ? "T":" ",
685 p2->name,
686 p2->long_name ? p2->long_name : "");
687 /* if(p2->decoder && decode==0)
688 printf(" use %s for decoding", p2->decoder->name);*/
689 printf("\n");
690 }
691 printf("\n");
8447f0bd
MN
692 printf(
693"Note, the names of encoders and decoders do not always match, so there are\n"
694"several cases where the above table shows encoder only or decoder only entries\n"
695"even though both encoding and decoding are supported. For example, the h263\n"
696"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
697"worse.\n");
698}
699
700void show_bsfs(void)
701{
702 AVBitStreamFilter *bsf=NULL;
ba9880c1
SS
703
704 printf("Bitstream filters:\n");
705 while((bsf = av_bitstream_filter_next(bsf)))
2091b27b 706 printf("%s\n", bsf->name);
ba9880c1 707 printf("\n");
8447f0bd
MN
708}
709
710void show_protocols(void)
711{
cdc6a87f
AK
712 void *opaque = NULL;
713 const char *name;
ba9880c1 714
2ee5c789 715 printf("Supported file protocols:\n"
cdc6a87f
AK
716 "Input:\n");
717 while ((name = avio_enum_protocols(&opaque, 0)))
718 printf("%s\n", name);
719 printf("Output:\n");
720 while ((name = avio_enum_protocols(&opaque, 1)))
721 printf("%s\n", name);
ba9880c1 722}
090b61b2 723
62d75662
SS
724void show_filters(void)
725{
78638628 726 AVFilter av_unused(**filter) = NULL;
62d75662
SS
727
728 printf("Filters:\n");
663c2edf 729#if CONFIG_AVFILTER
62d75662
SS
730 while ((filter = av_filter_next(filter)) && *filter)
731 printf("%-16s %s\n", (*filter)->name, (*filter)->description);
663c2edf 732#endif
62d75662
SS
733}
734
3f7bb426
SS
735void show_pix_fmts(void)
736{
9cb5c760
SS
737 enum PixelFormat pix_fmt;
738
739 printf(
740 "Pixel formats:\n"
741 "I.... = Supported Input format for conversion\n"
742 ".O... = Supported Output format for conversion\n"
743 "..H.. = Hardware accelerated format\n"
744 "...P. = Paletted format\n"
745 "....B = Bitstream format\n"
746 "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
747 "-----\n");
748
e24db3e3
MR
749#if !CONFIG_SWSCALE
750# define sws_isSupportedInput(x) 0
751# define sws_isSupportedOutput(x) 0
752#endif
753
9cb5c760
SS
754 for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
755 const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
756 printf("%c%c%c%c%c %-16s %d %2d\n",
757 sws_isSupportedInput (pix_fmt) ? 'I' : '.',
758 sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
759 pix_desc->flags & PIX_FMT_HWACCEL ? 'H' : '.',
760 pix_desc->flags & PIX_FMT_PAL ? 'P' : '.',
761 pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
762 pix_desc->name,
763 pix_desc->nb_components,
764 av_get_bits_per_pixel(pix_desc));
765 }
3f7bb426
SS
766}
767
090b61b2
SS
768int read_yesno(void)
769{
770 int c = getchar();
771 int yesno = (toupper(c) == 'Y');
772
773 while (c != '\n' && c != EOF)
774 c = getchar();
775
776 return yesno;
777}
458b062d
SS
778
779int read_file(const char *filename, char **bufptr, size_t *size)
780{
c56e9e05 781 FILE *f = fopen(filename, "rb");
458b062d
SS
782
783 if (!f) {
784 fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
785 return AVERROR(errno);
786 }
787 fseek(f, 0, SEEK_END);
788 *size = ftell(f);
789 fseek(f, 0, SEEK_SET);
790 *bufptr = av_malloc(*size + 1);
791 if (!*bufptr) {
792 fprintf(stderr, "Could not allocate file buffer\n");
793 fclose(f);
794 return AVERROR(ENOMEM);
795 }
796 fread(*bufptr, 1, *size, f);
797 (*bufptr)[*size++] = '\0';
798
799 fclose(f);
800 return 0;
801}
7a8bfa5d
AS
802
803void init_pts_correction(PtsCorrectionContext *ctx)
804{
805 ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
806 ctx->last_pts = ctx->last_dts = INT64_MIN;
807}
808
809int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
810{
811 int64_t pts = AV_NOPTS_VALUE;
812
813 if (dts != AV_NOPTS_VALUE) {
814 ctx->num_faulty_dts += dts <= ctx->last_dts;
815 ctx->last_dts = dts;
816 }
817 if (reordered_pts != AV_NOPTS_VALUE) {
818 ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
819 ctx->last_pts = reordered_pts;
820 }
01d46198 821 if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
7a8bfa5d
AS
822 && reordered_pts != AV_NOPTS_VALUE)
823 pts = reordered_pts;
824 else
825 pts = dts;
826
827 return pts;
828}
f7ead94c 829
6e872935
SS
830FILE *get_preset_file(char *filename, size_t filename_size,
831 const char *preset_name, int is_path, const char *codec_name)
832{
833 FILE *f = NULL;
834 int i;
835 const char *base[3]= { getenv("FFMPEG_DATADIR"),
836 getenv("HOME"),
837 FFMPEG_DATADIR,
838 };
839
840 if (is_path) {
841 av_strlcpy(filename, preset_name, filename_size);
842 f = fopen(filename, "r");
843 } else {
844 for (i = 0; i < 3 && !f; i++) {
845 if (!base[i])
846 continue;
847 snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
848 f = fopen(filename, "r");
849 if (!f && codec_name) {
850 snprintf(filename, filename_size,
851 "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
852 f = fopen(filename, "r");
853 }
854 }
855 }
856
857 return f;
858}
859
f7ead94c
SS
860#if CONFIG_AVFILTER
861
862static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
863{
864 FFSinkContext *priv = ctx->priv;
865
866 if (!opaque)
867 return AVERROR(EINVAL);
868 *priv = *(FFSinkContext *)opaque;
869
870 return 0;
871}
872
873static void null_end_frame(AVFilterLink *inlink) { }
874
875static int ffsink_query_formats(AVFilterContext *ctx)
876{
877 FFSinkContext *priv = ctx->priv;
878 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
879
880 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
881 return 0;
882}
883
884AVFilter ffsink = {
885 .name = "ffsink",
886 .priv_size = sizeof(FFSinkContext),
887 .init = ffsink_init,
888
889 .query_formats = ffsink_query_formats,
890
891 .inputs = (AVFilterPad[]) {{ .name = "default",
892 .type = AVMEDIA_TYPE_VIDEO,
893 .end_frame = null_end_frame,
894 .min_perms = AV_PERM_READ, },
895 { .name = NULL }},
896 .outputs = (AVFilterPad[]) {{ .name = NULL }},
897};
898
ff0652e5
SS
899int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
900 AVFilterBufferRef **picref_ptr, AVRational *tb)
901{
902 int ret;
903 AVFilterBufferRef *picref;
904
905 if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
906 return ret;
907 if (!(picref = ctx->inputs[0]->cur_buf))
908 return AVERROR(ENOENT);
909 *picref_ptr = picref;
910 ctx->inputs[0]->cur_buf = NULL;
911 *tb = ctx->inputs[0]->time_base;
912
913 memcpy(frame->data, picref->data, sizeof(frame->data));
914 memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
915 frame->interlaced_frame = picref->video->interlaced;
916 frame->top_field_first = picref->video->top_field_first;
10d39405
RPM
917 frame->key_frame = picref->video->key_frame;
918 frame->pict_type = picref->video->pict_type;
ff0652e5
SS
919
920 return 1;
921}
922
f7ead94c 923#endif /* CONFIG_AVFILTER */