2003-06-07 21:34:02 +03:00
|
|
|
/*
|
|
|
|
* Various utilities for command line tools
|
|
|
|
* Copyright (c) 2000-2003 Fabrice Bellard
|
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2003-06-07 21:34:02 +03:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 18:30:46 +03:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2003-06-07 21:34:02 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2003-06-07 21:34:02 +03:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 18:30:46 +03:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-13 00:43:26 +02:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2003-06-07 21:34:02 +03:00
|
|
|
*/
|
2007-06-10 17:34:56 +03:00
|
|
|
|
2007-07-02 10:43:23 +03:00
|
|
|
#include <string.h>
|
2013-11-23 23:32:55 +03:00
|
|
|
#include <stdint.h>
|
2007-07-02 10:43:23 +03:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
2008-02-25 16:15:52 +02:00
|
|
|
#include <math.h>
|
2007-07-02 10:43:23 +03:00
|
|
|
|
2008-10-22 13:36:34 +03:00
|
|
|
/* Include only the enabled headers since some compilers (namely, Sun
|
|
|
|
Studio) will not omit unused inline functions and create undefined
|
|
|
|
references to libraries that are not being built. */
|
|
|
|
|
2008-03-15 18:17:02 +02:00
|
|
|
#include "config.h"
|
2012-09-14 22:08:19 +03:00
|
|
|
#include "compat/va_copy.h"
|
2008-05-09 14:56:36 +03:00
|
|
|
#include "libavformat/avformat.h"
|
|
|
|
#include "libavfilter/avfilter.h"
|
|
|
|
#include "libavdevice/avdevice.h"
|
2012-04-05 21:06:28 +03:00
|
|
|
#include "libavresample/avresample.h"
|
2008-08-29 21:25:14 +03:00
|
|
|
#include "libswscale/swscale.h"
|
2011-12-22 05:09:58 +03:00
|
|
|
#include "libswresample/swresample.h"
|
2008-09-01 21:02:46 +03:00
|
|
|
#include "libpostproc/postprocess.h"
|
2017-05-22 16:27:51 +02:00
|
|
|
#include "libavutil/attributes.h"
|
2012-04-11 11:31:02 +03:00
|
|
|
#include "libavutil/avassert.h"
|
2008-05-09 14:56:36 +03:00
|
|
|
#include "libavutil/avstring.h"
|
2012-11-02 15:15:51 +03:00
|
|
|
#include "libavutil/bprint.h"
|
2015-05-03 23:49:16 +02:00
|
|
|
#include "libavutil/display.h"
|
2011-07-17 13:19:35 +03:00
|
|
|
#include "libavutil/mathematics.h"
|
2012-05-30 08:57:59 +03:00
|
|
|
#include "libavutil/imgutils.h"
|
2015-05-05 11:49:44 +02:00
|
|
|
#include "libavutil/libm.h"
|
2011-02-16 10:52:36 +02:00
|
|
|
#include "libavutil/parseutils.h"
|
2010-02-11 01:36:35 +02:00
|
|
|
#include "libavutil/pixdesc.h"
|
2010-06-10 00:28:53 +03:00
|
|
|
#include "libavutil/eval.h"
|
2011-05-25 17:42:41 +03:00
|
|
|
#include "libavutil/dict.h"
|
2011-02-03 15:58:59 +02:00
|
|
|
#include "libavutil/opt.h"
|
2013-10-14 06:41:45 +03:00
|
|
|
#include "libavutil/cpu.h"
|
2013-11-29 03:29:41 +03:00
|
|
|
#include "libavutil/ffversion.h"
|
2015-12-07 06:27:40 +02:00
|
|
|
#include "libavutil/version.h"
|
2003-06-07 21:34:02 +03:00
|
|
|
#include "cmdutils.h"
|
2010-01-20 08:42:39 +02:00
|
|
|
#if HAVE_SYS_RESOURCE_H
|
2012-10-14 02:27:26 +03:00
|
|
|
#include <sys/time.h>
|
2010-01-20 08:42:39 +02:00
|
|
|
#include <sys/resource.h>
|
|
|
|
#endif
|
2016-08-29 15:25:58 +02:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
2003-06-07 21:34:02 +03:00
|
|
|
|
2012-11-02 15:15:51 +03:00
|
|
|
static int init_report(const char *env);
|
|
|
|
|
2015-08-08 12:43:10 +02:00
|
|
|
AVDictionary *sws_dict;
|
2013-02-24 21:07:42 +03:00
|
|
|
AVDictionary *swr_opts;
|
2012-12-19 05:47:28 +03:00
|
|
|
AVDictionary *format_opts, *codec_opts, *resample_opts;
|
2008-02-21 14:24:37 +02:00
|
|
|
|
2011-12-08 16:42:24 +03:00
|
|
|
static FILE *report_file;
|
2014-05-12 23:23:36 +03:00
|
|
|
static int report_file_level = AV_LOG_DEBUG;
|
2013-12-28 07:18:39 +03:00
|
|
|
int hide_banner = 0;
|
2011-12-08 16:42:24 +03:00
|
|
|
|
2016-11-04 14:20:25 +02:00
|
|
|
enum show_muxdemuxers {
|
|
|
|
SHOW_DEFAULT,
|
|
|
|
SHOW_DEMUXERS,
|
|
|
|
SHOW_MUXERS,
|
|
|
|
};
|
|
|
|
|
2010-10-02 11:44:33 +03:00
|
|
|
void init_opts(void)
|
|
|
|
{
|
2015-08-08 12:43:10 +02:00
|
|
|
av_dict_set(&sws_dict, "flags", "bicubic", 0);
|
2010-10-02 11:44:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void uninit_opts(void)
|
|
|
|
{
|
2013-02-24 21:07:42 +03:00
|
|
|
av_dict_free(&swr_opts);
|
2015-08-08 12:43:10 +02:00
|
|
|
av_dict_free(&sws_dict);
|
2011-05-25 17:42:41 +03:00
|
|
|
av_dict_free(&format_opts);
|
2011-07-10 16:46:15 +03:00
|
|
|
av_dict_free(&codec_opts);
|
2012-12-19 05:47:28 +03:00
|
|
|
av_dict_free(&resample_opts);
|
2010-10-02 11:44:33 +03:00
|
|
|
}
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
|
2010-09-21 00:48:03 +03:00
|
|
|
{
|
|
|
|
vfprintf(stdout, fmt, vl);
|
|
|
|
}
|
|
|
|
|
2011-12-08 16:42:24 +03:00
|
|
|
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
|
|
|
|
{
|
|
|
|
va_list vl2;
|
|
|
|
char line[1024];
|
|
|
|
static int print_prefix = 1;
|
|
|
|
|
|
|
|
va_copy(vl2, vl);
|
|
|
|
av_log_default_callback(ptr, level, fmt, vl);
|
|
|
|
av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
|
|
|
|
va_end(vl2);
|
2014-05-12 23:23:36 +03:00
|
|
|
if (report_file_level >= level) {
|
|
|
|
fputs(line, report_file);
|
|
|
|
fflush(report_file);
|
|
|
|
}
|
2011-12-08 16:42:24 +03:00
|
|
|
}
|
|
|
|
|
2016-08-08 15:27:41 +02:00
|
|
|
void init_dynload(void)
|
|
|
|
{
|
2020-01-08 13:29:07 +02:00
|
|
|
#if HAVE_SETDLLDIRECTORY && defined(_WIN32)
|
2016-08-08 15:27:41 +02:00
|
|
|
/* Calling SetDllDirectory with the empty string (but not NULL) removes the
|
|
|
|
* current working directory from the DLL search path as a security pre-caution. */
|
|
|
|
SetDllDirectory("");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-07-07 02:52:51 +03:00
|
|
|
static void (*program_exit)(int ret);
|
|
|
|
|
|
|
|
void register_exit(void (*cb)(int ret))
|
|
|
|
{
|
|
|
|
program_exit = cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exit_program(int ret)
|
|
|
|
{
|
|
|
|
if (program_exit)
|
|
|
|
program_exit(ret);
|
|
|
|
|
|
|
|
exit(ret);
|
|
|
|
}
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
double parse_number_or_die(const char *context, const char *numstr, int type,
|
|
|
|
double min, double max)
|
2008-02-21 14:24:37 +02:00
|
|
|
{
|
|
|
|
char *tail;
|
|
|
|
const char *error;
|
2010-06-10 00:28:53 +03:00
|
|
|
double d = av_strtod(numstr, &tail);
|
2008-02-21 14:24:37 +02:00
|
|
|
if (*tail)
|
2011-12-31 15:31:54 +03:00
|
|
|
error = "Expected number for %s but found: %s\n";
|
2008-02-21 14:24:37 +02:00
|
|
|
else if (d < min || d > max)
|
2011-12-31 15:31:54 +03:00
|
|
|
error = "The value for %s was %s which is not within %f - %f\n";
|
|
|
|
else if (type == OPT_INT64 && (int64_t)d != d)
|
|
|
|
error = "Expected int64 for %s but found %s\n";
|
2011-04-16 14:41:53 +03:00
|
|
|
else if (type == OPT_INT && (int)d != d)
|
2011-12-31 15:31:54 +03:00
|
|
|
error = "Expected int for %s but found %s\n";
|
2008-02-21 14:24:37 +02:00
|
|
|
else
|
|
|
|
return d;
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2011-08-29 08:03:24 +03:00
|
|
|
return 0;
|
2008-02-21 14:24:37 +02:00
|
|
|
}
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
int64_t parse_time_or_die(const char *context, const char *timestr,
|
|
|
|
int is_duration)
|
2008-03-31 13:01:06 +03:00
|
|
|
{
|
2011-02-16 10:52:36 +02:00
|
|
|
int64_t us;
|
|
|
|
if (av_parse_time(&us, timestr, is_duration) < 0) {
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
|
|
|
|
is_duration ? "duration" : "date", context, timestr);
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2008-03-31 13:01:06 +03:00
|
|
|
}
|
|
|
|
return us;
|
|
|
|
}
|
|
|
|
|
2012-08-11 20:45:30 +03:00
|
|
|
void show_help_options(const OptionDef *options, const char *msg, int req_flags,
|
2012-08-15 11:31:46 +03:00
|
|
|
int rej_flags, int alt_flags)
|
2003-06-07 21:34:02 +03:00
|
|
|
{
|
|
|
|
const OptionDef *po;
|
2003-08-24 18:29:48 +03:00
|
|
|
int first;
|
2003-06-07 21:34:02 +03:00
|
|
|
|
2003-08-24 18:29:48 +03:00
|
|
|
first = 1;
|
2014-08-15 22:31:59 +03:00
|
|
|
for (po = options; po->name; po++) {
|
2019-12-12 10:02:53 +02:00
|
|
|
char buf[128];
|
2012-08-11 20:45:30 +03:00
|
|
|
|
|
|
|
if (((po->flags & req_flags) != req_flags) ||
|
2012-08-15 11:31:46 +03:00
|
|
|
(alt_flags && !(po->flags & alt_flags)) ||
|
2012-08-11 20:45:30 +03:00
|
|
|
(po->flags & rej_flags))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (first) {
|
|
|
|
printf("%s\n", msg);
|
|
|
|
first = 0;
|
|
|
|
}
|
|
|
|
av_strlcpy(buf, po->name, sizeof(buf));
|
2012-08-13 21:06:25 +03:00
|
|
|
if (po->argname) {
|
2012-08-11 20:45:30 +03:00
|
|
|
av_strlcat(buf, " ", sizeof(buf));
|
|
|
|
av_strlcat(buf, po->argname, sizeof(buf));
|
2003-06-07 21:34:02 +03:00
|
|
|
}
|
2012-08-11 20:45:30 +03:00
|
|
|
printf("-%-17s %s\n", buf, po->help);
|
2003-06-07 21:34:02 +03:00
|
|
|
}
|
2012-08-11 20:33:27 +03:00
|
|
|
printf("\n");
|
2003-06-07 21:34:02 +03:00
|
|
|
}
|
|
|
|
|
2011-10-04 15:50:00 +03:00
|
|
|
void show_help_children(const AVClass *class, int flags)
|
|
|
|
{
|
2020-05-27 15:25:38 +02:00
|
|
|
void *iter = NULL;
|
|
|
|
const AVClass *child;
|
2012-08-09 15:44:18 +03:00
|
|
|
if (class->option) {
|
|
|
|
av_opt_show2(&class, NULL, flags, 0);
|
|
|
|
printf("\n");
|
|
|
|
}
|
2011-10-04 15:50:00 +03:00
|
|
|
|
2020-05-27 15:25:38 +02:00
|
|
|
while (child = av_opt_child_class_iterate(class, &iter))
|
2011-10-04 15:50:00 +03:00
|
|
|
show_help_children(child, flags);
|
|
|
|
}
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
static const OptionDef *find_option(const OptionDef *po, const char *name)
|
|
|
|
{
|
2011-07-29 14:47:37 +03:00
|
|
|
const char *p = strchr(name, ':');
|
|
|
|
int len = p ? p - name : strlen(name);
|
|
|
|
|
2014-08-14 23:31:25 +03:00
|
|
|
while (po->name) {
|
2011-07-29 14:47:37 +03:00
|
|
|
if (!strncmp(name, po->name, len) && strlen(po->name) == len)
|
2005-09-11 14:10:25 +03:00
|
|
|
break;
|
|
|
|
po++;
|
|
|
|
}
|
|
|
|
return po;
|
|
|
|
}
|
|
|
|
|
2013-08-07 14:25:51 +03:00
|
|
|
/* _WIN32 means using the windows libc - cygwin doesn't define that
|
|
|
|
* by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
|
|
|
|
* it doesn't provide the actual command line via GetCommandLineW(). */
|
|
|
|
#if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
|
2012-07-07 23:46:26 +03:00
|
|
|
#include <shellapi.h>
|
2011-04-20 14:36:44 +03:00
|
|
|
/* Will be leaked on exit */
|
|
|
|
static char** win32_argv_utf8 = NULL;
|
|
|
|
static int win32_argc = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Prepare command line arguments for executable.
|
|
|
|
* For Windows - perform wide-char to UTF-8 conversion.
|
|
|
|
* Input arguments should be main() function arguments.
|
|
|
|
* @param argc_ptr Arguments number (including executable)
|
|
|
|
* @param argv_ptr Arguments list.
|
|
|
|
*/
|
|
|
|
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
|
|
|
|
{
|
|
|
|
char *argstr_flat;
|
|
|
|
wchar_t **argv_w;
|
|
|
|
int i, buffsize = 0, offset = 0;
|
|
|
|
|
|
|
|
if (win32_argv_utf8) {
|
|
|
|
*argc_ptr = win32_argc;
|
|
|
|
*argv_ptr = win32_argv_utf8;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
win32_argc = 0;
|
|
|
|
argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
|
|
|
|
if (win32_argc <= 0 || !argv_w)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* determine the UTF-8 buffer size (including NULL-termination symbols) */
|
|
|
|
for (i = 0; i < win32_argc; i++)
|
|
|
|
buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
|
|
|
|
NULL, 0, NULL, NULL);
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
|
|
|
|
argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
|
2014-08-14 23:31:24 +03:00
|
|
|
if (!win32_argv_utf8) {
|
2011-04-20 14:36:44 +03:00
|
|
|
LocalFree(argv_w);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < win32_argc; i++) {
|
|
|
|
win32_argv_utf8[i] = &argstr_flat[offset];
|
|
|
|
offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
|
|
|
|
&argstr_flat[offset],
|
|
|
|
buffsize - offset, NULL, NULL);
|
|
|
|
}
|
|
|
|
win32_argv_utf8[i] = NULL;
|
|
|
|
LocalFree(argv_w);
|
|
|
|
|
|
|
|
*argc_ptr = win32_argc;
|
|
|
|
*argv_ptr = win32_argv_utf8;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
|
|
|
|
{
|
|
|
|
/* nothing to do */
|
|
|
|
}
|
2012-11-29 18:02:24 +03:00
|
|
|
#endif /* HAVE_COMMANDLINETOARGVW */
|
2011-04-20 14:36:44 +03:00
|
|
|
|
2012-06-10 18:57:52 +03:00
|
|
|
static int write_option(void *optctx, const OptionDef *po, const char *opt,
|
|
|
|
const char *arg)
|
2003-06-07 21:34:02 +03:00
|
|
|
{
|
2011-08-29 09:11:03 +03:00
|
|
|
/* new-style options contain an offset into optctx, old-style address of
|
|
|
|
* a global var*/
|
2012-06-10 18:57:52 +03:00
|
|
|
void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
|
|
|
|
(uint8_t *)optctx + po->u.off : po->u.dst_ptr;
|
|
|
|
int *dstcount;
|
2011-08-29 08:54:56 +03:00
|
|
|
|
|
|
|
if (po->flags & OPT_SPEC) {
|
|
|
|
SpecifierOpt **so = dst;
|
|
|
|
char *p = strchr(opt, ':');
|
2014-12-17 15:53:45 +02:00
|
|
|
char *str;
|
2011-08-29 08:54:56 +03:00
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
dstcount = (int *)(so + 1);
|
2011-08-29 08:54:56 +03:00
|
|
|
*so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
|
2014-12-17 15:53:45 +02:00
|
|
|
str = av_strdup(p ? p + 1 : "");
|
|
|
|
if (!str)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
(*so)[*dstcount - 1].specifier = str;
|
2011-08-29 08:54:56 +03:00
|
|
|
dst = &(*so)[*dstcount - 1].u;
|
|
|
|
}
|
2011-08-29 09:11:03 +03:00
|
|
|
|
|
|
|
if (po->flags & OPT_STRING) {
|
|
|
|
char *str;
|
|
|
|
str = av_strdup(arg);
|
2012-11-15 18:11:04 +03:00
|
|
|
av_freep(dst);
|
2014-12-17 15:53:45 +02:00
|
|
|
if (!str)
|
|
|
|
return AVERROR(ENOMEM);
|
2011-12-31 15:31:54 +03:00
|
|
|
*(char **)dst = str;
|
2012-06-10 18:57:52 +03:00
|
|
|
} else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
|
2011-12-31 15:31:54 +03:00
|
|
|
*(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
|
2011-08-29 09:11:03 +03:00
|
|
|
} else if (po->flags & OPT_INT64) {
|
2011-12-31 15:31:54 +03:00
|
|
|
*(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
|
2011-08-28 19:20:17 +03:00
|
|
|
} else if (po->flags & OPT_TIME) {
|
2011-12-31 15:31:54 +03:00
|
|
|
*(int64_t *)dst = parse_time_or_die(opt, arg, 1);
|
2011-08-29 09:11:03 +03:00
|
|
|
} else if (po->flags & OPT_FLOAT) {
|
2011-12-31 15:31:54 +03:00
|
|
|
*(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
|
2011-08-29 10:16:42 +03:00
|
|
|
} else if (po->flags & OPT_DOUBLE) {
|
2011-12-31 15:31:54 +03:00
|
|
|
*(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
|
2011-08-29 09:11:03 +03:00
|
|
|
} else if (po->u.func_arg) {
|
2012-08-29 15:37:22 +03:00
|
|
|
int ret = po->u.func_arg(optctx, opt, arg);
|
2011-08-29 09:11:03 +03:00
|
|
|
if (ret < 0) {
|
2011-12-31 15:31:54 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR,
|
2013-03-10 17:36:20 +03:00
|
|
|
"Failed to set value '%s' for option '%s': %s\n",
|
|
|
|
arg, opt, av_err2str(ret));
|
2011-08-29 09:11:03 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (po->flags & OPT_EXIT)
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(0);
|
2012-06-10 18:57:52 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int parse_option(void *optctx, const char *opt, const char *arg,
|
|
|
|
const OptionDef *options)
|
|
|
|
{
|
|
|
|
const OptionDef *po;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
po = find_option(options, opt);
|
|
|
|
if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
|
|
|
|
/* handle 'no' bool option */
|
|
|
|
po = find_option(options, opt + 2);
|
|
|
|
if ((po->name && (po->flags & OPT_BOOL)))
|
|
|
|
arg = "0";
|
|
|
|
} else if (po->flags & OPT_BOOL)
|
|
|
|
arg = "1";
|
|
|
|
|
|
|
|
if (!po->name)
|
|
|
|
po = find_option(options, "default");
|
|
|
|
if (!po->name) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
if (po->flags & HAS_ARG && !arg) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = write_option(optctx, po, opt, arg);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2011-08-29 09:11:03 +03:00
|
|
|
return !!(po->flags & HAS_ARG);
|
|
|
|
}
|
|
|
|
|
2011-08-28 15:43:54 +03:00
|
|
|
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
|
2011-12-31 15:31:54 +03:00
|
|
|
void (*parse_arg_function)(void *, const char*))
|
2003-06-07 21:34:02 +03:00
|
|
|
{
|
2011-08-29 09:11:03 +03:00
|
|
|
const char *opt;
|
|
|
|
int optindex, handleoptions = 1, ret;
|
2003-06-07 21:34:02 +03:00
|
|
|
|
2011-04-20 14:36:44 +03:00
|
|
|
/* perform system-dependent conversions for arguments list */
|
|
|
|
prepare_app_arguments(&argc, &argv);
|
|
|
|
|
2003-06-07 21:34:02 +03:00
|
|
|
/* parse options */
|
|
|
|
optindex = 1;
|
|
|
|
while (optindex < argc) {
|
|
|
|
opt = argv[optindex++];
|
2005-12-17 20:14:38 +02:00
|
|
|
|
2006-11-27 14:37:43 +02:00
|
|
|
if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
|
2008-12-18 02:13:19 +02:00
|
|
|
if (opt[1] == '-' && opt[2] == '\0') {
|
|
|
|
handleoptions = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2009-12-15 01:47:22 +02:00
|
|
|
opt++;
|
2011-08-29 09:11:03 +03:00
|
|
|
|
|
|
|
if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2011-08-29 09:11:03 +03:00
|
|
|
optindex += ret;
|
2003-06-07 21:34:02 +03:00
|
|
|
} else {
|
2007-08-14 02:03:36 +03:00
|
|
|
if (parse_arg_function)
|
2011-08-28 15:43:54 +03:00
|
|
|
parse_arg_function(optctx, opt);
|
2003-06-07 21:34:02 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-10 21:46:30 +03:00
|
|
|
int parse_optgroup(void *optctx, OptionGroup *g)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
|
|
|
|
g->group_def->name, g->arg);
|
|
|
|
|
|
|
|
for (i = 0; i < g->nb_opts; i++) {
|
|
|
|
Option *o = &g->opts[i];
|
|
|
|
|
2013-02-20 10:02:16 +03:00
|
|
|
if (g->group_def->flags &&
|
|
|
|
!(g->group_def->flags & o->opt->flags)) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
|
|
|
|
"%s %s -- you are trying to apply an input option to an "
|
|
|
|
"output file or vice versa. Move this option before the "
|
|
|
|
"file it belongs to.\n", o->key, o->opt->help,
|
|
|
|
g->group_def->name, g->arg);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2012-06-10 21:46:30 +03:00
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
|
|
|
|
o->key, o->opt->help, o->val);
|
|
|
|
|
|
|
|
ret = write_option(optctx, o->opt, o->key, o->val);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-04 18:46:45 +03:00
|
|
|
int locate_option(int argc, char **argv, const OptionDef *options,
|
|
|
|
const char *optname)
|
2011-09-26 09:15:37 +03:00
|
|
|
{
|
|
|
|
const OptionDef *po;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *cur_opt = argv[i];
|
|
|
|
|
|
|
|
if (*cur_opt++ != '-')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
po = find_option(options, cur_opt);
|
|
|
|
if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
|
|
|
|
po = find_option(options, cur_opt + 2);
|
|
|
|
|
|
|
|
if ((!po->name && !strcmp(cur_opt, optname)) ||
|
|
|
|
(po->name && !strcmp(optname, po->name)))
|
|
|
|
return i;
|
|
|
|
|
2014-10-15 03:43:30 +03:00
|
|
|
if (!po->name || po->flags & HAS_ARG)
|
2011-09-26 09:15:37 +03:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-08 16:42:24 +03:00
|
|
|
static void dump_argument(const char *a)
|
|
|
|
{
|
|
|
|
const unsigned char *p;
|
|
|
|
|
|
|
|
for (p = a; *p; p++)
|
|
|
|
if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
|
|
|
|
*p == '_' || (*p >= 'a' && *p <= 'z')))
|
|
|
|
break;
|
|
|
|
if (!*p) {
|
|
|
|
fputs(a, report_file);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fputc('"', report_file);
|
|
|
|
for (p = a; *p; p++) {
|
|
|
|
if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
|
|
|
|
fprintf(report_file, "\\%c", *p);
|
|
|
|
else if (*p < ' ' || *p > '~')
|
|
|
|
fprintf(report_file, "\\x%02x", *p);
|
|
|
|
else
|
|
|
|
fputc(*p, report_file);
|
|
|
|
}
|
|
|
|
fputc('"', report_file);
|
|
|
|
}
|
|
|
|
|
2015-05-09 13:07:21 +02:00
|
|
|
static void check_options(const OptionDef *po)
|
|
|
|
{
|
|
|
|
while (po->name) {
|
|
|
|
if (po->flags & OPT_PERFILE)
|
|
|
|
av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT));
|
|
|
|
po++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-26 09:15:37 +03:00
|
|
|
void parse_loglevel(int argc, char **argv, const OptionDef *options)
|
|
|
|
{
|
|
|
|
int idx = locate_option(argc, argv, options, "loglevel");
|
2012-11-02 15:15:51 +03:00
|
|
|
const char *env;
|
2015-05-09 13:07:21 +02:00
|
|
|
|
|
|
|
check_options(options);
|
|
|
|
|
2011-10-07 15:29:03 +03:00
|
|
|
if (!idx)
|
|
|
|
idx = locate_option(argc, argv, options, "v");
|
2011-09-26 09:15:37 +03:00
|
|
|
if (idx && argv[idx + 1])
|
2012-08-29 15:37:22 +03:00
|
|
|
opt_loglevel(NULL, "loglevel", argv[idx + 1]);
|
2011-12-08 16:42:24 +03:00
|
|
|
idx = locate_option(argc, argv, options, "report");
|
2012-11-02 15:15:51 +03:00
|
|
|
if ((env = getenv("FFREPORT")) || idx) {
|
|
|
|
init_report(env);
|
2011-12-08 16:42:24 +03:00
|
|
|
if (report_file) {
|
|
|
|
int i;
|
|
|
|
fprintf(report_file, "Command line:\n");
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
dump_argument(argv[i]);
|
|
|
|
fputc(i < argc - 1 ? ' ' : '\n', report_file);
|
|
|
|
}
|
|
|
|
fflush(report_file);
|
|
|
|
}
|
|
|
|
}
|
2013-12-28 07:18:39 +03:00
|
|
|
idx = locate_option(argc, argv, options, "hide_banner");
|
|
|
|
if (idx)
|
|
|
|
hide_banner = 1;
|
2011-09-26 09:15:37 +03:00
|
|
|
}
|
|
|
|
|
2013-08-28 01:12:18 +03:00
|
|
|
static const AVOption *opt_find(void *obj, const char *name, const char *unit,
|
|
|
|
int opt_flags, int search_flags)
|
|
|
|
{
|
2013-08-30 13:39:27 +03:00
|
|
|
const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
|
2013-08-28 01:12:18 +03:00
|
|
|
if(o && !o->flags)
|
|
|
|
return NULL;
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
2015-08-08 14:56:29 +02:00
|
|
|
#define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
|
2012-08-29 15:37:22 +03:00
|
|
|
int opt_default(void *optctx, const char *opt, const char *arg)
|
2011-05-25 17:42:41 +03:00
|
|
|
{
|
2012-05-30 15:40:28 +03:00
|
|
|
const AVOption *o;
|
2012-10-18 02:56:48 +03:00
|
|
|
int consumed = 0;
|
2011-07-28 17:47:38 +03:00
|
|
|
char opt_stripped[128];
|
|
|
|
const char *p;
|
2012-10-29 20:00:14 +03:00
|
|
|
const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
|
2013-02-25 05:32:30 +03:00
|
|
|
#if CONFIG_AVRESAMPLE
|
2012-12-19 05:47:28 +03:00
|
|
|
const AVClass *rc = avresample_get_class();
|
2013-02-25 05:32:30 +03:00
|
|
|
#endif
|
2015-09-19 16:20:26 +02:00
|
|
|
#if CONFIG_SWSCALE
|
|
|
|
const AVClass *sc = sws_get_class();
|
|
|
|
#endif
|
|
|
|
#if CONFIG_SWRESAMPLE
|
|
|
|
const AVClass *swr_class = swr_get_class();
|
|
|
|
#endif
|
2011-07-28 17:47:38 +03:00
|
|
|
|
2012-12-20 04:15:40 +03:00
|
|
|
if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
|
|
|
|
av_log_set_level(AV_LOG_DEBUG);
|
|
|
|
|
2011-07-28 17:47:38 +03:00
|
|
|
if (!(p = strchr(opt, ':')))
|
|
|
|
p = opt + strlen(opt);
|
|
|
|
av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
|
|
|
|
|
2013-08-28 01:12:18 +03:00
|
|
|
if ((o = opt_find(&cc, opt_stripped, NULL, 0,
|
2011-12-31 15:31:54 +03:00
|
|
|
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
|
|
|
|
((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
|
2013-08-28 01:12:18 +03:00
|
|
|
(o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
|
2012-05-30 15:40:28 +03:00
|
|
|
av_dict_set(&codec_opts, opt, arg, FLAGS);
|
2012-10-18 02:56:48 +03:00
|
|
|
consumed = 1;
|
|
|
|
}
|
2013-08-28 01:12:18 +03:00
|
|
|
if ((o = opt_find(&fc, opt, NULL, 0,
|
2013-03-10 13:04:24 +03:00
|
|
|
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
|
2012-05-30 15:40:28 +03:00
|
|
|
av_dict_set(&format_opts, opt, arg, FLAGS);
|
2013-03-10 13:04:24 +03:00
|
|
|
if (consumed)
|
2013-03-10 13:05:32 +03:00
|
|
|
av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
|
2012-10-18 02:56:48 +03:00
|
|
|
consumed = 1;
|
|
|
|
}
|
2011-09-18 19:57:35 +03:00
|
|
|
#if CONFIG_SWSCALE
|
2015-08-08 12:43:10 +02:00
|
|
|
if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
|
|
|
|
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
|
|
|
|
struct SwsContext *sws = sws_alloc_context();
|
|
|
|
int ret = av_opt_set(sws, opt, arg, 0);
|
|
|
|
sws_freeContext(sws);
|
2015-09-19 21:23:11 +02:00
|
|
|
if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
|
|
|
|
!strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
|
|
|
|
!strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2011-05-25 17:42:41 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
|
|
|
|
return ret;
|
|
|
|
}
|
2015-08-08 12:43:10 +02:00
|
|
|
|
|
|
|
av_dict_set(&sws_dict, opt, arg, FLAGS);
|
|
|
|
|
2012-10-18 02:56:48 +03:00
|
|
|
consumed = 1;
|
2011-05-25 17:42:41 +03:00
|
|
|
}
|
2014-06-29 18:01:39 +03:00
|
|
|
#else
|
|
|
|
if (!consumed && !strcmp(opt, "sws_flags")) {
|
|
|
|
av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
|
|
|
|
consumed = 1;
|
|
|
|
}
|
2011-09-18 19:57:35 +03:00
|
|
|
#endif
|
2012-05-29 17:43:33 +03:00
|
|
|
#if CONFIG_SWRESAMPLE
|
2013-08-28 01:12:18 +03:00
|
|
|
if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
|
2013-02-24 21:07:42 +03:00
|
|
|
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
|
|
|
|
struct SwrContext *swr = swr_alloc();
|
|
|
|
int ret = av_opt_set(swr, opt, arg, 0);
|
|
|
|
swr_free(&swr);
|
2012-04-11 14:46:02 +03:00
|
|
|
if (ret < 0) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
|
|
|
|
return ret;
|
|
|
|
}
|
2013-02-24 21:07:42 +03:00
|
|
|
av_dict_set(&swr_opts, opt, arg, FLAGS);
|
2012-10-18 02:56:48 +03:00
|
|
|
consumed = 1;
|
2012-04-11 14:46:02 +03:00
|
|
|
}
|
2012-05-29 17:43:33 +03:00
|
|
|
#endif
|
2013-02-24 19:30:52 +03:00
|
|
|
#if CONFIG_AVRESAMPLE
|
2013-08-28 01:12:18 +03:00
|
|
|
if ((o=opt_find(&rc, opt, NULL, 0,
|
2013-02-24 22:16:17 +03:00
|
|
|
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
|
2013-02-24 19:30:52 +03:00
|
|
|
av_dict_set(&resample_opts, opt, arg, FLAGS);
|
|
|
|
consumed = 1;
|
2011-05-25 17:42:41 +03:00
|
|
|
}
|
2012-10-29 20:00:14 +03:00
|
|
|
#endif
|
2011-05-25 17:42:41 +03:00
|
|
|
|
2012-10-18 02:56:48 +03:00
|
|
|
if (consumed)
|
2011-05-25 17:42:41 +03:00
|
|
|
return 0;
|
|
|
|
return AVERROR_OPTION_NOT_FOUND;
|
|
|
|
}
|
2011-04-19 22:57:46 +03:00
|
|
|
|
2012-06-10 21:46:30 +03:00
|
|
|
/*
|
|
|
|
* Check whether given option is a group separator.
|
|
|
|
*
|
|
|
|
* @return index of the group definition that matched or -1 if none
|
|
|
|
*/
|
2012-12-19 23:53:22 +03:00
|
|
|
static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
|
|
|
|
const char *opt)
|
2012-06-10 21:46:30 +03:00
|
|
|
{
|
2012-12-19 23:53:22 +03:00
|
|
|
int i;
|
2012-06-10 21:46:30 +03:00
|
|
|
|
2012-12-19 23:53:22 +03:00
|
|
|
for (i = 0; i < nb_groups; i++) {
|
|
|
|
const OptionGroupDef *p = &groups[i];
|
2012-06-10 21:46:30 +03:00
|
|
|
if (p->sep && !strcmp(p->sep, opt))
|
2012-12-19 23:53:22 +03:00
|
|
|
return i;
|
2012-06-10 21:46:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finish parsing an option group.
|
|
|
|
*
|
|
|
|
* @param group_idx which group definition should this group belong to
|
|
|
|
* @param arg argument of the group delimiting option
|
|
|
|
*/
|
|
|
|
static void finish_group(OptionParseContext *octx, int group_idx,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
OptionGroupList *l = &octx->groups[group_idx];
|
|
|
|
OptionGroup *g;
|
|
|
|
|
|
|
|
GROW_ARRAY(l->groups, l->nb_groups);
|
|
|
|
g = &l->groups[l->nb_groups - 1];
|
|
|
|
|
|
|
|
*g = octx->cur_group;
|
|
|
|
g->arg = arg;
|
|
|
|
g->group_def = l->group_def;
|
2015-08-08 12:43:10 +02:00
|
|
|
g->sws_dict = sws_dict;
|
2012-12-20 04:38:02 +03:00
|
|
|
g->swr_opts = swr_opts;
|
2012-06-10 21:46:30 +03:00
|
|
|
g->codec_opts = codec_opts;
|
|
|
|
g->format_opts = format_opts;
|
2012-12-19 05:47:28 +03:00
|
|
|
g->resample_opts = resample_opts;
|
2012-06-10 21:46:30 +03:00
|
|
|
|
|
|
|
codec_opts = NULL;
|
|
|
|
format_opts = NULL;
|
2012-12-19 05:47:28 +03:00
|
|
|
resample_opts = NULL;
|
2015-08-08 12:43:10 +02:00
|
|
|
sws_dict = NULL;
|
2012-12-20 04:38:02 +03:00
|
|
|
swr_opts = NULL;
|
2012-06-10 21:46:30 +03:00
|
|
|
init_opts();
|
|
|
|
|
|
|
|
memset(&octx->cur_group, 0, sizeof(octx->cur_group));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add an option instance to currently parsed group.
|
|
|
|
*/
|
|
|
|
static void add_opt(OptionParseContext *octx, const OptionDef *opt,
|
|
|
|
const char *key, const char *val)
|
|
|
|
{
|
|
|
|
int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
|
|
|
|
OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
|
|
|
|
|
|
|
|
GROW_ARRAY(g->opts, g->nb_opts);
|
|
|
|
g->opts[g->nb_opts - 1].opt = opt;
|
|
|
|
g->opts[g->nb_opts - 1].key = key;
|
|
|
|
g->opts[g->nb_opts - 1].val = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_parse_context(OptionParseContext *octx,
|
2012-12-19 23:53:22 +03:00
|
|
|
const OptionGroupDef *groups, int nb_groups)
|
2012-06-10 21:46:30 +03:00
|
|
|
{
|
|
|
|
static const OptionGroupDef global_group = { "global" };
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(octx, 0, sizeof(*octx));
|
|
|
|
|
2012-12-19 23:53:22 +03:00
|
|
|
octx->nb_groups = nb_groups;
|
2014-04-08 16:44:32 +03:00
|
|
|
octx->groups = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
|
2012-06-10 21:46:30 +03:00
|
|
|
if (!octx->groups)
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2012-06-10 21:46:30 +03:00
|
|
|
|
|
|
|
for (i = 0; i < octx->nb_groups; i++)
|
|
|
|
octx->groups[i].group_def = &groups[i];
|
|
|
|
|
|
|
|
octx->global_opts.group_def = &global_group;
|
|
|
|
octx->global_opts.arg = "";
|
|
|
|
|
|
|
|
init_opts();
|
|
|
|
}
|
|
|
|
|
|
|
|
void uninit_parse_context(OptionParseContext *octx)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < octx->nb_groups; i++) {
|
|
|
|
OptionGroupList *l = &octx->groups[i];
|
|
|
|
|
|
|
|
for (j = 0; j < l->nb_groups; j++) {
|
|
|
|
av_freep(&l->groups[j].opts);
|
|
|
|
av_dict_free(&l->groups[j].codec_opts);
|
|
|
|
av_dict_free(&l->groups[j].format_opts);
|
2012-12-19 05:47:28 +03:00
|
|
|
av_dict_free(&l->groups[j].resample_opts);
|
2015-08-08 12:43:10 +02:00
|
|
|
|
|
|
|
av_dict_free(&l->groups[j].sws_dict);
|
2013-02-24 21:07:42 +03:00
|
|
|
av_dict_free(&l->groups[j].swr_opts);
|
2012-06-10 21:46:30 +03:00
|
|
|
}
|
|
|
|
av_freep(&l->groups);
|
|
|
|
}
|
|
|
|
av_freep(&octx->groups);
|
|
|
|
|
|
|
|
av_freep(&octx->cur_group.opts);
|
|
|
|
av_freep(&octx->global_opts.opts);
|
|
|
|
|
|
|
|
uninit_opts();
|
|
|
|
}
|
|
|
|
|
|
|
|
int split_commandline(OptionParseContext *octx, int argc, char *argv[],
|
|
|
|
const OptionDef *options,
|
2012-12-19 23:53:22 +03:00
|
|
|
const OptionGroupDef *groups, int nb_groups)
|
2012-06-10 21:46:30 +03:00
|
|
|
{
|
|
|
|
int optindex = 1;
|
2013-01-17 19:03:07 +03:00
|
|
|
int dashdash = -2;
|
2012-06-10 21:46:30 +03:00
|
|
|
|
|
|
|
/* perform system-dependent conversions for arguments list */
|
|
|
|
prepare_app_arguments(&argc, &argv);
|
|
|
|
|
2012-12-19 23:53:22 +03:00
|
|
|
init_parse_context(octx, groups, nb_groups);
|
2012-06-10 21:46:30 +03:00
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
|
|
|
|
|
|
|
|
while (optindex < argc) {
|
|
|
|
const char *opt = argv[optindex++], *arg;
|
|
|
|
const OptionDef *po;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
|
|
|
|
|
2013-01-17 19:03:07 +03:00
|
|
|
if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
|
|
|
|
dashdash = optindex;
|
|
|
|
continue;
|
|
|
|
}
|
2012-06-10 21:46:30 +03:00
|
|
|
/* unnamed group separators, e.g. output filename */
|
2013-01-17 19:03:07 +03:00
|
|
|
if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
|
2012-06-10 21:46:30 +03:00
|
|
|
finish_group(octx, 0, opt);
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
opt++;
|
|
|
|
|
|
|
|
#define GET_ARG(arg) \
|
|
|
|
do { \
|
|
|
|
arg = argv[optindex++]; \
|
|
|
|
if (!arg) { \
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
|
|
|
|
return AVERROR(EINVAL); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/* named group separators, e.g. -i */
|
2012-12-19 23:53:22 +03:00
|
|
|
if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
|
2012-06-10 21:46:30 +03:00
|
|
|
GET_ARG(arg);
|
|
|
|
finish_group(octx, ret, arg);
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
|
|
|
|
groups[ret].name, arg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* normal options */
|
|
|
|
po = find_option(options, opt);
|
|
|
|
if (po->name) {
|
|
|
|
if (po->flags & OPT_EXIT) {
|
|
|
|
/* optional argument, e.g. -h */
|
|
|
|
arg = argv[optindex++];
|
|
|
|
} else if (po->flags & HAS_ARG) {
|
|
|
|
GET_ARG(arg);
|
|
|
|
} else {
|
|
|
|
arg = "1";
|
|
|
|
}
|
|
|
|
|
|
|
|
add_opt(octx, po, opt, arg);
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
|
|
|
|
"argument '%s'.\n", po->name, po->help, arg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* AVOptions */
|
|
|
|
if (argv[optindex]) {
|
|
|
|
ret = opt_default(NULL, opt, argv[optindex]);
|
|
|
|
if (ret >= 0) {
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
|
|
|
|
"argument '%s'.\n", opt, argv[optindex]);
|
|
|
|
optindex++;
|
|
|
|
continue;
|
|
|
|
} else if (ret != AVERROR_OPTION_NOT_FOUND) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
|
|
|
|
"with argument '%s'.\n", opt, argv[optindex]);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* boolean -nofoo options */
|
|
|
|
if (opt[0] == 'n' && opt[1] == 'o' &&
|
|
|
|
(po = find_option(options, opt + 2)) &&
|
|
|
|
po->name && po->flags & OPT_BOOL) {
|
|
|
|
add_opt(octx, po, opt, "0");
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
|
|
|
|
"argument 0.\n", po->name, po->help);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
|
|
|
|
return AVERROR_OPTION_NOT_FOUND;
|
|
|
|
}
|
|
|
|
|
2012-12-19 05:47:28 +03:00
|
|
|
if (octx->cur_group.nb_opts || codec_opts || format_opts || resample_opts)
|
2019-09-27 22:19:24 +02:00
|
|
|
av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
|
|
|
|
"command: may be ignored.\n");
|
2012-06-10 21:46:30 +03:00
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-14 06:41:45 +03:00
|
|
|
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
2013-10-22 20:01:36 +03:00
|
|
|
int ret;
|
|
|
|
unsigned flags = av_get_cpu_flags();
|
2013-10-14 06:41:45 +03:00
|
|
|
|
2013-10-22 20:01:36 +03:00
|
|
|
if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
|
|
|
|
return ret;
|
2013-10-14 06:41:45 +03:00
|
|
|
|
2013-10-22 20:01:36 +03:00
|
|
|
av_force_cpu_flags(flags);
|
2013-10-14 06:41:45 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int opt_loglevel(void *optctx, const char *opt, const char *arg)
|
2009-06-17 02:09:03 +03:00
|
|
|
{
|
2009-06-27 13:26:27 +03:00
|
|
|
const struct { const char *name; int level; } log_levels[] = {
|
2009-06-17 02:09:03 +03:00
|
|
|
{ "quiet" , AV_LOG_QUIET },
|
|
|
|
{ "panic" , AV_LOG_PANIC },
|
|
|
|
{ "fatal" , AV_LOG_FATAL },
|
|
|
|
{ "error" , AV_LOG_ERROR },
|
|
|
|
{ "warning", AV_LOG_WARNING },
|
|
|
|
{ "info" , AV_LOG_INFO },
|
|
|
|
{ "verbose", AV_LOG_VERBOSE },
|
|
|
|
{ "debug" , AV_LOG_DEBUG },
|
2015-03-16 10:57:34 +02:00
|
|
|
{ "trace" , AV_LOG_TRACE },
|
2009-06-17 02:09:03 +03:00
|
|
|
};
|
2018-04-03 08:54:10 +02:00
|
|
|
const char *token;
|
2009-06-17 02:09:03 +03:00
|
|
|
char *tail;
|
2018-04-03 08:54:10 +02:00
|
|
|
int flags = av_log_get_flags();
|
|
|
|
int level = av_log_get_level();
|
|
|
|
int cmd, i = 0;
|
|
|
|
|
|
|
|
av_assert0(arg);
|
|
|
|
while (*arg) {
|
|
|
|
token = arg;
|
|
|
|
if (*token == '+' || *token == '-') {
|
|
|
|
cmd = *token++;
|
|
|
|
} else {
|
|
|
|
cmd = 0;
|
|
|
|
}
|
|
|
|
if (!i && !cmd) {
|
|
|
|
flags = 0; /* missing relative prefix, build absolute value */
|
|
|
|
}
|
|
|
|
if (!strncmp(token, "repeat", 6)) {
|
|
|
|
if (cmd == '-') {
|
|
|
|
flags |= AV_LOG_SKIP_REPEATED;
|
|
|
|
} else {
|
|
|
|
flags &= ~AV_LOG_SKIP_REPEATED;
|
|
|
|
}
|
|
|
|
arg = token + 6;
|
|
|
|
} else if (!strncmp(token, "level", 5)) {
|
|
|
|
if (cmd == '-') {
|
|
|
|
flags &= ~AV_LOG_PRINT_LEVEL;
|
|
|
|
} else {
|
|
|
|
flags |= AV_LOG_PRINT_LEVEL;
|
|
|
|
}
|
|
|
|
arg = token + 5;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (!*arg) {
|
|
|
|
goto end;
|
|
|
|
} else if (*arg == '+') {
|
|
|
|
arg++;
|
|
|
|
} else if (!i) {
|
|
|
|
flags = av_log_get_flags(); /* level value without prefix, reset flags */
|
|
|
|
}
|
2013-03-31 15:08:03 +03:00
|
|
|
|
2009-06-17 02:09:03 +03:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
|
|
|
|
if (!strcmp(log_levels[i].name, arg)) {
|
2018-04-03 08:54:10 +02:00
|
|
|
level = log_levels[i].level;
|
|
|
|
goto end;
|
2009-06-17 02:09:03 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
level = strtol(arg, &tail, 10);
|
|
|
|
if (*tail) {
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
|
|
|
|
"Possible levels are numbers or:\n", arg);
|
2009-06-17 02:09:03 +03:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2009-06-17 02:09:03 +03:00
|
|
|
}
|
2018-04-03 08:54:10 +02:00
|
|
|
|
|
|
|
end:
|
|
|
|
av_log_set_flags(flags);
|
2009-06-17 02:09:03 +03:00
|
|
|
av_log_set_level(level);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:15:51 +03:00
|
|
|
static void expand_filename_template(AVBPrint *bp, const char *template,
|
|
|
|
struct tm *tm)
|
2011-12-08 16:42:24 +03:00
|
|
|
{
|
2012-11-02 15:15:51 +03:00
|
|
|
int c;
|
|
|
|
|
|
|
|
while ((c = *(template++))) {
|
|
|
|
if (c == '%') {
|
|
|
|
if (!(c = *(template++)))
|
|
|
|
break;
|
|
|
|
switch (c) {
|
|
|
|
case 'p':
|
|
|
|
av_bprintf(bp, "%s", program_name);
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
|
|
|
|
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
|
|
|
|
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
|
|
|
break;
|
|
|
|
case '%':
|
|
|
|
av_bprint_chars(bp, c, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
av_bprint_chars(bp, c, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init_report(const char *env)
|
|
|
|
{
|
2012-11-17 13:24:01 +03:00
|
|
|
char *filename_template = NULL;
|
2012-11-02 15:15:51 +03:00
|
|
|
char *key, *val;
|
|
|
|
int ret, count = 0;
|
2019-09-09 20:07:08 +02:00
|
|
|
int prog_loglevel, envlevel = 0;
|
2011-12-08 16:42:24 +03:00
|
|
|
time_t now;
|
|
|
|
struct tm *tm;
|
2012-11-02 15:15:51 +03:00
|
|
|
AVBPrint filename;
|
2011-12-08 16:42:24 +03:00
|
|
|
|
|
|
|
if (report_file) /* already opened */
|
|
|
|
return 0;
|
|
|
|
time(&now);
|
|
|
|
tm = localtime(&now);
|
2012-11-02 15:15:51 +03:00
|
|
|
|
|
|
|
while (env && *env) {
|
|
|
|
if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
|
|
|
|
if (count)
|
|
|
|
av_log(NULL, AV_LOG_ERROR,
|
|
|
|
"Failed to parse FFREPORT environment variable: %s\n",
|
|
|
|
av_err2str(ret));
|
|
|
|
break;
|
|
|
|
}
|
2012-11-10 15:03:09 +03:00
|
|
|
if (*env)
|
|
|
|
env++;
|
2012-11-02 15:15:51 +03:00
|
|
|
count++;
|
|
|
|
if (!strcmp(key, "file")) {
|
2012-11-17 13:24:01 +03:00
|
|
|
av_free(filename_template);
|
2012-11-02 15:15:51 +03:00
|
|
|
filename_template = val;
|
|
|
|
val = NULL;
|
2014-05-12 23:23:36 +03:00
|
|
|
} else if (!strcmp(key, "level")) {
|
|
|
|
char *tail;
|
|
|
|
report_file_level = strtol(val, &tail, 10);
|
|
|
|
if (*tail) {
|
|
|
|
av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
|
|
|
|
exit_program(1);
|
|
|
|
}
|
2019-09-09 20:07:08 +02:00
|
|
|
envlevel = 1;
|
2012-11-02 15:15:51 +03:00
|
|
|
} else {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
|
|
|
|
}
|
|
|
|
av_free(val);
|
|
|
|
av_free(key);
|
|
|
|
}
|
|
|
|
|
2018-06-10 09:53:24 +02:00
|
|
|
av_bprint_init(&filename, 0, AV_BPRINT_SIZE_AUTOMATIC);
|
2012-11-17 13:24:01 +03:00
|
|
|
expand_filename_template(&filename,
|
|
|
|
av_x_if_null(filename_template, "%p-%t.log"), tm);
|
|
|
|
av_free(filename_template);
|
2012-11-02 15:15:51 +03:00
|
|
|
if (!av_bprint_is_complete(&filename)) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
|
2019-09-09 20:07:08 +02:00
|
|
|
prog_loglevel = av_log_get_level();
|
|
|
|
if (!envlevel)
|
|
|
|
report_file_level = FFMAX(report_file_level, prog_loglevel);
|
|
|
|
|
2012-11-02 15:15:51 +03:00
|
|
|
report_file = fopen(filename.str, "w");
|
2011-12-08 16:42:24 +03:00
|
|
|
if (!report_file) {
|
2014-10-25 14:17:26 +03:00
|
|
|
int ret = AVERROR(errno);
|
2011-12-08 16:42:24 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
|
2012-11-02 15:15:51 +03:00
|
|
|
filename.str, strerror(errno));
|
2014-10-25 14:17:26 +03:00
|
|
|
return ret;
|
2011-12-08 16:42:24 +03:00
|
|
|
}
|
|
|
|
av_log_set_callback(log_callback_report);
|
|
|
|
av_log(NULL, AV_LOG_INFO,
|
|
|
|
"%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
|
2019-09-09 20:07:08 +02:00
|
|
|
"Report written to \"%s\"\n"
|
|
|
|
"Log level: %d\n",
|
2011-12-08 16:42:24 +03:00
|
|
|
program_name,
|
|
|
|
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
|
|
|
|
tm->tm_hour, tm->tm_min, tm->tm_sec,
|
2019-09-09 20:07:08 +02:00
|
|
|
filename.str, report_file_level);
|
2012-11-02 15:15:51 +03:00
|
|
|
av_bprint_finalize(&filename, NULL);
|
2011-12-08 16:42:24 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-08-06 03:17:05 +02:00
|
|
|
int opt_report(void *optctx, const char *opt, const char *arg)
|
2012-11-02 15:15:51 +03:00
|
|
|
{
|
|
|
|
return init_report(NULL);
|
|
|
|
}
|
|
|
|
|
2012-08-31 13:04:17 +03:00
|
|
|
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
|
2011-12-25 20:44:36 +03:00
|
|
|
{
|
|
|
|
char *tail;
|
|
|
|
size_t max;
|
|
|
|
|
|
|
|
max = strtol(arg, &tail, 10);
|
|
|
|
if (*tail) {
|
|
|
|
av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
|
2013-07-08 12:10:02 +03:00
|
|
|
exit_program(1);
|
2011-12-25 20:44:36 +03:00
|
|
|
}
|
|
|
|
av_max_alloc(max);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int opt_timelimit(void *optctx, const char *opt, const char *arg)
|
2010-01-20 08:42:39 +02:00
|
|
|
{
|
2010-02-10 00:55:11 +02:00
|
|
|
#if HAVE_SETRLIMIT
|
2010-01-20 08:42:39 +02:00
|
|
|
int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
|
|
|
|
struct rlimit rl = { lim, lim + 1 };
|
|
|
|
if (setrlimit(RLIMIT_CPU, &rl))
|
|
|
|
perror("setrlimit");
|
|
|
|
#else
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
|
2010-01-20 08:42:39 +02:00
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-06-07 21:34:02 +03:00
|
|
|
void print_error(const char *filename, int err)
|
|
|
|
{
|
2010-03-27 00:46:47 +02:00
|
|
|
char errbuf[128];
|
2010-05-06 00:44:54 +03:00
|
|
|
const char *errbuf_ptr = errbuf;
|
2010-03-27 00:46:47 +02:00
|
|
|
|
2010-05-06 00:45:00 +03:00
|
|
|
if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
|
|
|
|
errbuf_ptr = strerror(AVUNERROR(err));
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
|
2003-06-07 21:34:02 +03:00
|
|
|
}
|
2007-08-20 11:09:51 +03:00
|
|
|
|
2010-07-22 16:05:07 +03:00
|
|
|
static int warned_cfg = 0;
|
|
|
|
|
2010-07-22 16:04:58 +03:00
|
|
|
#define INDENT 1
|
|
|
|
#define SHOW_VERSION 2
|
2010-07-22 16:05:07 +03:00
|
|
|
#define SHOW_CONFIG 4
|
2012-01-01 18:42:35 +03:00
|
|
|
#define SHOW_COPYRIGHT 8
|
2010-07-22 16:04:58 +03:00
|
|
|
|
2011-09-26 09:39:43 +03:00
|
|
|
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
|
2010-01-27 14:58:26 +02:00
|
|
|
if (CONFIG_##LIBNAME) { \
|
2010-07-22 16:05:10 +03:00
|
|
|
const char *indent = flags & INDENT? " " : ""; \
|
2010-07-22 16:04:58 +03:00
|
|
|
if (flags & SHOW_VERSION) { \
|
2010-07-22 16:05:01 +03:00
|
|
|
unsigned int version = libname##_version(); \
|
2012-04-05 21:06:28 +03:00
|
|
|
av_log(NULL, level, \
|
2012-04-25 23:01:59 +03:00
|
|
|
"%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
|
2011-09-26 09:39:43 +03:00
|
|
|
indent, #libname, \
|
|
|
|
LIB##LIBNAME##_VERSION_MAJOR, \
|
|
|
|
LIB##LIBNAME##_VERSION_MINOR, \
|
|
|
|
LIB##LIBNAME##_VERSION_MICRO, \
|
2015-12-07 06:27:40 +02:00
|
|
|
AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
|
|
|
|
AV_VERSION_MICRO(version)); \
|
2010-07-22 16:04:58 +03:00
|
|
|
} \
|
2010-07-22 16:05:07 +03:00
|
|
|
if (flags & SHOW_CONFIG) { \
|
|
|
|
const char *cfg = libname##_configuration(); \
|
2011-03-17 18:01:10 +02:00
|
|
|
if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
|
2010-07-22 16:05:07 +03:00
|
|
|
if (!warned_cfg) { \
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, level, \
|
2010-07-22 16:05:07 +03:00
|
|
|
"%sWARNING: library configuration mismatch\n", \
|
2010-07-22 16:05:10 +03:00
|
|
|
indent); \
|
2010-07-22 16:05:07 +03:00
|
|
|
warned_cfg = 1; \
|
|
|
|
} \
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log(NULL, level, "%s%-11s configuration: %s\n", \
|
2010-07-22 16:05:10 +03:00
|
|
|
indent, #libname, cfg); \
|
2010-07-22 16:05:07 +03:00
|
|
|
} \
|
|
|
|
} \
|
2010-07-22 16:04:58 +03:00
|
|
|
} \
|
2008-08-13 23:08:37 +03:00
|
|
|
|
2011-09-26 09:39:43 +03:00
|
|
|
static void print_all_libs_info(int flags, int level)
|
2008-08-13 23:08:37 +03:00
|
|
|
{
|
2015-12-07 20:42:28 +02:00
|
|
|
PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
|
|
|
|
PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
|
|
|
|
PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
|
|
|
|
PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
|
|
|
|
PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
|
2013-03-10 13:48:11 +03:00
|
|
|
PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
|
2015-12-07 20:42:28 +02:00
|
|
|
PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
|
|
|
|
PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
|
|
|
|
PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
|
2008-08-13 23:08:37 +03:00
|
|
|
}
|
|
|
|
|
2012-01-01 18:42:35 +03:00
|
|
|
static void print_program_info(int flags, int level)
|
|
|
|
{
|
|
|
|
const char *indent = flags & INDENT? " " : "";
|
|
|
|
|
|
|
|
av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
|
|
|
|
if (flags & SHOW_COPYRIGHT)
|
|
|
|
av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
|
2013-11-26 12:03:32 +03:00
|
|
|
program_birth_year, CONFIG_THIS_YEAR);
|
2012-01-01 18:42:35 +03:00
|
|
|
av_log(NULL, level, "\n");
|
2015-02-02 01:20:18 +02:00
|
|
|
av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
|
2012-07-19 22:58:09 +03:00
|
|
|
|
2012-01-01 18:42:35 +03:00
|
|
|
av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
|
|
|
|
}
|
|
|
|
|
2013-08-11 19:17:57 +03:00
|
|
|
static void print_buildconf(int flags, int level)
|
|
|
|
{
|
2013-11-21 14:52:17 +03:00
|
|
|
const char *indent = flags & INDENT ? " " : "";
|
2013-08-11 19:17:57 +03:00
|
|
|
char str[] = { FFMPEG_CONFIGURATION };
|
|
|
|
char *conflist, *remove_tilde, *splitconf;
|
|
|
|
|
|
|
|
// Change all the ' --' strings to '~--' so that
|
|
|
|
// they can be identified as tokens.
|
2013-11-21 14:52:17 +03:00
|
|
|
while ((conflist = strstr(str, " --")) != NULL) {
|
2013-08-11 19:17:57 +03:00
|
|
|
strncpy(conflist, "~--", 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compensate for the weirdness this would cause
|
|
|
|
// when passing 'pkg-config --static'.
|
2013-11-21 14:52:17 +03:00
|
|
|
while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
|
|
|
|
strncpy(remove_tilde, "pkg-config ", 11);
|
2013-08-11 19:17:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
splitconf = strtok(str, "~");
|
2013-11-21 14:52:17 +03:00
|
|
|
av_log(NULL, level, "\n%sconfiguration:\n", indent);
|
2013-11-20 01:30:04 +03:00
|
|
|
while (splitconf != NULL) {
|
2013-08-11 19:17:57 +03:00
|
|
|
av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
|
|
|
|
splitconf = strtok(NULL, "~");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-21 00:03:25 +03:00
|
|
|
void show_banner(int argc, char **argv, const OptionDef *options)
|
2007-09-27 09:38:40 +03:00
|
|
|
{
|
2011-12-21 00:03:25 +03:00
|
|
|
int idx = locate_option(argc, argv, options, "version");
|
2013-12-28 07:18:39 +03:00
|
|
|
if (hide_banner || idx)
|
2011-12-21 00:03:25 +03:00
|
|
|
return;
|
|
|
|
|
2012-01-01 18:42:35 +03:00
|
|
|
print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
|
2011-09-29 13:59:05 +03:00
|
|
|
print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
|
|
|
|
print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
|
2007-09-27 09:38:40 +03:00
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_version(void *optctx, const char *opt, const char *arg)
|
2012-08-11 17:13:54 +03:00
|
|
|
{
|
2011-09-26 09:39:43 +03:00
|
|
|
av_log_set_callback(log_callback_help);
|
2014-06-11 02:58:44 +03:00
|
|
|
print_program_info (SHOW_COPYRIGHT, AV_LOG_INFO);
|
2011-09-26 09:39:43 +03:00
|
|
|
print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
|
2012-08-11 17:13:54 +03:00
|
|
|
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2007-09-27 09:38:40 +03:00
|
|
|
}
|
|
|
|
|
2013-08-11 19:17:57 +03:00
|
|
|
int show_buildconf(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
|
|
|
av_log_set_callback(log_callback_help);
|
|
|
|
print_buildconf (INDENT|0, AV_LOG_INFO);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_license(void *optctx, const char *opt, const char *arg)
|
2007-08-20 11:09:51 +03:00
|
|
|
{
|
2009-05-26 01:22:51 +03:00
|
|
|
#if CONFIG_NONFREE
|
2012-10-29 01:37:17 +03:00
|
|
|
printf(
|
2008-07-09 21:45:33 +03:00
|
|
|
"This version of %s has nonfree parts compiled in.\n"
|
|
|
|
"Therefore it is not legally redistributable.\n",
|
2012-10-29 01:37:17 +03:00
|
|
|
program_name );
|
2009-06-05 14:04:03 +03:00
|
|
|
#elif CONFIG_GPLV3
|
2012-10-29 01:37:17 +03:00
|
|
|
printf(
|
2009-06-05 14:04:03 +03:00
|
|
|
"%s is free software; you can redistribute it and/or modify\n"
|
|
|
|
"it under the terms of the GNU General Public License as published by\n"
|
|
|
|
"the Free Software Foundation; either version 3 of the License, or\n"
|
|
|
|
"(at your option) any later version.\n"
|
|
|
|
"\n"
|
|
|
|
"%s is distributed in the hope that it will be useful,\n"
|
|
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
|
|
"GNU General Public License for more details.\n"
|
|
|
|
"\n"
|
|
|
|
"You should have received a copy of the GNU General Public License\n"
|
|
|
|
"along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
|
2012-10-29 01:37:17 +03:00
|
|
|
program_name, program_name, program_name );
|
2008-01-30 10:07:18 +02:00
|
|
|
#elif CONFIG_GPL
|
2012-10-29 01:37:17 +03:00
|
|
|
printf(
|
2008-07-09 21:45:33 +03:00
|
|
|
"%s is free software; you can redistribute it and/or modify\n"
|
2007-08-20 11:09:51 +03:00
|
|
|
"it under the terms of the GNU General Public License as published by\n"
|
|
|
|
"the Free Software Foundation; either version 2 of the License, or\n"
|
|
|
|
"(at your option) any later version.\n"
|
|
|
|
"\n"
|
2008-07-09 21:45:33 +03:00
|
|
|
"%s is distributed in the hope that it will be useful,\n"
|
2007-08-20 11:09:51 +03:00
|
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
|
|
"GNU General Public License for more details.\n"
|
|
|
|
"\n"
|
|
|
|
"You should have received a copy of the GNU General Public License\n"
|
2008-07-09 21:45:33 +03:00
|
|
|
"along with %s; if not, write to the Free Software\n"
|
|
|
|
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
|
2012-10-29 01:37:17 +03:00
|
|
|
program_name, program_name, program_name );
|
2009-06-05 14:04:03 +03:00
|
|
|
#elif CONFIG_LGPLV3
|
2012-10-29 01:37:17 +03:00
|
|
|
printf(
|
2009-06-05 14:04:03 +03:00
|
|
|
"%s is free software; you can redistribute it and/or modify\n"
|
|
|
|
"it under the terms of the GNU Lesser General Public License as published by\n"
|
|
|
|
"the Free Software Foundation; either version 3 of the License, or\n"
|
|
|
|
"(at your option) any later version.\n"
|
|
|
|
"\n"
|
|
|
|
"%s is distributed in the hope that it will be useful,\n"
|
|
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
|
|
"GNU Lesser General Public License for more details.\n"
|
|
|
|
"\n"
|
|
|
|
"You should have received a copy of the GNU Lesser General Public License\n"
|
|
|
|
"along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
|
2012-10-29 01:37:17 +03:00
|
|
|
program_name, program_name, program_name );
|
2007-08-20 11:09:51 +03:00
|
|
|
#else
|
2012-10-29 01:37:17 +03:00
|
|
|
printf(
|
2008-07-09 21:45:33 +03:00
|
|
|
"%s is free software; you can redistribute it and/or\n"
|
2007-08-20 11:09:51 +03:00
|
|
|
"modify it under the terms of the GNU Lesser General Public\n"
|
|
|
|
"License as published by the Free Software Foundation; either\n"
|
|
|
|
"version 2.1 of the License, or (at your option) any later version.\n"
|
|
|
|
"\n"
|
2008-07-09 21:45:33 +03:00
|
|
|
"%s is distributed in the hope that it will be useful,\n"
|
2007-08-20 11:09:51 +03:00
|
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
|
|
|
|
"Lesser General Public License for more details.\n"
|
|
|
|
"\n"
|
|
|
|
"You should have received a copy of the GNU Lesser General Public\n"
|
2008-07-09 21:45:33 +03:00
|
|
|
"License along with %s; if not, write to the Free Software\n"
|
|
|
|
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
|
2012-10-29 01:37:17 +03:00
|
|
|
program_name, program_name, program_name );
|
2007-08-20 11:09:51 +03:00
|
|
|
#endif
|
2012-08-11 17:13:54 +03:00
|
|
|
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2007-08-20 11:09:51 +03:00
|
|
|
}
|
2008-05-22 15:55:35 +03:00
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
static int is_device(const AVClass *avclass)
|
|
|
|
{
|
|
|
|
if (!avclass)
|
|
|
|
return 0;
|
|
|
|
return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
|
|
|
|
}
|
|
|
|
|
2016-11-04 14:20:25 +02:00
|
|
|
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
|
2008-05-22 15:55:35 +03:00
|
|
|
{
|
2018-03-23 22:38:32 +02:00
|
|
|
void *ifmt_opaque = NULL;
|
|
|
|
const AVInputFormat *ifmt = NULL;
|
|
|
|
void *ofmt_opaque = NULL;
|
|
|
|
const AVOutputFormat *ofmt = NULL;
|
2008-05-22 15:55:35 +03:00
|
|
|
const char *last_name;
|
2018-02-08 18:20:36 +02:00
|
|
|
int is_dev;
|
2008-05-22 15:55:35 +03:00
|
|
|
|
2014-05-28 00:04:52 +03:00
|
|
|
printf("%s\n"
|
2011-12-31 15:31:54 +03:00
|
|
|
" D. = Demuxing supported\n"
|
|
|
|
" .E = Muxing supported\n"
|
2014-05-28 00:04:52 +03:00
|
|
|
" --\n", device_only ? "Devices:" : "File formats:");
|
2011-12-31 15:31:54 +03:00
|
|
|
last_name = "000";
|
|
|
|
for (;;) {
|
|
|
|
int decode = 0;
|
|
|
|
int encode = 0;
|
|
|
|
const char *name = NULL;
|
|
|
|
const char *long_name = NULL;
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
if (muxdemuxers !=SHOW_DEMUXERS) {
|
2018-04-01 16:29:46 +02:00
|
|
|
ofmt_opaque = NULL;
|
2018-03-23 22:38:32 +02:00
|
|
|
while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
|
2018-02-08 18:20:36 +02:00
|
|
|
is_dev = is_device(ofmt->priv_class);
|
|
|
|
if (!is_dev && device_only)
|
|
|
|
continue;
|
|
|
|
if ((!name || strcmp(ofmt->name, name) < 0) &&
|
|
|
|
strcmp(ofmt->name, last_name) > 0) {
|
|
|
|
name = ofmt->name;
|
|
|
|
long_name = ofmt->long_name;
|
|
|
|
encode = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (muxdemuxers != SHOW_MUXERS) {
|
2018-04-01 16:29:46 +02:00
|
|
|
ifmt_opaque = NULL;
|
2018-03-23 22:38:32 +02:00
|
|
|
while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
|
2018-02-08 18:20:36 +02:00
|
|
|
is_dev = is_device(ifmt->priv_class);
|
|
|
|
if (!is_dev && device_only)
|
|
|
|
continue;
|
|
|
|
if ((!name || strcmp(ifmt->name, name) < 0) &&
|
|
|
|
strcmp(ifmt->name, last_name) > 0) {
|
|
|
|
name = ifmt->name;
|
|
|
|
long_name = ifmt->long_name;
|
|
|
|
encode = 0;
|
|
|
|
}
|
|
|
|
if (name && strcmp(ifmt->name, name) == 0)
|
|
|
|
decode = 1;
|
|
|
|
}
|
|
|
|
}
|
2014-08-14 23:31:24 +03:00
|
|
|
if (!name)
|
2008-05-22 15:55:35 +03:00
|
|
|
break;
|
2011-12-31 15:31:54 +03:00
|
|
|
last_name = name;
|
2008-05-22 15:55:35 +03:00
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
printf(" %s%s %-15s %s\n",
|
|
|
|
decode ? "D" : " ",
|
|
|
|
encode ? "E" : " ",
|
|
|
|
name,
|
2008-05-22 15:55:35 +03:00
|
|
|
long_name ? long_name:" ");
|
|
|
|
}
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2009-11-19 18:35:55 +02:00
|
|
|
}
|
2008-05-22 15:55:35 +03:00
|
|
|
|
2014-05-28 00:04:52 +03:00
|
|
|
int show_formats(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
2016-11-04 14:20:25 +02:00
|
|
|
return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
|
|
|
|
}
|
|
|
|
|
|
|
|
int show_muxers(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
|
|
|
return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
|
|
|
|
}
|
|
|
|
|
|
|
|
int show_demuxers(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
|
|
|
return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
|
2014-05-28 00:04:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int show_devices(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
2016-11-04 14:20:25 +02:00
|
|
|
return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
|
2014-05-28 00:04:52 +03:00
|
|
|
}
|
|
|
|
|
2012-08-13 21:06:25 +03:00
|
|
|
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
|
|
|
|
if (codec->field) { \
|
2012-10-22 02:04:14 +03:00
|
|
|
const type *p = codec->field; \
|
2012-08-13 21:06:25 +03:00
|
|
|
\
|
|
|
|
printf(" Supported " list_name ":"); \
|
|
|
|
while (*p != term) { \
|
|
|
|
get_name(*p); \
|
|
|
|
printf(" %s", name); \
|
|
|
|
p++; \
|
|
|
|
} \
|
|
|
|
printf("\n"); \
|
|
|
|
} \
|
|
|
|
|
|
|
|
static void print_codec(const AVCodec *c)
|
|
|
|
{
|
|
|
|
int encoder = av_codec_is_encoder(c);
|
|
|
|
|
|
|
|
printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
|
|
|
|
c->long_name ? c->long_name : "");
|
|
|
|
|
2015-10-14 15:07:10 +02:00
|
|
|
printf(" General capabilities: ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
|
|
|
|
printf("horizband ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_DR1)
|
|
|
|
printf("dr1 ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
|
|
|
|
printf("trunc ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_DELAY)
|
|
|
|
printf("delay ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
|
|
|
|
printf("small ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
|
|
|
|
printf("subframes ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
|
|
|
|
printf("exp ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
|
|
|
|
printf("chconf ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
|
2015-10-19 13:57:22 +02:00
|
|
|
printf("paramchange ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
|
2015-10-14 15:07:10 +02:00
|
|
|
printf("variable ");
|
|
|
|
if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
|
|
|
|
AV_CODEC_CAP_SLICE_THREADS |
|
|
|
|
AV_CODEC_CAP_AUTO_THREADS))
|
|
|
|
printf("threads ");
|
2018-05-25 08:57:48 +02:00
|
|
|
if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
|
|
|
|
printf("avoidprobe ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_HARDWARE)
|
|
|
|
printf("hardware ");
|
|
|
|
if (c->capabilities & AV_CODEC_CAP_HYBRID)
|
|
|
|
printf("hybrid ");
|
2015-10-14 15:07:10 +02:00
|
|
|
if (!c->capabilities)
|
|
|
|
printf("none");
|
|
|
|
printf("\n");
|
|
|
|
|
2013-06-07 17:24:52 +03:00
|
|
|
if (c->type == AVMEDIA_TYPE_VIDEO ||
|
|
|
|
c->type == AVMEDIA_TYPE_AUDIO) {
|
2012-08-13 21:06:25 +03:00
|
|
|
printf(" Threading capabilities: ");
|
2015-07-07 02:41:27 +02:00
|
|
|
switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
|
2015-10-14 15:07:09 +02:00
|
|
|
AV_CODEC_CAP_SLICE_THREADS |
|
|
|
|
AV_CODEC_CAP_AUTO_THREADS)) {
|
2015-07-07 02:41:27 +02:00
|
|
|
case AV_CODEC_CAP_FRAME_THREADS |
|
|
|
|
AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
|
|
|
|
case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
|
|
|
|
case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
|
2015-10-14 15:07:09 +02:00
|
|
|
case AV_CODEC_CAP_AUTO_THREADS : printf("auto"); break;
|
|
|
|
default: printf("none"); break;
|
2012-08-13 21:06:25 +03:00
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
2018-05-26 14:57:45 +02:00
|
|
|
if (avcodec_get_hw_config(c, 0)) {
|
|
|
|
printf(" Supported hardware devices: ");
|
|
|
|
for (int i = 0;; i++) {
|
|
|
|
const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
|
|
|
|
if (!config)
|
|
|
|
break;
|
|
|
|
printf("%s ", av_hwdevice_get_type_name(config->device_type));
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
2012-08-13 21:06:25 +03:00
|
|
|
if (c->supported_framerates) {
|
|
|
|
const AVRational *fps = c->supported_framerates;
|
|
|
|
|
|
|
|
printf(" Supported framerates:");
|
|
|
|
while (fps->num) {
|
|
|
|
printf(" %d/%d", fps->num, fps->den);
|
|
|
|
fps++;
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
2012-10-06 13:10:34 +03:00
|
|
|
PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
|
|
|
|
AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
|
2012-08-13 21:06:25 +03:00
|
|
|
PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
|
|
|
|
GET_SAMPLE_RATE_NAME);
|
|
|
|
PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
|
|
|
|
AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME);
|
|
|
|
PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
|
|
|
|
0, GET_CH_LAYOUT_DESC);
|
|
|
|
|
|
|
|
if (c->priv_class) {
|
|
|
|
show_help_children(c->priv_class,
|
|
|
|
AV_OPT_FLAG_ENCODING_PARAM |
|
|
|
|
AV_OPT_FLAG_DECODING_PARAM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-19 22:50:30 +03:00
|
|
|
static char get_media_type_char(enum AVMediaType type)
|
|
|
|
{
|
2012-08-11 16:23:22 +03:00
|
|
|
switch (type) {
|
|
|
|
case AVMEDIA_TYPE_VIDEO: return 'V';
|
|
|
|
case AVMEDIA_TYPE_AUDIO: return 'A';
|
2012-08-18 16:10:13 +03:00
|
|
|
case AVMEDIA_TYPE_DATA: return 'D';
|
2012-08-11 16:23:22 +03:00
|
|
|
case AVMEDIA_TYPE_SUBTITLE: return 'S';
|
2012-08-18 16:10:13 +03:00
|
|
|
case AVMEDIA_TYPE_ATTACHMENT:return 'T';
|
2012-08-11 16:23:22 +03:00
|
|
|
default: return '?';
|
|
|
|
}
|
2012-01-19 22:50:30 +03:00
|
|
|
}
|
|
|
|
|
2020-04-14 10:09:24 +02:00
|
|
|
static const AVCodec *next_codec_for_id(enum AVCodecID id, void **iter,
|
2012-08-11 16:23:22 +03:00
|
|
|
int encoder)
|
2009-11-19 18:35:55 +02:00
|
|
|
{
|
2020-04-14 10:09:24 +02:00
|
|
|
const AVCodec *c;
|
|
|
|
while ((c = av_codec_iterate(iter))) {
|
|
|
|
if (c->id == id &&
|
|
|
|
(encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
|
|
|
|
return c;
|
2012-08-11 16:23:22 +03:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-09-22 20:26:27 +03:00
|
|
|
static int compare_codec_desc(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor * const *da = a;
|
|
|
|
const AVCodecDescriptor * const *db = b;
|
|
|
|
|
2015-11-01 17:43:56 +02:00
|
|
|
return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
|
2012-09-22 20:26:27 +03:00
|
|
|
strcmp((*da)->name, (*db)->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor *desc = NULL;
|
|
|
|
const AVCodecDescriptor **codecs;
|
|
|
|
unsigned nb_codecs = 0, i = 0;
|
|
|
|
|
|
|
|
while ((desc = avcodec_descriptor_next(desc)))
|
|
|
|
nb_codecs++;
|
|
|
|
if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
|
2012-11-23 20:10:02 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
|
2013-07-08 12:10:02 +03:00
|
|
|
exit_program(1);
|
2012-09-22 20:26:27 +03:00
|
|
|
}
|
|
|
|
desc = NULL;
|
|
|
|
while ((desc = avcodec_descriptor_next(desc)))
|
|
|
|
codecs[i++] = desc;
|
|
|
|
av_assert0(i == nb_codecs);
|
|
|
|
qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
|
|
|
|
*rcodecs = codecs;
|
|
|
|
return nb_codecs;
|
|
|
|
}
|
|
|
|
|
2012-08-11 16:23:22 +03:00
|
|
|
static void print_codecs_for_id(enum AVCodecID id, int encoder)
|
|
|
|
{
|
2020-04-14 10:09:24 +02:00
|
|
|
void *iter = NULL;
|
|
|
|
const AVCodec *codec;
|
2012-08-11 16:23:22 +03:00
|
|
|
|
|
|
|
printf(" (%s: ", encoder ? "encoders" : "decoders");
|
|
|
|
|
2020-04-14 10:09:24 +02:00
|
|
|
while ((codec = next_codec_for_id(id, &iter, encoder)))
|
2012-08-11 16:23:22 +03:00
|
|
|
printf("%s ", codec->name);
|
|
|
|
|
|
|
|
printf(")");
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_codecs(void *optctx, const char *opt, const char *arg)
|
2009-11-19 18:35:55 +02:00
|
|
|
{
|
2012-09-22 20:26:27 +03:00
|
|
|
const AVCodecDescriptor **codecs;
|
|
|
|
unsigned i, nb_codecs = get_codecs_sorted(&codecs);
|
2012-08-11 16:23:22 +03:00
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
printf("Codecs:\n"
|
2012-08-29 10:43:20 +03:00
|
|
|
" D..... = Decoding supported\n"
|
|
|
|
" .E.... = Encoding supported\n"
|
|
|
|
" ..V... = Video codec\n"
|
|
|
|
" ..A... = Audio codec\n"
|
|
|
|
" ..S... = Subtitle codec\n"
|
|
|
|
" ...I.. = Intra frame-only codec\n"
|
|
|
|
" ....L. = Lossy compression\n"
|
|
|
|
" .....S = Lossless compression\n"
|
|
|
|
" -------\n");
|
2012-09-22 20:26:27 +03:00
|
|
|
for (i = 0; i < nb_codecs; i++) {
|
|
|
|
const AVCodecDescriptor *desc = codecs[i];
|
2020-04-14 10:09:24 +02:00
|
|
|
const AVCodec *codec;
|
|
|
|
void *iter = NULL;
|
2012-08-11 16:23:22 +03:00
|
|
|
|
2014-04-29 22:55:59 +03:00
|
|
|
if (strstr(desc->name, "_deprecated"))
|
|
|
|
continue;
|
|
|
|
|
2012-08-25 09:49:23 +03:00
|
|
|
printf(" ");
|
2012-08-11 16:23:22 +03:00
|
|
|
printf(avcodec_find_decoder(desc->id) ? "D" : ".");
|
|
|
|
printf(avcodec_find_encoder(desc->id) ? "E" : ".");
|
|
|
|
|
|
|
|
printf("%c", get_media_type_char(desc->type));
|
|
|
|
printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
|
2012-08-29 10:43:20 +03:00
|
|
|
printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
|
|
|
|
printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
|
2012-08-11 16:23:22 +03:00
|
|
|
|
|
|
|
printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
|
|
|
|
|
|
|
|
/* print decoders/encoders when there's more than one or their
|
|
|
|
* names are different from codec name */
|
2020-04-14 10:09:24 +02:00
|
|
|
while ((codec = next_codec_for_id(desc->id, &iter, 0))) {
|
2012-08-11 16:23:22 +03:00
|
|
|
if (strcmp(codec->name, desc->name)) {
|
|
|
|
print_codecs_for_id(desc->id, 0);
|
|
|
|
break;
|
2008-05-22 15:55:35 +03:00
|
|
|
}
|
2012-08-11 16:23:22 +03:00
|
|
|
}
|
2020-04-14 10:09:24 +02:00
|
|
|
iter = NULL;
|
|
|
|
while ((codec = next_codec_for_id(desc->id, &iter, 1))) {
|
2012-08-11 16:23:22 +03:00
|
|
|
if (strcmp(codec->name, desc->name)) {
|
|
|
|
print_codecs_for_id(desc->id, 1);
|
|
|
|
break;
|
2008-05-22 15:55:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
}
|
2012-09-22 20:26:27 +03:00
|
|
|
av_free(codecs);
|
2012-08-18 16:10:13 +03:00
|
|
|
return 0;
|
2012-08-11 16:23:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void print_codecs(int encoder)
|
|
|
|
{
|
2012-09-22 20:26:27 +03:00
|
|
|
const AVCodecDescriptor **codecs;
|
|
|
|
unsigned i, nb_codecs = get_codecs_sorted(&codecs);
|
2012-08-11 16:23:22 +03:00
|
|
|
|
|
|
|
printf("%s:\n"
|
2012-08-18 16:10:13 +03:00
|
|
|
" V..... = Video\n"
|
|
|
|
" A..... = Audio\n"
|
|
|
|
" S..... = Subtitle\n"
|
|
|
|
" .F.... = Frame-level multithreading\n"
|
|
|
|
" ..S... = Slice-level multithreading\n"
|
|
|
|
" ...X.. = Codec is experimental\n"
|
|
|
|
" ....B. = Supports draw_horiz_band\n"
|
|
|
|
" .....D = Supports direct rendering method 1\n"
|
|
|
|
" ------\n",
|
2012-08-11 16:23:22 +03:00
|
|
|
encoder ? "Encoders" : "Decoders");
|
2012-09-22 20:26:27 +03:00
|
|
|
for (i = 0; i < nb_codecs; i++) {
|
|
|
|
const AVCodecDescriptor *desc = codecs[i];
|
2020-04-14 10:09:24 +02:00
|
|
|
const AVCodec *codec;
|
|
|
|
void *iter = NULL;
|
2012-08-11 16:23:22 +03:00
|
|
|
|
2020-04-14 10:09:24 +02:00
|
|
|
while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
|
2012-08-25 09:49:23 +03:00
|
|
|
printf(" %c", get_media_type_char(desc->type));
|
2015-07-07 02:41:27 +02:00
|
|
|
printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
|
|
|
|
printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
|
|
|
|
printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
|
2015-07-27 22:21:19 +02:00
|
|
|
printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
|
|
|
|
printf((codec->capabilities & AV_CODEC_CAP_DR1) ? "D" : ".");
|
2012-08-11 16:23:22 +03:00
|
|
|
|
|
|
|
printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
|
|
|
|
if (strcmp(codec->name, desc->name))
|
|
|
|
printf(" (codec %s)", desc->name);
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
2012-09-22 20:26:27 +03:00
|
|
|
av_free(codecs);
|
2012-08-11 16:23:22 +03:00
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_decoders(void *optctx, const char *opt, const char *arg)
|
2012-08-11 16:23:22 +03:00
|
|
|
{
|
|
|
|
print_codecs(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_encoders(void *optctx, const char *opt, const char *arg)
|
2012-08-11 16:23:22 +03:00
|
|
|
{
|
|
|
|
print_codecs(1);
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2009-11-19 18:35:55 +02:00
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_bsfs(void *optctx, const char *opt, const char *arg)
|
2009-11-19 18:35:55 +02:00
|
|
|
{
|
2016-09-21 15:39:16 +02:00
|
|
|
const AVBitStreamFilter *bsf = NULL;
|
|
|
|
void *opaque = NULL;
|
2008-05-22 15:55:35 +03:00
|
|
|
|
|
|
|
printf("Bitstream filters:\n");
|
2018-02-02 21:25:36 +02:00
|
|
|
while ((bsf = av_bsf_iterate(&opaque)))
|
2009-11-19 00:27:23 +02:00
|
|
|
printf("%s\n", bsf->name);
|
2008-05-22 15:55:35 +03:00
|
|
|
printf("\n");
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2009-11-19 18:35:55 +02:00
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_protocols(void *optctx, const char *opt, const char *arg)
|
2009-11-19 18:35:55 +02:00
|
|
|
{
|
2011-04-04 21:28:58 +03:00
|
|
|
void *opaque = NULL;
|
|
|
|
const char *name;
|
2008-05-22 15:55:35 +03:00
|
|
|
|
2010-07-30 01:38:28 +03:00
|
|
|
printf("Supported file protocols:\n"
|
2011-04-04 21:28:58 +03:00
|
|
|
"Input:\n");
|
|
|
|
while ((name = avio_enum_protocols(&opaque, 0)))
|
2015-04-19 00:31:23 +02:00
|
|
|
printf(" %s\n", name);
|
2011-04-04 21:28:58 +03:00
|
|
|
printf("Output:\n");
|
|
|
|
while ((name = avio_enum_protocols(&opaque, 1)))
|
2015-04-19 00:31:23 +02:00
|
|
|
printf(" %s\n", name);
|
2012-01-28 14:36:38 +03:00
|
|
|
return 0;
|
2008-05-22 15:55:35 +03:00
|
|
|
}
|
2009-03-18 23:35:49 +02:00
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_filters(void *optctx, const char *opt, const char *arg)
|
2009-12-12 18:18:11 +02:00
|
|
|
{
|
2014-09-03 00:25:33 +03:00
|
|
|
#if CONFIG_AVFILTER
|
|
|
|
const AVFilter *filter = NULL;
|
2012-01-19 22:50:44 +03:00
|
|
|
char descr[64], *descr_cur;
|
2018-03-23 22:38:32 +02:00
|
|
|
void *opaque = NULL;
|
2012-01-19 22:50:44 +03:00
|
|
|
int i, j;
|
|
|
|
const AVFilterPad *pad;
|
2009-12-12 18:18:11 +02:00
|
|
|
|
2013-04-17 12:31:49 +03:00
|
|
|
printf("Filters:\n"
|
2013-09-30 13:15:22 +03:00
|
|
|
" T.. = Timeline support\n"
|
|
|
|
" .S. = Slice threading\n"
|
2015-04-03 20:43:21 +02:00
|
|
|
" ..C = Command support\n"
|
2013-04-17 12:31:49 +03:00
|
|
|
" A = Audio input/output\n"
|
|
|
|
" V = Video input/output\n"
|
|
|
|
" N = Dynamic number and/or type of input/output\n"
|
|
|
|
" | = Source or sink filter\n");
|
2018-03-23 22:38:32 +02:00
|
|
|
while ((filter = av_filter_iterate(&opaque))) {
|
2012-01-19 22:50:44 +03:00
|
|
|
descr_cur = descr;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
if (i) {
|
|
|
|
*(descr_cur++) = '-';
|
|
|
|
*(descr_cur++) = '>';
|
|
|
|
}
|
2013-04-12 16:01:41 +03:00
|
|
|
pad = i ? filter->outputs : filter->inputs;
|
2015-08-08 10:41:31 +02:00
|
|
|
for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
|
2012-01-19 22:50:44 +03:00
|
|
|
if (descr_cur >= descr + sizeof(descr) - 4)
|
|
|
|
break;
|
2015-08-08 10:41:31 +02:00
|
|
|
*(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
|
2012-01-19 22:50:44 +03:00
|
|
|
}
|
|
|
|
if (!j)
|
2013-04-17 12:31:49 +03:00
|
|
|
*(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
|
|
|
|
( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
|
2012-01-19 22:50:44 +03:00
|
|
|
}
|
|
|
|
*descr_cur = 0;
|
2016-02-05 22:18:45 +02:00
|
|
|
printf(" %c%c%c %-17s %-10s %s\n",
|
2013-05-24 16:15:49 +03:00
|
|
|
filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
|
|
|
|
filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
|
2013-09-30 13:15:22 +03:00
|
|
|
filter->process_command ? 'C' : '.',
|
2013-05-19 18:30:23 +03:00
|
|
|
filter->name, descr, filter->description);
|
2012-01-19 22:50:44 +03:00
|
|
|
}
|
2014-09-03 00:25:33 +03:00
|
|
|
#else
|
|
|
|
printf("No filters available: libavfilter disabled\n");
|
2009-12-12 21:15:56 +02:00
|
|
|
#endif
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2009-12-12 18:18:11 +02:00
|
|
|
}
|
|
|
|
|
2013-10-28 11:39:38 +03:00
|
|
|
int show_colors(void *optctx, const char *opt, const char *arg)
|
2013-10-17 20:04:16 +03:00
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const uint8_t *rgb;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
printf("%-32s #RRGGBB\n", "name");
|
|
|
|
|
|
|
|
for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
|
|
|
|
printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
|
2013-10-28 11:39:38 +03:00
|
|
|
|
|
|
|
return 0;
|
2013-10-17 20:04:16 +03:00
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
|
2009-12-21 23:53:03 +02:00
|
|
|
{
|
2012-10-06 14:29:37 +03:00
|
|
|
const AVPixFmtDescriptor *pix_desc = NULL;
|
2010-02-11 01:36:35 +02:00
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
printf("Pixel formats:\n"
|
|
|
|
"I.... = Supported Input format for conversion\n"
|
|
|
|
".O... = Supported Output format for conversion\n"
|
|
|
|
"..H.. = Hardware accelerated format\n"
|
|
|
|
"...P. = Paletted format\n"
|
|
|
|
"....B = Bitstream format\n"
|
|
|
|
"FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
|
|
|
|
"-----\n");
|
2010-02-11 01:36:35 +02:00
|
|
|
|
2010-05-09 15:04:48 +03:00
|
|
|
#if !CONFIG_SWSCALE
|
|
|
|
# define sws_isSupportedInput(x) 0
|
|
|
|
# define sws_isSupportedOutput(x) 0
|
|
|
|
#endif
|
|
|
|
|
2012-10-06 14:29:37 +03:00
|
|
|
while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
|
2017-05-22 16:27:51 +02:00
|
|
|
enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
|
2010-02-11 01:36:35 +02:00
|
|
|
printf("%c%c%c%c%c %-16s %d %2d\n",
|
2013-05-12 16:41:49 +03:00
|
|
|
sws_isSupportedInput (pix_fmt) ? 'I' : '.',
|
|
|
|
sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
|
|
|
|
pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
|
|
|
|
pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
|
|
|
|
pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
|
2010-02-11 01:36:35 +02:00
|
|
|
pix_desc->name,
|
|
|
|
pix_desc->nb_components,
|
|
|
|
av_get_bits_per_pixel(pix_desc));
|
|
|
|
}
|
2011-06-29 19:38:46 +03:00
|
|
|
return 0;
|
2009-12-21 23:53:03 +02:00
|
|
|
}
|
|
|
|
|
2012-08-31 13:04:17 +03:00
|
|
|
int show_layouts(void *optctx, const char *opt, const char *arg)
|
2012-07-30 01:34:01 +03:00
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
uint64_t layout, j;
|
|
|
|
const char *name, *descr;
|
|
|
|
|
|
|
|
printf("Individual channels:\n"
|
2014-09-02 17:20:45 +03:00
|
|
|
"NAME DESCRIPTION\n");
|
2012-07-30 01:34:01 +03:00
|
|
|
for (i = 0; i < 63; i++) {
|
|
|
|
name = av_get_channel_name((uint64_t)1 << i);
|
|
|
|
if (!name)
|
|
|
|
continue;
|
|
|
|
descr = av_get_channel_description((uint64_t)1 << i);
|
2014-09-02 17:20:45 +03:00
|
|
|
printf("%-14s %s\n", name, descr);
|
2012-07-30 01:34:01 +03:00
|
|
|
}
|
|
|
|
printf("\nStandard channel layouts:\n"
|
2014-09-02 17:20:45 +03:00
|
|
|
"NAME DECOMPOSITION\n");
|
2012-07-30 01:34:01 +03:00
|
|
|
for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
|
|
|
|
if (name) {
|
2014-09-02 17:20:45 +03:00
|
|
|
printf("%-14s ", name);
|
2012-07-30 01:34:01 +03:00
|
|
|
for (j = 1; j; j <<= 1)
|
|
|
|
if ((layout & j))
|
|
|
|
printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
|
2011-08-31 09:51:15 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char fmt_str[128];
|
|
|
|
for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
|
|
|
|
printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-13 21:06:25 +03:00
|
|
|
static void show_help_codec(const char *name, int encoder)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor *desc;
|
|
|
|
const AVCodec *codec;
|
|
|
|
|
|
|
|
if (!name) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec = encoder ? avcodec_find_encoder_by_name(name) :
|
|
|
|
avcodec_find_decoder_by_name(name);
|
|
|
|
|
|
|
|
if (codec)
|
|
|
|
print_codec(codec);
|
|
|
|
else if ((desc = avcodec_descriptor_get_by_name(name))) {
|
2020-04-14 10:09:24 +02:00
|
|
|
void *iter = NULL;
|
2012-08-13 21:06:25 +03:00
|
|
|
int printed = 0;
|
|
|
|
|
2020-04-14 10:09:24 +02:00
|
|
|
while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
|
2012-08-13 21:06:25 +03:00
|
|
|
printed = 1;
|
|
|
|
print_codec(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!printed) {
|
2012-08-20 18:03:04 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
|
|
|
|
"but no %s for it are available. FFmpeg might need to be "
|
2012-08-13 21:06:25 +03:00
|
|
|
"recompiled with additional external libraries.\n",
|
|
|
|
name, encoder ? "encoders" : "decoders");
|
|
|
|
}
|
|
|
|
} else {
|
2012-08-20 18:03:04 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
|
2012-08-13 21:06:25 +03:00
|
|
|
name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-14 08:57:56 +03:00
|
|
|
static void show_help_demuxer(const char *name)
|
|
|
|
{
|
|
|
|
const AVInputFormat *fmt = av_find_input_format(name);
|
|
|
|
|
|
|
|
if (!fmt) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
|
|
|
|
|
|
|
|
if (fmt->extensions)
|
|
|
|
printf(" Common extensions: %s.\n", fmt->extensions);
|
|
|
|
|
|
|
|
if (fmt->priv_class)
|
|
|
|
show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
|
|
|
|
}
|
|
|
|
|
2019-11-27 07:57:02 +02:00
|
|
|
static void show_help_protocol(const char *name)
|
|
|
|
{
|
2020-01-30 16:03:17 +02:00
|
|
|
const AVClass *proto_class;
|
2019-11-27 07:57:02 +02:00
|
|
|
|
2020-01-30 16:03:17 +02:00
|
|
|
if (!name) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
proto_class = avio_protocol_get_class(name);
|
2019-11-27 07:57:02 +02:00
|
|
|
if (!proto_class) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
show_help_children(proto_class, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
|
|
|
|
}
|
|
|
|
|
2012-08-14 08:57:56 +03:00
|
|
|
static void show_help_muxer(const char *name)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor *desc;
|
|
|
|
const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
|
|
|
|
|
|
|
|
if (!fmt) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
|
|
|
|
|
|
|
|
if (fmt->extensions)
|
|
|
|
printf(" Common extensions: %s.\n", fmt->extensions);
|
|
|
|
if (fmt->mime_type)
|
|
|
|
printf(" Mime type: %s.\n", fmt->mime_type);
|
|
|
|
if (fmt->video_codec != AV_CODEC_ID_NONE &&
|
|
|
|
(desc = avcodec_descriptor_get(fmt->video_codec))) {
|
|
|
|
printf(" Default video codec: %s.\n", desc->name);
|
|
|
|
}
|
|
|
|
if (fmt->audio_codec != AV_CODEC_ID_NONE &&
|
|
|
|
(desc = avcodec_descriptor_get(fmt->audio_codec))) {
|
|
|
|
printf(" Default audio codec: %s.\n", desc->name);
|
|
|
|
}
|
|
|
|
if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
|
|
|
|
(desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
|
|
|
|
printf(" Default subtitle codec: %s.\n", desc->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fmt->priv_class)
|
|
|
|
show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
|
|
|
|
}
|
|
|
|
|
2013-04-16 17:09:16 +03:00
|
|
|
#if CONFIG_AVFILTER
|
2013-03-31 16:04:04 +03:00
|
|
|
static void show_help_filter(const char *name)
|
|
|
|
{
|
2013-04-01 20:56:59 +03:00
|
|
|
#if CONFIG_AVFILTER
|
2013-03-28 11:29:00 +03:00
|
|
|
const AVFilter *f = avfilter_get_by_name(name);
|
|
|
|
int i, count;
|
2013-03-31 16:04:04 +03:00
|
|
|
|
|
|
|
if (!name) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
|
|
|
|
return;
|
2013-03-28 11:29:00 +03:00
|
|
|
} else if (!f) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
|
2013-03-31 16:04:04 +03:00
|
|
|
return;
|
|
|
|
}
|
2013-03-28 11:29:00 +03:00
|
|
|
|
2013-04-12 17:14:36 +03:00
|
|
|
printf("Filter %s\n", f->name);
|
|
|
|
if (f->description)
|
|
|
|
printf(" %s\n", f->description);
|
2013-05-11 21:41:46 +03:00
|
|
|
|
|
|
|
if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
|
|
|
|
printf(" slice threading supported\n");
|
2013-03-28 11:29:00 +03:00
|
|
|
|
|
|
|
printf(" Inputs:\n");
|
|
|
|
count = avfilter_pad_count(f->inputs);
|
|
|
|
for (i = 0; i < count; i++) {
|
2013-04-17 15:31:21 +03:00
|
|
|
printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
|
2013-03-28 11:29:00 +03:00
|
|
|
media_type_string(avfilter_pad_get_type(f->inputs, i)));
|
|
|
|
}
|
|
|
|
if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
|
|
|
|
printf(" dynamic (depending on the options)\n");
|
2013-04-13 20:48:10 +03:00
|
|
|
else if (!count)
|
|
|
|
printf(" none (source filter)\n");
|
2013-03-28 11:29:00 +03:00
|
|
|
|
|
|
|
printf(" Outputs:\n");
|
|
|
|
count = avfilter_pad_count(f->outputs);
|
|
|
|
for (i = 0; i < count; i++) {
|
2013-04-17 15:31:21 +03:00
|
|
|
printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
|
2013-03-28 11:29:00 +03:00
|
|
|
media_type_string(avfilter_pad_get_type(f->outputs, i)));
|
|
|
|
}
|
|
|
|
if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
|
|
|
|
printf(" dynamic (depending on the options)\n");
|
2013-04-13 20:48:10 +03:00
|
|
|
else if (!count)
|
|
|
|
printf(" none (sink filter)\n");
|
2013-03-28 11:29:00 +03:00
|
|
|
|
|
|
|
if (f->priv_class)
|
2013-04-12 17:14:36 +03:00
|
|
|
show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
|
2013-03-28 11:29:00 +03:00
|
|
|
AV_OPT_FLAG_AUDIO_PARAM);
|
2013-04-08 21:35:02 +03:00
|
|
|
if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
|
|
|
|
printf("This filter has support for timeline through the 'enable' option.\n");
|
2013-04-01 20:56:59 +03:00
|
|
|
#else
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
|
|
|
|
"can not to satisfy request\n");
|
|
|
|
#endif
|
2013-03-31 16:04:04 +03:00
|
|
|
}
|
2013-04-16 17:09:16 +03:00
|
|
|
#endif
|
2013-03-31 16:04:04 +03:00
|
|
|
|
2018-03-08 07:50:31 +02:00
|
|
|
static void show_help_bsf(const char *name)
|
|
|
|
{
|
|
|
|
const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
|
|
|
|
|
2018-07-28 05:58:29 +02:00
|
|
|
if (!name) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
|
|
|
|
return;
|
|
|
|
} else if (!bsf) {
|
2018-03-08 07:50:31 +02:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Bit stream filter %s\n", bsf->name);
|
2018-03-22 03:09:45 +02:00
|
|
|
PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
|
|
|
|
AV_CODEC_ID_NONE, GET_CODEC_NAME);
|
2018-03-08 07:50:31 +02:00
|
|
|
if (bsf->priv_class)
|
|
|
|
show_help_children(bsf->priv_class, AV_OPT_FLAG_BSF_PARAM);
|
|
|
|
}
|
|
|
|
|
2012-08-29 15:37:22 +03:00
|
|
|
int show_help(void *optctx, const char *opt, const char *arg)
|
2012-08-13 21:06:25 +03:00
|
|
|
{
|
|
|
|
char *topic, *par;
|
|
|
|
av_log_set_callback(log_callback_help);
|
|
|
|
|
|
|
|
topic = av_strdup(arg ? arg : "");
|
2014-12-17 15:53:45 +02:00
|
|
|
if (!topic)
|
|
|
|
return AVERROR(ENOMEM);
|
2012-08-13 21:06:25 +03:00
|
|
|
par = strchr(topic, '=');
|
|
|
|
if (par)
|
|
|
|
*par++ = 0;
|
|
|
|
|
|
|
|
if (!*topic) {
|
|
|
|
show_help_default(topic, par);
|
|
|
|
} else if (!strcmp(topic, "decoder")) {
|
|
|
|
show_help_codec(par, 0);
|
|
|
|
} else if (!strcmp(topic, "encoder")) {
|
|
|
|
show_help_codec(par, 1);
|
2012-08-14 08:57:56 +03:00
|
|
|
} else if (!strcmp(topic, "demuxer")) {
|
|
|
|
show_help_demuxer(par);
|
|
|
|
} else if (!strcmp(topic, "muxer")) {
|
|
|
|
show_help_muxer(par);
|
2019-11-27 07:57:02 +02:00
|
|
|
} else if (!strcmp(topic, "protocol")) {
|
|
|
|
show_help_protocol(par);
|
2013-04-16 17:09:16 +03:00
|
|
|
#if CONFIG_AVFILTER
|
2013-03-31 16:04:04 +03:00
|
|
|
} else if (!strcmp(topic, "filter")) {
|
|
|
|
show_help_filter(par);
|
2013-04-16 17:09:16 +03:00
|
|
|
#endif
|
2018-03-08 07:50:31 +02:00
|
|
|
} else if (!strcmp(topic, "bsf")) {
|
|
|
|
show_help_bsf(par);
|
2012-08-13 21:06:25 +03:00
|
|
|
} else {
|
|
|
|
show_help_default(topic, par);
|
|
|
|
}
|
|
|
|
|
|
|
|
av_freep(&topic);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-18 23:35:49 +02:00
|
|
|
int read_yesno(void)
|
|
|
|
{
|
|
|
|
int c = getchar();
|
2013-03-03 13:17:50 +03:00
|
|
|
int yesno = (av_toupper(c) == 'Y');
|
2009-03-18 23:35:49 +02:00
|
|
|
|
|
|
|
while (c != '\n' && c != EOF)
|
|
|
|
c = getchar();
|
|
|
|
|
|
|
|
return yesno;
|
|
|
|
}
|
2010-04-02 01:34:22 +03:00
|
|
|
|
2010-11-05 01:07:04 +02:00
|
|
|
FILE *get_preset_file(char *filename, size_t filename_size,
|
2011-12-31 15:31:54 +03:00
|
|
|
const char *preset_name, int is_path,
|
|
|
|
const char *codec_name)
|
2010-11-05 01:07:04 +02:00
|
|
|
{
|
|
|
|
FILE *f = NULL;
|
|
|
|
int i;
|
2012-01-04 03:12:34 +03:00
|
|
|
const char *base[3] = { getenv("FFMPEG_DATADIR"),
|
2011-12-31 15:31:54 +03:00
|
|
|
getenv("HOME"),
|
2012-01-04 03:12:34 +03:00
|
|
|
FFMPEG_DATADIR, };
|
2010-11-05 01:07:04 +02:00
|
|
|
|
|
|
|
if (is_path) {
|
|
|
|
av_strlcpy(filename, preset_name, filename_size);
|
|
|
|
f = fopen(filename, "r");
|
|
|
|
} else {
|
2020-01-08 13:29:07 +02:00
|
|
|
#if HAVE_GETMODULEHANDLE && defined(_WIN32)
|
2011-05-21 04:36:26 +03:00
|
|
|
char datadir[MAX_PATH], *ls;
|
|
|
|
base[2] = NULL;
|
|
|
|
|
|
|
|
if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
|
|
|
|
{
|
|
|
|
for (ls = datadir; ls < datadir + strlen(datadir); ls++)
|
|
|
|
if (*ls == '\\') *ls = '/';
|
|
|
|
|
|
|
|
if (ls = strrchr(datadir, '/'))
|
|
|
|
{
|
|
|
|
*ls = 0;
|
|
|
|
strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
|
|
|
|
base[2] = datadir;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2010-11-05 01:07:04 +02:00
|
|
|
for (i = 0; i < 3 && !f; i++) {
|
|
|
|
if (!base[i])
|
|
|
|
continue;
|
2011-12-31 15:31:54 +03:00
|
|
|
snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
|
2012-01-04 03:12:34 +03:00
|
|
|
i != 1 ? "" : "/.ffmpeg", preset_name);
|
2010-11-05 01:07:04 +02:00
|
|
|
f = fopen(filename, "r");
|
|
|
|
if (!f && codec_name) {
|
|
|
|
snprintf(filename, filename_size,
|
2011-12-31 15:31:54 +03:00
|
|
|
"%s%s/%s-%s.ffpreset",
|
2012-03-19 01:12:35 +03:00
|
|
|
base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
|
2011-12-31 15:31:54 +03:00
|
|
|
preset_name);
|
2010-11-05 01:07:04 +02:00
|
|
|
f = fopen(filename, "r");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2011-07-28 17:47:38 +03:00
|
|
|
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
|
|
|
|
{
|
2012-07-18 12:41:13 +03:00
|
|
|
int ret = avformat_match_stream_specifier(s, st, spec);
|
|
|
|
if (ret < 0)
|
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
|
|
|
|
return ret;
|
2011-07-28 17:47:38 +03:00
|
|
|
}
|
|
|
|
|
2012-08-05 12:11:04 +03:00
|
|
|
AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
|
2012-06-30 01:28:02 +03:00
|
|
|
AVFormatContext *s, AVStream *st, AVCodec *codec)
|
2011-07-10 16:46:15 +03:00
|
|
|
{
|
|
|
|
AVDictionary *ret = NULL;
|
|
|
|
AVDictionaryEntry *t = NULL;
|
2011-12-31 15:31:54 +03:00
|
|
|
int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
|
|
|
|
: AV_OPT_FLAG_DECODING_PARAM;
|
2011-07-10 16:46:15 +03:00
|
|
|
char prefix = 0;
|
2011-08-23 08:43:54 +03:00
|
|
|
const AVClass *cc = avcodec_get_class();
|
2011-07-10 16:46:15 +03:00
|
|
|
|
2012-06-30 01:28:02 +03:00
|
|
|
if (!codec)
|
|
|
|
codec = s->oformat ? avcodec_find_encoder(codec_id)
|
|
|
|
: avcodec_find_decoder(codec_id);
|
2011-07-10 16:46:15 +03:00
|
|
|
|
2016-09-01 16:48:45 +02:00
|
|
|
switch (st->codecpar->codec_type) {
|
2011-12-31 15:31:54 +03:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
|
|
|
prefix = 'v';
|
|
|
|
flags |= AV_OPT_FLAG_VIDEO_PARAM;
|
|
|
|
break;
|
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
|
|
|
prefix = 'a';
|
|
|
|
flags |= AV_OPT_FLAG_AUDIO_PARAM;
|
|
|
|
break;
|
|
|
|
case AVMEDIA_TYPE_SUBTITLE:
|
|
|
|
prefix = 's';
|
|
|
|
flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
|
|
|
|
break;
|
2011-07-10 16:46:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
|
2011-07-28 17:47:38 +03:00
|
|
|
char *p = strchr(t->key, ':');
|
|
|
|
|
|
|
|
/* check stream specification in opt name */
|
|
|
|
if (p)
|
|
|
|
switch (check_stream_specifier(s, st, p + 1)) {
|
|
|
|
case 1: *p = 0; break;
|
|
|
|
case 0: continue;
|
2014-11-17 05:06:32 +02:00
|
|
|
default: exit_program(1);
|
2011-07-28 17:47:38 +03:00
|
|
|
}
|
|
|
|
|
2011-08-23 08:43:54 +03:00
|
|
|
if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
|
2014-03-28 18:03:33 +03:00
|
|
|
!codec ||
|
|
|
|
(codec->priv_class &&
|
2011-12-31 15:31:54 +03:00
|
|
|
av_opt_find(&codec->priv_class, t->key, NULL, flags,
|
|
|
|
AV_OPT_SEARCH_FAKE_OBJ)))
|
2011-07-10 16:46:15 +03:00
|
|
|
av_dict_set(&ret, t->key, t->value, 0);
|
2011-12-31 15:31:54 +03:00
|
|
|
else if (t->key[0] == prefix &&
|
|
|
|
av_opt_find(&cc, t->key + 1, NULL, flags,
|
|
|
|
AV_OPT_SEARCH_FAKE_OBJ))
|
|
|
|
av_dict_set(&ret, t->key + 1, t->value, 0);
|
2011-07-28 17:47:38 +03:00
|
|
|
|
|
|
|
if (p)
|
|
|
|
*p = ':';
|
2011-07-10 16:46:15 +03:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-31 15:31:54 +03:00
|
|
|
AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
|
|
|
|
AVDictionary *codec_opts)
|
2011-05-25 17:59:51 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
AVDictionary **opts;
|
|
|
|
|
|
|
|
if (!s->nb_streams)
|
|
|
|
return NULL;
|
2014-04-08 16:44:32 +03:00
|
|
|
opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
|
2011-05-25 17:59:51 +03:00
|
|
|
if (!opts) {
|
2011-12-31 15:31:54 +03:00
|
|
|
av_log(NULL, AV_LOG_ERROR,
|
|
|
|
"Could not alloc memory for stream options.\n");
|
2011-05-25 17:59:51 +03:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
for (i = 0; i < s->nb_streams; i++)
|
2016-09-01 16:48:45 +02:00
|
|
|
opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
|
2012-06-30 01:28:02 +03:00
|
|
|
s, s->streams[i], NULL);
|
2011-05-25 17:59:51 +03:00
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2011-08-29 08:11:57 +03:00
|
|
|
void *grow_array(void *array, int elem_size, int *size, int new_size)
|
|
|
|
{
|
|
|
|
if (new_size >= INT_MAX / elem_size) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2011-08-29 08:11:57 +03:00
|
|
|
}
|
|
|
|
if (*size < new_size) {
|
2015-01-06 18:52:54 +02:00
|
|
|
uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
|
2011-08-29 08:11:57 +03:00
|
|
|
if (!tmp) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
|
2013-07-07 02:52:51 +03:00
|
|
|
exit_program(1);
|
2011-08-29 08:11:57 +03:00
|
|
|
}
|
|
|
|
memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
|
|
|
|
*size = new_size;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
return array;
|
|
|
|
}
|
2014-08-07 01:45:26 +03:00
|
|
|
|
2015-05-05 07:46:42 +02:00
|
|
|
double get_rotation(AVStream *st)
|
|
|
|
{
|
|
|
|
uint8_t* displaymatrix = av_stream_get_side_data(st,
|
|
|
|
AV_PKT_DATA_DISPLAYMATRIX, NULL);
|
|
|
|
double theta = 0;
|
avformat, ffmpeg: deprecate old rotation API
The old "API" that signaled rotation as a metadata value has been
replaced by DISPLAYMATRIX side data quite a while ago.
There is no reason to make muxers/demuxers/API users support both. In
addition, the metadata API is dangerous, as user tags could "leak" into
it, creating unintended features or bugs.
ffmpeg CLI has to be updated to use the new API. In particular, we must
not allow to leak the "rotate" tag into the muxer. Some muxers will
catch this properly (like mov), but others (like mkv) can add it as
generic tag. Note applications, which use libavformat and assume the
old rotate API, will interpret such "rotate" user tags as rotate
metadata (which it is not), and incorrectly rotate the video.
The ffmpeg/ffplay tools drop the use of the old API for muxing and
demuxing, as all muxers/demuxers support the new API. This will mean
that the tools will not mistakenly interpret per-track "rotate" user
tags as rotate metadata. It will _not_ be treated as regression.
Unfortunately, hacks have been added, that allow the user to override
rotation by setting metadata explicitly, e.g. via
-metadata:s:v:0 rotate=0
See references to trac #4560. fate-filter-meta-4560-rotate0 tests this.
It's easier to adjust the hack for supporting it than arguing for its
removal, so ffmpeg CLI now explicitly catches this case, and essentially
replaces the "rotate" value with a display matrix side data. (It would
be easier for both user and implementation to create an explicit option
for rotation.)
When the code under FF_API_OLD_ROTATE_API is disabled, one FATE
reference file has to be updated (because "rotate" is not exported
anymore).
Tested-by: Michael Niedermayer <michael@niedermayer.cc>
Reviewed-by: Michael Niedermayer <michael@niedermayer.cc>
2017-03-21 09:02:58 +02:00
|
|
|
if (displaymatrix)
|
2015-05-18 01:11:02 +02:00
|
|
|
theta = -av_display_rotation_get((int32_t*) displaymatrix);
|
2015-05-05 07:46:42 +02:00
|
|
|
|
|
|
|
theta -= 360*floor(theta/360 + 0.9/360);
|
|
|
|
|
|
|
|
if (fabs(theta - 90*round(theta/90)) > 2)
|
2015-08-08 10:41:32 +02:00
|
|
|
av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
|
|
|
|
"If you want to help, upload a sample "
|
2020-05-10 21:01:35 +02:00
|
|
|
"of this file to https://streams.videolan.org/upload/ "
|
2015-08-08 10:41:32 +02:00
|
|
|
"and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
|
2015-05-05 07:46:42 +02:00
|
|
|
|
|
|
|
return theta;
|
|
|
|
}
|
|
|
|
|
2014-08-07 01:45:26 +03:00
|
|
|
#if CONFIG_AVDEVICE
|
2018-02-08 18:20:36 +02:00
|
|
|
static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
|
2014-08-07 01:45:26 +03:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
AVDeviceInfoList *device_list = NULL;
|
|
|
|
|
|
|
|
if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
2016-10-09 12:57:02 +02:00
|
|
|
printf("Auto-detected sources for %s:\n", fmt->name);
|
2014-08-07 01:45:26 +03:00
|
|
|
if (!fmt->get_device_list) {
|
|
|
|
ret = AVERROR(ENOSYS);
|
|
|
|
printf("Cannot list sources. Not implemented.\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
|
2014-08-07 01:45:26 +03:00
|
|
|
printf("Cannot list sources.\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < device_list->nb_devices; i++) {
|
|
|
|
printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
|
|
|
|
device_list->devices[i]->device_name, device_list->devices[i]->device_description);
|
|
|
|
}
|
|
|
|
|
|
|
|
fail:
|
|
|
|
avdevice_free_list_devices(&device_list);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
|
2014-08-07 01:45:26 +03:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
AVDeviceInfoList *device_list = NULL;
|
|
|
|
|
|
|
|
if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
2016-10-09 12:57:02 +02:00
|
|
|
printf("Auto-detected sinks for %s:\n", fmt->name);
|
2014-08-07 01:45:26 +03:00
|
|
|
if (!fmt->get_device_list) {
|
|
|
|
ret = AVERROR(ENOSYS);
|
|
|
|
printf("Cannot list sinks. Not implemented.\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
|
2014-08-07 01:45:26 +03:00
|
|
|
printf("Cannot list sinks.\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < device_list->nb_devices; i++) {
|
|
|
|
printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
|
|
|
|
device_list->devices[i]->device_name, device_list->devices[i]->device_description);
|
|
|
|
}
|
|
|
|
|
|
|
|
fail:
|
|
|
|
avdevice_free_list_devices(&device_list);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
if (arg) {
|
|
|
|
char *opts_str = NULL;
|
|
|
|
av_assert0(dev && opts);
|
|
|
|
*dev = av_strdup(arg);
|
|
|
|
if (!*dev)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
if ((opts_str = strchr(*dev, ','))) {
|
|
|
|
*(opts_str++) = '\0';
|
|
|
|
if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
|
|
|
|
av_freep(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
printf("\nDevice name is not provided.\n"
|
|
|
|
"You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int show_sources(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
2018-02-08 18:20:36 +02:00
|
|
|
AVInputFormat *fmt = NULL;
|
2014-08-07 01:45:26 +03:00
|
|
|
char *dev = NULL;
|
|
|
|
AVDictionary *opts = NULL;
|
|
|
|
int ret = 0;
|
|
|
|
int error_level = av_log_get_level();
|
|
|
|
|
|
|
|
av_log_set_level(AV_LOG_ERROR);
|
|
|
|
|
|
|
|
if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
do {
|
|
|
|
fmt = av_input_audio_device_next(fmt);
|
|
|
|
if (fmt) {
|
|
|
|
if (!strcmp(fmt->name, "lavfi"))
|
|
|
|
continue; //it's pointless to probe lavfi
|
|
|
|
if (dev && !av_match_name(dev, fmt->name))
|
|
|
|
continue;
|
|
|
|
print_device_sources(fmt, opts);
|
|
|
|
}
|
|
|
|
} while (fmt);
|
|
|
|
do {
|
|
|
|
fmt = av_input_video_device_next(fmt);
|
|
|
|
if (fmt) {
|
|
|
|
if (dev && !av_match_name(dev, fmt->name))
|
|
|
|
continue;
|
|
|
|
print_device_sources(fmt, opts);
|
|
|
|
}
|
|
|
|
} while (fmt);
|
2014-08-07 01:45:26 +03:00
|
|
|
fail:
|
|
|
|
av_dict_free(&opts);
|
|
|
|
av_free(dev);
|
|
|
|
av_log_set_level(error_level);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int show_sinks(void *optctx, const char *opt, const char *arg)
|
|
|
|
{
|
2018-02-08 18:20:36 +02:00
|
|
|
AVOutputFormat *fmt = NULL;
|
2014-08-07 01:45:26 +03:00
|
|
|
char *dev = NULL;
|
|
|
|
AVDictionary *opts = NULL;
|
|
|
|
int ret = 0;
|
|
|
|
int error_level = av_log_get_level();
|
|
|
|
|
|
|
|
av_log_set_level(AV_LOG_ERROR);
|
|
|
|
|
|
|
|
if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2018-02-08 18:20:36 +02:00
|
|
|
do {
|
|
|
|
fmt = av_output_audio_device_next(fmt);
|
|
|
|
if (fmt) {
|
|
|
|
if (dev && !av_match_name(dev, fmt->name))
|
|
|
|
continue;
|
|
|
|
print_device_sinks(fmt, opts);
|
|
|
|
}
|
|
|
|
} while (fmt);
|
|
|
|
do {
|
|
|
|
fmt = av_output_video_device_next(fmt);
|
|
|
|
if (fmt) {
|
|
|
|
if (dev && !av_match_name(dev, fmt->name))
|
|
|
|
continue;
|
|
|
|
print_device_sinks(fmt, opts);
|
|
|
|
}
|
|
|
|
} while (fmt);
|
2014-08-07 01:45:26 +03:00
|
|
|
fail:
|
|
|
|
av_dict_free(&opts);
|
|
|
|
av_free(dev);
|
|
|
|
av_log_set_level(error_level);
|
|
|
|
return ret;
|
|
|
|
}
|
2015-05-03 23:49:16 +02:00
|
|
|
|
2014-08-07 01:45:26 +03:00
|
|
|
#endif
|