#include "libavfilter/avfilter.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
+#include "libswresample/swresample.h"
#include "libpostproc/postprocess.h"
#include "libavutil/avstring.h"
+#include "libavutil/mathematics.h"
#include "libavutil/parseutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/eval.h"
static const int this_year = 2011;
+static FILE *report_file;
+
void init_opts(void)
{
#if CONFIG_SWSCALE
vfprintf(stdout, fmt, vl);
}
+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);
+ fputs(line, report_file);
+ fflush(report_file);
+}
+
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
{
char *tail;
error= "Expected int for %s but found %s\n";
else
return d;
- fprintf(stderr, error, context, numstr, min, max);
+ av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
exit_program(1);
return 0;
}
{
int64_t us;
if (av_parse_time(&us, timestr, is_duration) < 0) {
- fprintf(stderr, "Invalid %s specification for %s: %s\n",
- is_duration ? "duration" : "date", context, timestr);
+ av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
+ is_duration ? "duration" : "date", context, timestr);
exit_program(1);
}
return us;
}
}
+void show_help_children(const AVClass *class, int flags)
+{
+ const AVClass *child = NULL;
+ av_opt_show2(&class, NULL, flags, 0);
+ printf("\n");
+
+ while (child = av_opt_child_class_next(class, child))
+ show_help_children(child, flags);
+}
+
static const OptionDef* find_option(const OptionDef *po, const char *name){
const char *p = strchr(name, ':');
int len = p ? p - name : strlen(name);
}
}
-#define FLAGS(o) ((o)->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
+/*
+ * Return index of option opt in argv or 0 if not found.
+ */
+static int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
+{
+ 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;
+
+ if (!po || po->flags & HAS_ARG)
+ i++;
+ }
+ return 0;
+}
+
+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);
+}
+
+void parse_loglevel(int argc, char **argv, const OptionDef *options)
+{
+ int idx = locate_option(argc, argv, options, "loglevel");
+ if (!idx)
+ idx = locate_option(argc, argv, options, "v");
+ if (idx && argv[idx + 1])
+ opt_loglevel("loglevel", argv[idx + 1]);
+ idx = locate_option(argc, argv, options, "report");
+ if (idx || getenv("FFREPORT")) {
+ opt_report("report");
+ 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);
+ }
+ }
+}
+
+#define FLAGS(o) ((o)->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
int opt_default(const char *opt, const char *arg)
{
const AVOption *oc, *of, *os;
char opt_stripped[128];
const char *p;
- const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();
+ const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc;
if (!(p = strchr(opt, ':')))
p = opt + strlen(opt);
av_dict_set(&codec_opts, opt, arg, FLAGS(oc));
if ((of = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
av_dict_set(&format_opts, opt, arg, FLAGS(of));
+#if CONFIG_SWSCALE
+ sc = sws_get_class();
if ((os = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
// XXX we only support sws_flags, not arbitrary sws options
- int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
+ int ret = av_opt_set(sws_opts, opt, arg, 0);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
return ret;
}
}
+#endif
if (oc || of || os)
return 0;
- fprintf(stderr, "Unrecognized option '%s'\n", opt);
+ av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
return AVERROR_OPTION_NOT_FOUND;
}
level = strtol(arg, &tail, 10);
if (*tail) {
- fprintf(stderr, "Invalid loglevel \"%s\". "
- "Possible levels are numbers or:\n", arg);
+ av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
+ "Possible levels are numbers or:\n", arg);
for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
- fprintf(stderr, "\"%s\"\n", log_levels[i].name);
+ av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
exit_program(1);
}
av_log_set_level(level);
return 0;
}
+int opt_report(const char *opt)
+{
+ char filename[64];
+ time_t now;
+ struct tm *tm;
+
+ if (report_file) /* already opened */
+ return 0;
+ time(&now);
+ tm = localtime(&now);
+ snprintf(filename, sizeof(filename), "%s-%04d%02d%02d-%02d%02d%02d.log",
+ program_name,
+ tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec);
+ report_file = fopen(filename, "w");
+ if (!report_file) {
+ av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
+ filename, strerror(errno));
+ return AVERROR(errno);
+ }
+ av_log_set_callback(log_callback_report);
+ av_log(NULL, AV_LOG_INFO,
+ "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
+ "Report written to \"%s\"\n",
+ program_name,
+ tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec,
+ filename);
+ av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
+ return 0;
+}
+
+int opt_max_alloc(const char *opt, const char *arg)
+{
+ char *tail;
+ size_t max;
+
+ max = strtol(arg, &tail, 10);
+ if (*tail) {
+ av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
+ exit_program(1);
+ }
+ av_max_alloc(max);
+ return 0;
+}
+
+int opt_codec_debug(const char *opt, const char *arg)
+{
+ av_log_set_level(AV_LOG_DEBUG);
+ return opt_default(opt, arg);
+}
+
int opt_timelimit(const char *opt, const char *arg)
{
#if HAVE_SETRLIMIT
if (setrlimit(RLIMIT_CPU, &rl))
perror("setrlimit");
#else
- fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
+ av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
#endif
return 0;
}
if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
errbuf_ptr = strerror(AVUNERROR(err));
- fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
+ av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
}
static int warned_cfg = 0;
#define SHOW_VERSION 2
#define SHOW_CONFIG 4
-#define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags) \
+#define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
if (CONFIG_##LIBNAME) { \
const char *indent = flags & INDENT? " " : ""; \
if (flags & SHOW_VERSION) { \
unsigned int version = libname##_version(); \
- fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
- indent, #libname, \
- LIB##LIBNAME##_VERSION_MAJOR, \
- LIB##LIBNAME##_VERSION_MINOR, \
- LIB##LIBNAME##_VERSION_MICRO, \
- version >> 16, version >> 8 & 0xff, version & 0xff); \
+ av_log(NULL, level, "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",\
+ indent, #libname, \
+ LIB##LIBNAME##_VERSION_MAJOR, \
+ LIB##LIBNAME##_VERSION_MINOR, \
+ LIB##LIBNAME##_VERSION_MICRO, \
+ version >> 16, version >> 8 & 0xff, version & 0xff); \
} \
if (flags & SHOW_CONFIG) { \
const char *cfg = libname##_configuration(); \
if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
if (!warned_cfg) { \
- fprintf(outstream, \
+ av_log(NULL, level, \
"%sWARNING: library configuration mismatch\n", \
indent); \
warned_cfg = 1; \
} \
- fprintf(stderr, "%s%-11s configuration: %s\n", \
+ av_log(NULL, level, "%s%-11s configuration: %s\n", \
indent, #libname, cfg); \
} \
} \
} \
-static void print_all_libs_info(FILE* outstream, int flags)
+static void print_all_libs_info(int flags, int level)
{
- PRINT_LIB_INFO(outstream, avutil, AVUTIL, flags);
- PRINT_LIB_INFO(outstream, avcodec, AVCODEC, flags);
- PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
- PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
- PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
- PRINT_LIB_INFO(outstream, swscale, SWSCALE, flags);
- PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
+ 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);
+ PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
+ PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
+ PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
}
-void show_banner(void)
+void show_banner(int argc, char **argv, const OptionDef *options)
{
- fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
- program_name, program_birth_year, this_year);
- fprintf(stderr, " built on %s %s with %s %s\n",
- __DATE__, __TIME__, CC_TYPE, CC_VERSION);
- fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
- print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
- print_all_libs_info(stderr, INDENT|SHOW_VERSION);
+ int idx = locate_option(argc, argv, options, "version");
+ if (idx)
+ return;
+
+ av_log(NULL, AV_LOG_INFO, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
+ program_name, program_birth_year, this_year);
+ av_log(NULL, AV_LOG_INFO, " built on %s %s with %s %s\n",
+ __DATE__, __TIME__, CC_TYPE, CC_VERSION);
+ av_log(NULL, AV_LOG_INFO, " configuration: " FFMPEG_CONFIGURATION "\n");
+ print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
+ print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
}
int opt_version(const char *opt, const char *arg) {
+ av_log_set_callback(log_callback_help);
printf("%s " FFMPEG_VERSION "\n", program_name);
- print_all_libs_info(stdout, SHOW_VERSION);
+ print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
return 0;
}
for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
+ if(!pix_desc->name)
+ continue;
printf("%c%c%c%c%c %-16s %d %2d\n",
sws_isSupportedInput (pix_fmt) ? 'I' : '.',
sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
return yesno;
}
-int read_file(const char *filename, char **bufptr, size_t *size)
+int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
{
+ int ret;
FILE *f = fopen(filename, "rb");
if (!f) {
- fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
+ av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename, strerror(errno));
return AVERROR(errno);
}
fseek(f, 0, SEEK_END);
fseek(f, 0, SEEK_SET);
*bufptr = av_malloc(*size + 1);
if (!*bufptr) {
- fprintf(stderr, "Could not allocate file buffer\n");
+ av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
fclose(f);
return AVERROR(ENOMEM);
}
- fread(*bufptr, 1, *size, f);
- (*bufptr)[*size++] = '\0';
+ ret = fread(*bufptr, 1, *size, f);
+ if (ret < *size) {
+ av_free(*bufptr);
+ if (ferror(f)) {
+ av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
+ filename, strerror(errno));
+ ret = AVERROR(errno);
+ } else
+ ret = AVERROR_EOF;
+ } else {
+ ret = 0;
+ (*bufptr)[*size++] = '\0';
+ }
fclose(f);
- return 0;
+ return ret;
}
FILE *get_preset_file(char *filename, size_t filename_size,
{
if (*spec <= '9' && *spec >= '0') /* opt:index */
return strtol(spec, NULL, 0) == st->index;
- else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd') { /* opt:[vasd] */
+ else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */
enum AVMediaType type;
switch (*spec++) {
case 'a': type = AVMEDIA_TYPE_AUDIO; break;
case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
case 'd': type = AVMEDIA_TYPE_DATA; break;
+ case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
default: abort(); // never reached, silence warning
}
if (type != st->codec->codec_type)
if (*endptr++ == ':') {
int stream_idx = strtol(endptr, NULL, 0);
- return (stream_idx >= 0 && stream_idx < s->programs[i]->nb_stream_indexes &&
- st->index == s->programs[i]->stream_index[stream_idx]);
+ return stream_idx >= 0 &&
+ stream_idx < s->programs[i]->nb_stream_indexes &&
+ st->index == s->programs[i]->stream_index[stream_idx];
}
for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
return AVERROR(EINVAL);
}
-AVDictionary *filter_codec_opts(AVDictionary *opts, enum CodecID codec_id, AVFormatContext *s, AVStream *st)
+AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec, AVFormatContext *s, AVStream *st)
{
AVDictionary *ret = NULL;
AVDictionaryEntry *t = NULL;
- AVCodec *codec = s->oformat ? avcodec_find_encoder(codec_id) : avcodec_find_decoder(codec_id);
int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM : AV_OPT_FLAG_DECODING_PARAM;
char prefix = 0;
const AVClass *cc = avcodec_get_class();
return NULL;
}
for (i = 0; i < s->nb_streams; i++)
- opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id, s, s->streams[i]);
+ opts[i] = filter_codec_opts(codec_opts, avcodec_find_decoder(s->streams[i]->codec->codec_id), s, s->streams[i]);
return opts;
}
projects / ffmpeg / blobdiff