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