/* * Various utilities for command line tools * Copyright (c) 2000-2003 Fabrice Bellard * * This file is part of FFmpeg. * * FFmpeg 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. * * FFmpeg 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 FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <string.h>#include <stdint.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 "compat/va_copy.h"#include "libavformat/avformat.h"#include "libswscale/swscale.h"#include "libswresample/swresample.h"#include "libavutil/avassert.h"#include "libavutil/avstring.h"#include "libavutil/bprint.h"#include "libavutil/display.h"#include "libavutil/getenv_utf8.h"#include "libavutil/libm.h"#include "libavutil/mem.h"#include "libavutil/parseutils.h"#include "libavutil/eval.h"#include "libavutil/dict.h"#include "libavutil/opt.h"#include "cmdutils.h"#include "fopen_utf8.h"#include "opt_common.h"#ifdef _WIN32#include <windows.h>#include "compat/w32dlfcn.h"#endif AVDictionary *sws_dict;AVDictionary *swr_opts;AVDictionary *format_opts, *codec_opts; int hide_banner = 0; void uninit_opts(void){    av_dict_free(&swr_opts);    av_dict_free(&sws_dict);    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);} void init_dynload(void){#if HAVE_SETDLLDIRECTORY && defined(_WIN32)    /* 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} int parse_number(const char *context, const char *numstr, enum OptionType type,                 double min, double max, double *dst){    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_TYPE_INT64 && (int64_t)d != d)        error = "Expected int64 for %s but found %s\n";    else if (type == OPT_TYPE_INT && (int)d != d)        error = "Expected int for %s but found %s\n";    else {        *dst = d;        return 0;    }     av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);    return AVERROR(EINVAL);} void show_help_options(const OptionDef *options, const char *msg, int req_flags,                       int rej_flags){    const OptionDef *po;    int first;     first = 1;    for (po = options; po->name; po++) {        char buf[128];         if (((po->flags & req_flags) != req_flags) ||            (po->flags & rej_flags))            continue;         if (first) {            printf("%s\n", msg);            first = 0;        }        av_strlcpy(buf, po->name, sizeof(buf));         if (po->flags & OPT_FLAG_PERSTREAM)            av_strlcat(buf, "[:<stream_spec>]", sizeof(buf));        else if (po->flags & OPT_FLAG_SPEC)            av_strlcat(buf, "[:<spec>]", sizeof(buf));         if (po->argname)            av_strlcatf(buf, sizeof(buf), " <%s>", po->argname);         printf("-%-17s  %s\n", buf, po->help);    }    printf("\n");} void show_help_children(const AVClass *class, int flags){    void *iter = NULL;    const AVClass *child;    if (class->option) {        av_opt_show2(&class, NULL, flags, 0);        printf("\n");    }     while (child = av_opt_child_class_iterate(class, &iter))        show_help_children(child, flags);} static const OptionDef *find_option(const OptionDef *po, const char *name){    if (*name == '/')        name++;     while (po->name) {        const char *end;        if (av_strstart(name, po->name, &end) && (!*end || *end == ':'))            break;        po++;    }    return po;} /* _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)#include <shellapi.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) {        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 /* HAVE_COMMANDLINETOARGVW */ static int opt_has_arg(const OptionDef *o){    if (o->type == OPT_TYPE_BOOL)        return 0;    if (o->type == OPT_TYPE_FUNC)        return !!(o->flags & OPT_FUNC_ARG);    return 1;} static int write_option(void *optctx, const OptionDef *po, const char *opt,                        const char *arg, const OptionDef *defs){    /* new-style options contain an offset into optctx, old-style address of     * a global var*/    void *dst = po->flags & OPT_FLAG_OFFSET ?                (uint8_t *)optctx + po->u.off : po->u.dst_ptr;    char *arg_allocated = NULL;     enum OptionType so_type = po->type;     SpecifierOptList *sol = NULL;    double num;    int ret = 0;     if (*opt == '/') {        opt++;         if (po->type == OPT_TYPE_BOOL) {            av_log(NULL, AV_LOG_FATAL,                   "Requested to load an argument from file for a bool option '%s'\n",                   po->name);            return AVERROR(EINVAL);        }         arg_allocated = file_read(arg);        if (!arg_allocated) {            av_log(NULL, AV_LOG_FATAL,                   "Error reading the value for option '%s' from file: %s\n",                   opt, arg);            return AVERROR(EINVAL);        }         arg = arg_allocated;    }     if (po->flags & OPT_FLAG_SPEC) {        char *p = strchr(opt, ':');        char *str;         sol = dst;        ret = GROW_ARRAY(sol->opt, sol->nb_opt);        if (ret < 0)            goto finish;         str = av_strdup(p ? p + 1 : "");        if (!str) {            ret = AVERROR(ENOMEM);            goto finish;        }        sol->opt[sol->nb_opt - 1].specifier = str;         if (po->flags & OPT_FLAG_PERSTREAM) {            ret = stream_specifier_parse(&sol->opt[sol->nb_opt - 1].stream_spec,                                         str, 0, NULL);            if (ret < 0)                goto finish;        }         dst = &sol->opt[sol->nb_opt - 1].u;    }     if (po->type == OPT_TYPE_STRING) {        char *str;        if (arg_allocated) {            str           = arg_allocated;            arg_allocated = NULL;        } else            str = av_strdup(arg);        av_freep(dst);         if (!str) {            ret = AVERROR(ENOMEM);            goto finish;        }         *(char **)dst = str;    } else if (po->type == OPT_TYPE_BOOL || po->type == OPT_TYPE_INT) {        ret = parse_number(opt, arg, OPT_TYPE_INT64, INT_MIN, INT_MAX, &num);        if (ret < 0)            goto finish;         *(int *)dst = num;        so_type = OPT_TYPE_INT;    } else if (po->type == OPT_TYPE_INT64) {        ret = parse_number(opt, arg, OPT_TYPE_INT64, INT64_MIN, (double)INT64_MAX, &num);        if (ret < 0)            goto finish;         *(int64_t *)dst = num;    } else if (po->type == OPT_TYPE_TIME) {        ret = av_parse_time(dst, arg, 1);        if (ret < 0) {            av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n",                   opt, arg);            goto finish;        }        so_type = OPT_TYPE_INT64;    } else if (po->type == OPT_TYPE_FLOAT) {        ret = parse_number(opt, arg, OPT_TYPE_FLOAT, -INFINITY, INFINITY, &num);        if (ret < 0)            goto finish;         *(float *)dst = num;    } else if (po->type == OPT_TYPE_DOUBLE) {        ret = parse_number(opt, arg, OPT_TYPE_DOUBLE, -INFINITY, INFINITY, &num);        if (ret < 0)            goto finish;         *(double *)dst = num;    } else {        av_assert0(po->type == OPT_TYPE_FUNC && po->u.func_arg);         ret = po->u.func_arg(optctx, opt, arg);        if (ret < 0) {            av_log(NULL, AV_LOG_ERROR,                   "Failed to set value '%s' for option '%s': %s\n",                   arg, opt, av_err2str(ret));            goto finish;        }    }    if (po->flags & OPT_EXIT) {        ret = AVERROR_EXIT;        goto finish;    }     if (sol) {        sol->type = so_type;        sol->opt_canon = (po->flags & OPT_HAS_CANON) ?                         find_option(defs, po->u1.name_canon) : po;    } finish:    av_freep(&arg_allocated);    return ret;} int parse_option(void *optctx, const char *opt, const char *arg,                 const OptionDef *options){    static const OptionDef opt_avoptions = {        .name       = "AVOption passthrough",        .type       = OPT_TYPE_FUNC,        .flags      = OPT_FUNC_ARG,        .u.func_arg = opt_default,    };     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->type == OPT_TYPE_BOOL))            arg = "0";    } else if (po->type == OPT_TYPE_BOOL)        arg = "1";     if (!po->name)        po = &opt_avoptions;    if (!po->name) {        av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);        return AVERROR(EINVAL);    }    if (opt_has_arg(po) && !arg) {        av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);        return AVERROR(EINVAL);    }     ret = write_option(optctx, po, opt, arg, options);    if (ret < 0)        return ret;     return opt_has_arg(po);} int parse_options(void *optctx, int argc, char **argv, const OptionDef *options,                  int (*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)                return ret;            optindex += ret;        } else {            if (parse_arg_function) {                ret = parse_arg_function(optctx, opt);                if (ret < 0)                    return ret;            }        }    }     return 0;} int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs){    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];         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);        }         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, defs);        if (ret < 0)            return ret;    }     av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");     return 0;} 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[0] == '-' && cur_opt[1]))            continue;        cur_opt++;         po = find_option(options, cur_opt);        if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')

Lines 1–500 of 1538. Load more