/* * Various utilities for command line tools * Copyright (c) 2000-2003 Fabrice Bellard * * This file is part of Libav. * * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * Libav is distributed in the hope that it will be useful, * 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 * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <string.h>#include <stdlib.h>#include <errno.h>#include <math.h> /* 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. */ #include "config.h"#include "libavformat/avformat.h"#include "libavfilter/avfilter.h"#include "libavdevice/avdevice.h"#include "libavresample/avresample.h"#include "libswscale/swscale.h"#include "libavutil/avassert.h"#include "libavutil/avstring.h"#include "libavutil/mathematics.h"#include "libavutil/imgutils.h"#include "libavutil/parseutils.h"#include "libavutil/pixdesc.h"#include "libavutil/eval.h"#include "libavutil/dict.h"#include "libavutil/opt.h"#include "cmdutils.h"#include "version.h"#if CONFIG_NETWORK#include "libavformat/network.h"#endif#if HAVE_SYS_RESOURCE_H#include <sys/resource.h>#endif struct SwsContext *sws_opts;AVDictionary *format_opts, *codec_opts; static const int this_year = 2012; void init_opts(void){#if CONFIG_SWSCALE    sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,                              NULL, NULL, NULL);#endif} void uninit_opts(void){#if CONFIG_SWSCALE    sws_freeContext(sws_opts);    sws_opts = NULL;#endif    av_dict_free(&format_opts);    av_dict_free(&codec_opts);} void log_callback_help(void *ptr, int level, const char *fmt, va_list vl){    vfprintf(stdout, fmt, vl);} double parse_number_or_die(const char *context, const char *numstr, int type,                           double min, double max){    char *tail;    const char *error;    double d = av_strtod(numstr, &tail);    if (*tail)        error = "Expected number for %s but found: %s\n";    else if (d < min || d > max)        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";    else if (type == OPT_INT && (int)d != d)        error = "Expected int for %s but found %s\n";    else        return d;    av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);    exit_program(1);    return 0;} int64_t parse_time_or_die(const char *context, const char *timestr,                          int is_duration){    int64_t us;    if (av_parse_time(&us, timestr, is_duration) < 0) {        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_options(const OptionDef *options, const char *msg, int mask,                       int value){    const OptionDef *po;    int first;     first = 1;    for (po = options; po->name != NULL; po++) {        char buf[64];        if ((po->flags & mask) == value) {            if (first) {                printf("%s", msg);                first = 0;            }            av_strlcpy(buf, po->name, sizeof(buf));            if (po->flags & HAS_ARG) {                av_strlcat(buf, " ", sizeof(buf));                av_strlcat(buf, po->argname, sizeof(buf));            }            printf("-%-17s  %s\n", buf, po->help);        }    }} 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);     while (po->name != NULL) {        if (!strncmp(name, po->name, len) && strlen(po->name) == len)            break;        po++;    }    return po;} #if defined(_WIN32) && !defined(__MINGW32CE__)#include <windows.h>/* 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);     win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);    argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);    if (win32_argv_utf8 == NULL) {        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;}#elsestatic inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr){    /* nothing to do */}#endif /* WIN32 && !__MINGW32CE__ */ int parse_option(void *optctx, const char *opt, const char *arg,                 const OptionDef *options){    const OptionDef *po;    int bool_val = 1;    int *dstcount;    void *dst;     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)))            bool_val = 0;    }    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);    }     /* new-style options contain an offset into optctx, old-style address of     * a global var*/    dst = po->flags & (OPT_OFFSET | OPT_SPEC) ? (uint8_t *)optctx + po->u.off                                              : po->u.dst_ptr;     if (po->flags & OPT_SPEC) {        SpecifierOpt **so = dst;        char *p = strchr(opt, ':');         dstcount = (int *)(so + 1);        *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);        (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");        dst = &(*so)[*dstcount - 1].u;    }     if (po->flags & OPT_STRING) {        char *str;        str = av_strdup(arg);        *(char **)dst = str;    } else if (po->flags & OPT_BOOL) {        *(int *)dst = bool_val;    } else if (po->flags & OPT_INT) {        *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);    } else if (po->flags & OPT_INT64) {        *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);    } else if (po->flags & OPT_TIME) {        *(int64_t *)dst = parse_time_or_die(opt, arg, 1);    } else if (po->flags & OPT_FLOAT) {        *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);    } else if (po->flags & OPT_DOUBLE) {        *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);    } else if (po->u.func_arg) {        int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)                                        : po->u.func_arg(opt, arg);        if (ret < 0) {            av_log(NULL, AV_LOG_ERROR,                   "Failed to set value '%s' for option '%s'\n", arg, opt);            return ret;        }    }    if (po->flags & OPT_EXIT)        exit_program(0);    return !!(po->flags & HAS_ARG);} void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,                   void (*parse_arg_function)(void *, const char*)){    const char *opt;    int optindex, handleoptions = 1, ret;     /* perform system-dependent conversions for arguments list */    prepare_app_arguments(&argc, &argv);     /* parse options */    optindex = 1;    while (optindex < argc) {        opt = argv[optindex++];         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {            if (opt[1] == '-' && opt[2] == '\0') {                handleoptions = 0;                continue;            }            opt++;             if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)                exit_program(1);            optindex += ret;        } else {            if (parse_arg_function)                parse_arg_function(optctx, opt);        }    }} 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;} 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]);} #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0int opt_default(const char *opt, const char *arg){    const AVOption *o;    char opt_stripped[128];    const char *p;    const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc = sws_get_class();     if (!(p = strchr(opt, ':')))        p = opt + strlen(opt);    av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));     if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||        ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&         (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))        av_dict_set(&codec_opts, opt, arg, FLAGS);    else if ((o = av_opt_find(&fc, opt, NULL, 0,                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))        av_dict_set(&format_opts, opt, arg, FLAGS);    else if ((o = 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_opt_set(sws_opts, opt, arg, 0);        if (ret < 0) {            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);            return ret;        }    }     if (o)        return 0;    av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);    return AVERROR_OPTION_NOT_FOUND;} int opt_loglevel(const char *opt, const char *arg){    const struct { const char *name; int level; } log_levels[] = {        { "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   },    };    char *tail;    int level;    int i;     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {        if (!strcmp(log_levels[i].name, arg)) {            av_log_set_level(log_levels[i].level);            return 0;        }    }     level = strtol(arg, &tail, 10);    if (*tail) {        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++)            av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);        exit_program(1);    }    av_log_set_level(level);    return 0;} int opt_timelimit(const char *opt, const char *arg){#if HAVE_SETRLIMIT    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    av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);#endif    return 0;} void print_error(const char *filename, int err){    char errbuf[128];    const char *errbuf_ptr = errbuf;     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)        errbuf_ptr = strerror(AVUNERROR(err));    av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);} static int warned_cfg = 0; #define INDENT        1#define SHOW_VERSION  2#define SHOW_CONFIG   4 #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();                 \            av_log(NULL, level,                                         \                   "%slib%-10s %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); \        }                                                               \        if (flags & SHOW_CONFIG) {                                      \            const char *cfg = libname##_configuration();                \            if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \                if (!warned_cfg) {                                      \                    av_log(NULL, level,                                 \                            "%sWARNING: library configuration mismatch\n", \                            indent);                                    \                    warned_cfg = 1;                                     \                }                                                       \                av_log(NULL, level, "%s%-11s configuration: %s\n",      \                        indent, #libname, cfg);                         \            }                                                           \        }                                                               \    }                                                                   \ static void print_all_libs_info(int flags, int level){    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(avresample, AVRESAMPLE, flags, level);    PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);} void show_banner(void)

Lines 1–500 of 1173. Load more