/*
 * This file is part of MPlayer.
 *
 * MPlayer is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MPlayer 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/// \file
/// \ingroup Options

#include "config.h"

#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>
#include <inttypes.h>
#include <unistd.h>

#include "talloc.h"
#include "m_option.h"
#include "mp_msg.h"
#include "stream/url.h"
#include "libavutil/avstring.h"

const m_option_t *m_option_list_find(const m_option_t *list, const char *name)
{
    int i;

    for (i = 0; list[i].name; i++) {
        int l = strlen(list[i].name) - 1;
        if ((list[i].type->flags & M_OPT_TYPE_ALLOW_WILDCARD)
            && (l > 0) && (list[i].name[l] == '*')) {
            if (strncasecmp(list[i].name, name, l) == 0)
                return &list[i];
        } else if (strcasecmp(list[i].name, name) == 0)
            return &list[i];
    }
    return NULL;
}

// Default function that just does a memcpy

static void copy_opt(const m_option_t *opt, void *dst, const void *src)
{
    if (dst && src)
        memcpy(dst, src, opt->type->size);
}

// Flag

#define VAL(x) (*(int *)(x))

static int parse_flag(const m_option_t *opt, const char *name,
                      const char *param, bool ambiguous_param, void *dst)
{
    if (param && !ambiguous_param) {
        if (!strcasecmp(param, "yes") || /* any other language? */
            !strcasecmp(param, "on") ||
            !strcasecmp(param, "ja") ||
            !strcasecmp(param, "si") ||
            !strcasecmp(param, "igen") ||
            !strcasecmp(param, "y") ||
            !strcasecmp(param, "j") ||
            !strcasecmp(param, "i") ||
            !strcasecmp(param, "tak") ||
            !strcasecmp(param, "ja") ||
            !strcasecmp(param, "true") ||
            !strcmp(param, "1")) {
            if (dst)
                VAL(dst) = opt->max;
        } else if (!strcasecmp(param, "no") ||
                   !strcasecmp(param, "off") ||
                   !strcasecmp(param, "nein") ||
                   !strcasecmp(param, "nicht") ||
                   !strcasecmp(param, "nem") ||
                   !strcasecmp(param, "n") ||
                   !strcasecmp(param, "nie") ||
                   !strcasecmp(param, "nej") ||
                   !strcasecmp(param, "false") ||
                   !strcmp(param, "0")) {
            if (dst)
                VAL(dst) = opt->min;
        } else {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Invalid parameter for %s flag: %s\n", name, param);
            return M_OPT_INVALID;
        }
        return 1;
    } else {
        if (dst)
            VAL(dst) = opt->max;
        return 0;
    }
}

static char *print_flag(const m_option_t *opt, const void *val)
{
    if (VAL(val) == opt->min)
        return talloc_strdup(NULL, "no");
    else
        return talloc_strdup(NULL, "yes");
}

const m_option_type_t m_option_type_flag = {
    "Flag",
    "need yes or no in config files",
    sizeof(int),
    0,
    parse_flag,
    print_flag,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

// Integer

static int parse_int(const m_option_t *opt, const char *name,
                     const char *param, bool ambiguous_param, void *dst)
{
    long long tmp_int;
    char *endptr;

    if (param == NULL)
        return M_OPT_MISSING_PARAM;

    tmp_int = strtoll(param, &endptr, 10);
    if (*endptr)
        tmp_int = strtoll(param, &endptr, 0);
    if (*endptr) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "The %s option must be an integer: %s\n", name, param);
        return M_OPT_INVALID;
    }

    if ((opt->flags & M_OPT_MIN) && (tmp_int < opt->min)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "The %s option must be >= %d: %s\n",
               name, (int) opt->min, param);
        return M_OPT_OUT_OF_RANGE;
    }

    if ((opt->flags & M_OPT_MAX) && (tmp_int > opt->max)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "The %s option must be <= %d: %s\n",
               name, (int) opt->max, param);
        return M_OPT_OUT_OF_RANGE;
    }

    if (dst) {
        if (opt->type->size == sizeof(int64_t))
            *(int64_t *)dst = tmp_int;
        else
            VAL(dst) = tmp_int;
    }

    return 1;
}

static char *print_int(const m_option_t *opt, const void *val)
{
    if (opt->type->size == sizeof(int64_t))
        return talloc_asprintf(NULL, "%"PRId64, *(const int64_t *)val);
    return talloc_asprintf(NULL, "%d", VAL(val));
}

const m_option_type_t m_option_type_int = {
    "Integer",
    "",
    sizeof(int),
    0,
    parse_int,
    print_int,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

const m_option_type_t m_option_type_int64 = {
    "Integer64",
    "",
    sizeof(int64_t),
    0,
    parse_int,
    print_int,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

static int parse_intpair(const struct m_option *opt, const char *name,
                         const char *param, bool ambiguous_param, void *dst)
{
    if (param == NULL)
        return M_OPT_MISSING_PARAM;

    char *s = (char *)param;
    int start = -1;
    int end = -1;
    if (*s) {
        start = strtol(s, &s, 10);
        if (s == param)
            goto bad;
    }
    if (*s) {
        if (*s != '-')
            goto bad;
        s++;
    }
    if (*s)
        end = strtol(s, &s, 10);
    if (*s)
        goto bad;

    if (dst) {
        int *p = dst;
        p[0] = start;
        p[1] = end;
    }

    return 1;

bad:
    mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid integer range "
           "specification for option %s: %s\n", name, param);
    return M_OPT_INVALID;
}

const struct m_option_type m_option_type_intpair = {
    .name = "Int[-Int]",
    .size = sizeof(int[2]),
    .parse = parse_intpair,
    .save = copy_opt,
    .set = copy_opt,
};

static int parse_choice(const struct m_option *opt, const char *name,
                        const char *param, bool ambiguous_param, void *dst)
{
    if (param == NULL)
        return M_OPT_MISSING_PARAM;

    struct m_opt_choice_alternatives *alt;
    for (alt = opt->priv; alt->name; alt++)
        if (!strcmp(param, alt->name))
            break;
    if (!alt->name) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid value for option %s: %s\n",
               name, param);
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Valid values are:");
        for (alt = opt->priv; alt->name; alt++)
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s", alt->name);
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
        return M_OPT_INVALID;
    }
    if (dst)
        *(int *)dst = alt->value;

    return 1;
}

static char *print_choice(const m_option_t *opt, const void *val)
{
    int v = *(int *)val;
    struct m_opt_choice_alternatives *alt;
    for (alt = opt->priv; alt->name; alt++)
        if (alt->value == v)
            return talloc_strdup(NULL, alt->name);
    abort();
}

const struct m_option_type m_option_type_choice = {
    .name = "String",  // same as arbitrary strings in option list for now
    .size = sizeof(int),
    .parse = parse_choice,
    .print = print_choice,
    .save = copy_opt,
    .set = copy_opt,
};

// Float

#undef VAL
#define VAL(x) (*(double *)(x))

static int parse_double(const m_option_t *opt, const char *name,
                        const char *param, bool ambiguous_param, void *dst)
{
    double tmp_float;
    char *endptr;

    if (param == NULL)
        return M_OPT_MISSING_PARAM;

    tmp_float = strtod(param, &endptr);

    switch (*endptr) {
    case ':':
    case '/':
        tmp_float /= strtod(endptr + 1, &endptr);
        break;
    case '.':
    case ',':
        /* we also handle floats specified with
         * non-locale decimal point ::atmos
         */
        if (tmp_float < 0)
            tmp_float -= 1.0 / pow(10, strlen(endptr + 1)) *
                strtod(endptr + 1, &endptr);
        else
            tmp_float += 1.0 / pow(10, strlen(endptr + 1)) *
                strtod(endptr + 1, &endptr);
        break;
    }

    if (*endptr) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "The %s option must be a floating point number or a "
               "ratio (numerator[:/]denominator): %s\n", name, param);
        return M_OPT_INVALID;
    }

    if (opt->flags & M_OPT_MIN)
        if (tmp_float < opt->min) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "The %s option must be >= %f: %s\n", name, opt->min, param);
            return M_OPT_OUT_OF_RANGE;
        }

    if (opt->flags & M_OPT_MAX)
        if (tmp_float > opt->max) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "The %s option must be <= %f: %s\n", name, opt->max, param);
            return M_OPT_OUT_OF_RANGE;
        }

    if (dst)
        VAL(dst) = tmp_float;
    return 1;
}

static char *print_double(const m_option_t *opt, const void *val)
{
    opt = NULL;
    return talloc_asprintf(NULL, "%f", VAL(val));
}

const m_option_type_t m_option_type_double = {
    "Double",
    "double precision floating point number or ratio (numerator[:/]denominator)",
    sizeof(double),
    0,
    parse_double,
    print_double,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

#undef VAL
#define VAL(x) (*(float *)(x))

static int parse_float(const m_option_t *opt, const char *name,
                       const char *param, bool ambiguous_param, void *dst)
{
    double tmp;
    int r = parse_double(opt, name, param, false, &tmp);
    if (r == 1 && dst)
        VAL(dst) = tmp;
    return r;
}

static char *print_float(const m_option_t *opt, const void *val)
{
    opt = NULL;
    return talloc_asprintf(NULL, "%f", VAL(val));
}

const m_option_type_t m_option_type_float = {
    "Float",
    "floating point number or ratio (numerator[:/]denominator)",
    sizeof(float),
    0,
    parse_float,
    print_float,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

///////////// Position
#undef VAL
#define VAL(x) (*(off_t *)(x))

static int parse_position(const m_option_t *opt, const char *name,
                          const char *param, bool ambiguous_param, void *dst)
{
    off_t tmp_off;
    char dummy;

    if (param == NULL)
        return M_OPT_MISSING_PARAM;
    if (sscanf(param, sizeof(off_t) == sizeof(int) ?
               "%d%c" : "%"PRId64"%c", &tmp_off, &dummy) != 1) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "The %s option must be an integer: %s\n", opt->name, param);
        return M_OPT_INVALID;
    }

    if (opt->flags & M_OPT_MIN)
        if (tmp_off < opt->min) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "The %s option must be >= %"PRId64 ": %s\n",
                   name, (int64_t) opt->min, param);
            return M_OPT_OUT_OF_RANGE;
        }

    if (opt->flags & M_OPT_MAX)
        if (tmp_off > opt->max) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "The %s option must be <= %"PRId64 ": %s\n",
                   name, (int64_t) opt->max, param);
            return M_OPT_OUT_OF_RANGE;
        }

    if (dst)
        VAL(dst) = tmp_off;
    return 1;
}

static char *print_position(const m_option_t *opt, const void *val)
{
    return talloc_asprintf(NULL, "%"PRId64, (int64_t)VAL(val));
}

const m_option_type_t m_option_type_position = {
    "Position",
    "Integer (off_t)",
    sizeof(off_t),
    0,
    parse_position,
    print_position,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};


///////////// String

#undef VAL
#define VAL(x) (*(char **)(x))

static int parse_str(const m_option_t *opt, const char *name,
                     const char *param, bool ambiguous_param, void *dst)
{


    if (param == NULL)
        return M_OPT_MISSING_PARAM;

    if ((opt->flags & M_OPT_MIN) && (strlen(param) < opt->min)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Parameter must be >= %d chars: %s\n",
               (int) opt->min, param);
        return M_OPT_OUT_OF_RANGE;
    }

    if ((opt->flags & M_OPT_MAX) && (strlen(param) > opt->max)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Parameter must be <= %d chars: %s\n",
               (int) opt->max, param);
        return M_OPT_OUT_OF_RANGE;
    }

    if (dst) {
        talloc_free(VAL(dst));
        VAL(dst) = talloc_strdup(NULL, param);
    }

    return 1;

}

static char *print_str(const m_option_t *opt, const void *val)
{
    return (val && VAL(val)) ? talloc_strdup(NULL, VAL(val)) : NULL;
}

static void copy_str(const m_option_t *opt, void *dst, const void *src)
{
    if (dst && src) {
        talloc_free(VAL(dst));
        VAL(dst) = talloc_strdup(NULL, VAL(src));
    }
}

static void free_str(void *src)
{
    if (src && VAL(src)) {
        talloc_free(VAL(src));
        VAL(src) = NULL;
    }
}

const m_option_type_t m_option_type_string = {
    "String",
    "",
    sizeof(char *),
    M_OPT_TYPE_DYNAMIC,
    parse_str,
    print_str,
    copy_str,
    copy_str,
    copy_str,
    free_str
};

//////////// String list

#undef VAL
#define VAL(x) (*(char ***)(x))

#define OP_NONE 0
#define OP_ADD 1
#define OP_PRE 2
#define OP_DEL 3
#define OP_CLR 4

static void free_str_list(void *dst)
{
    char **d;
    int i;

    if (!dst || !VAL(dst))
        return;
    d = VAL(dst);

    for (i = 0; d[i] != NULL; i++)
        talloc_free(d[i]);
    talloc_free(d);
    VAL(dst) = NULL;
}

static int str_list_add(char **add, int n, void *dst, int pre)
{
    char **lst = VAL(dst);
    int ln;

    if (!dst)
        return M_OPT_PARSER_ERR;
    lst = VAL(dst);

    for (ln = 0; lst && lst[ln]; ln++)
        /**/;

    lst = talloc_realloc(NULL, lst, char *, n + ln + 1);

    if (pre) {
        memmove(&lst[n], lst, ln * sizeof(char *));
        memcpy(lst, add, n * sizeof(char *));
    } else
        memcpy(&lst[ln], add, n * sizeof(char *));
    // (re-)add NULL-termination
    lst[ln + n] = NULL;

    talloc_free(add);

    VAL(dst) = lst;

    return 1;
}

static int str_list_del(char **del, int n, void *dst)
{
    char **lst, *ep;
    int i, ln, s;
    long idx;

    if (!dst)
        return M_OPT_PARSER_ERR;
    lst = VAL(dst);

    for (ln = 0; lst && lst[ln]; ln++)
        /**/;
    s = ln;

    for (i = 0; del[i] != NULL; i++) {
        idx = strtol(del[i], &ep, 0);
        if (*ep) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid index: %s\n", del[i]);
            talloc_free(del[i]);
            continue;
        }
        talloc_free(del[i]);
        if (idx < 0 || idx >= ln) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Index %ld is out of range.\n", idx);
            continue;
        } else if (!lst[idx])
            continue;
        talloc_free(lst[idx]);
        lst[idx] = NULL;
        s--;
    }
    talloc_free(del);

    if (s == 0) {
        talloc_free(lst);
        VAL(dst) = NULL;
        return 1;
    }

    // Don't bother shrinking the list allocation
    for (i = 0, n = 0; i < ln; i++) {
        if (!lst[i])
            continue;
        lst[n] = lst[i];
        n++;
    }
    lst[s] = NULL;

    return 1;
}

static char *get_nextsep(char *ptr, char sep, int modify)
{
    char *last_ptr = ptr;
    for (;;) {
        ptr = strchr(ptr, sep);
        if (ptr && ptr > last_ptr && ptr[-1] == '\\') {
            if (modify)
                memmove(ptr - 1, ptr, strlen(ptr) + 1);
            else
                ptr++;
        } else
            break;
    }
    return ptr;
}

static int parse_str_list(const m_option_t *opt, const char *name,
                          const char *param, bool ambiguous_param, void *dst)
{
    int n = 0, len = strlen(opt->name);
    char *str;
    char *ptr = (char *)param, *last_ptr, **res;
    int op = OP_NONE;

    if (opt->name[len - 1] == '*' && ((int)strlen(name) > len - 1)) {
        const char *n = &name[len - 1];
        if (strcasecmp(n, "-add") == 0)
            op = OP_ADD;
        else if (strcasecmp(n, "-pre") == 0)
            op = OP_PRE;
        else if (strcasecmp(n, "-del") == 0)
            op = OP_DEL;
        else if (strcasecmp(n, "-clr") == 0)
            op = OP_CLR;
        else
            return M_OPT_UNKNOWN;
    }

    // Clear the list ??
    if (op == OP_CLR) {
        if (dst)
            free_str_list(dst);
        return 0;
    }

    // All other ops need a param
    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    // custom type for "profile" calls this but uses ->priv for something else
    char separator = opt->type == &m_option_type_string_list && opt->priv ?
                     *(char *)opt->priv : OPTION_LIST_SEPARATOR;
    while (ptr[0] != '\0') {
        ptr = get_nextsep(ptr, separator, 0);
        if (!ptr) {
            n++;
            break;
        }
        ptr++;
        n++;
    }
    if (n == 0)
        return M_OPT_INVALID;
    if (((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
        ((opt->flags & M_OPT_MAX) && (n > opt->max)))
        return M_OPT_OUT_OF_RANGE;

    if (!dst)
        return 1;

    res = talloc_array(NULL, char *, n + 2);
    ptr = str = talloc_strdup(NULL, param);
    n = 0;

    while (1) {
        last_ptr = ptr;
        ptr = get_nextsep(ptr, separator, 1);
        if (!ptr) {
            res[n] = talloc_strdup(NULL, last_ptr);
            n++;
            break;
        }
        len = ptr - last_ptr;
        res[n] = talloc_strndup(NULL, last_ptr, len);
        ptr++;
        n++;
    }
    res[n] = NULL;
    talloc_free(str);

    switch (op) {
    case OP_ADD:
        return str_list_add(res, n, dst, 0);
    case OP_PRE:
        return str_list_add(res, n, dst, 1);
    case OP_DEL:
        return str_list_del(res, n, dst);
    }

    if (VAL(dst))
        free_str_list(dst);
    VAL(dst) = res;

    return 1;
}

static void copy_str_list(const m_option_t *opt, void *dst, const void *src)
{
    int n;
    char **d, **s;

    if (!(dst && src))
        return;
    s = VAL(src);

    if (VAL(dst))
        free_str_list(dst);

    if (!s) {
        VAL(dst) = NULL;
        return;
    }

    for (n = 0; s[n] != NULL; n++)
        /* NOTHING */;
    d = talloc_array(NULL, char *, n + 1);
    for (; n >= 0; n--)
        d[n] = talloc_strdup(NULL, s[n]);

    VAL(dst) = d;
}

static char *print_str_list(const m_option_t *opt, const void *src)
{
    char **lst = NULL;
    char *ret = NULL;

    if (!(src && VAL(src)))
        return NULL;
    lst = VAL(src);

    for (int i = 0; lst[i]; i++) {
        if (ret)
            ret = talloc_strdup_append_buffer(ret, ",");
        ret = talloc_strdup_append_buffer(ret, lst[i]);
    }
    return ret;
}

const m_option_type_t m_option_type_string_list = {
    "String list",
    "A list of strings separated by ','\n"
    "Option with a name ending in an * permits using the following suffix: \n"
    "\t-add: Add the given parameters at the end of the list.\n"
    "\t-pre: Add the given parameters at the beginning of the list.\n"
    "\t-del: Remove the entry at the given indices.\n"
    "\t-clr: Clear the list.\n"
    "e.g: -vf-add flip,mirror -vf-del 2,5\n",
    sizeof(char **),
    M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
    parse_str_list,
    print_str_list,
    copy_str_list,
    copy_str_list,
    copy_str_list,
    free_str_list
};


///////////////////  Func based options

// A chained list to save the various calls for func_param
struct m_func_save {
    struct m_func_save *next;
    char *name;
    char *param;
};

#undef VAL
#define VAL(x) (*(struct m_func_save **)(x))

static void free_func_pf(void *src)
{
    struct m_func_save *s, *n;

    if (!src)
        return;

    s = VAL(src);

    while (s) {
        n = s->next;
        talloc_free(s->name);
        talloc_free(s->param);
        talloc_free(s);
        s = n;
    }
    VAL(src) = NULL;
}

// Parser for func_param
static int parse_func_pf(const m_option_t *opt, const char *name,
                         const char *param, bool ambiguous_param, void *dst)
{
    struct m_func_save *s, *p;

    if (!dst)
        return 1;

    s = talloc_zero(NULL, struct m_func_save);
    s->name = talloc_strdup(NULL, name);
    s->param = talloc_strdup(NULL, param);

    p = VAL(dst);
    if (p) {
        for (; p->next != NULL; p = p->next)
            /**/;
        p->next = s;
    } else
        VAL(dst) = s;

    return 1;
}

static void copy_func_pf(const m_option_t *opt, void *dst, const void *src)
{
    struct m_func_save *d = NULL, *s, *last = NULL;

    if (!(dst && src))
        return;
    s = VAL(src);

    if (VAL(dst))
        free_func_pf(dst);

    while (s) {
        d = talloc_zero(NULL, struct m_func_save);
        d->name = talloc_strdup(NULL, s->name);
        d->param = talloc_strdup(NULL, s->param);
        if (last)
            last->next = d;
        else
            VAL(dst) = d;
        last = d;
        s = s->next;
    }


}

/////////////////// Func_param

static void set_func_param(const m_option_t *opt, void *dst, const void *src)
{
    struct m_func_save *s;

    if (!src)
        return;
    s = VAL(src);

    if (!s)
        return;

    for (; s != NULL; s = s->next)
        ((m_opt_func_param_t) opt->p)(opt, s->param);
}

const m_option_type_t m_option_type_func_param = {
    "Func param",
    "",
    sizeof(struct m_func_save *),
    M_OPT_TYPE_INDIRECT,
    parse_func_pf,
    NULL,
    NULL, // Nothing to do on save
    set_func_param,
    copy_func_pf,
    free_func_pf
};

/////////////// Func

#undef VAL

static int parse_func(const m_option_t *opt, const char *name,
                      const char *param, bool ambiguous_param, void *dst)
{
    return 0;
}

static void set_func(const m_option_t *opt, void *dst, const void *src)
{
    ((m_opt_func_t) opt->p)(opt);
}

const m_option_type_t m_option_type_func = {
    "Func",
    "",
    sizeof(int),
    M_OPT_TYPE_INDIRECT,
    parse_func,
    NULL,
    NULL, // Nothing to do on save
    set_func,
    NULL,
    NULL
};

/////////////////// Print

static int parse_print(const m_option_t *opt, const char *name,
                       const char *param, bool ambiguous_param, void *dst)
{
    if (opt->type == CONF_TYPE_PRINT_INDIRECT)
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", *(char **) opt->p);
    else if (opt->type == CONF_TYPE_PRINT_FUNC)
        return ((m_opt_func_full_t) opt->p)(opt, name, param);
    else
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", mp_gtext(opt->p));

    if (opt->priv == NULL)
        return M_OPT_EXIT;
    return 0;
}

const m_option_type_t m_option_type_print = {
    "Print",
    "",
    0,
    0,
    parse_print,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

const m_option_type_t m_option_type_print_indirect = {
    "Print",
    "",
    0,
    0,
    parse_print,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

const m_option_type_t m_option_type_print_func = {
    "Print",
    "",
    0,
    M_OPT_TYPE_ALLOW_WILDCARD,
    parse_print,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/////////////////////// Subconfig
#undef VAL
#define VAL(x) (*(char ***)(x))

static int parse_subconf(const m_option_t *opt, const char *name,
                         const char *param, bool ambiguous_param, void *dst)
{
    char *subparam;
    char *subopt;
    int nr = 0, i, r;
    const m_option_t *subopts;
    const char *p;
    char **lst = NULL;

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    subparam = talloc_size(NULL, strlen(param) + 1);
    subopt = talloc_size(NULL, strlen(param) + 1);
    p = param;

    subopts = opt->p;

    while (p[0]) {
        int sscanf_ret = 1;
        int optlen = strcspn(p, ":=");
        /* clear out */
        subopt[0] = subparam[0] = 0;
        av_strlcpy(subopt, p, optlen + 1);
        p = &p[optlen];
        if (p[0] == '=') {
            sscanf_ret = 2;
            p = &p[1];
            if (p[0] == '"') {
                p = &p[1];
                optlen = strcspn(p, "\"");
                av_strlcpy(subparam, p, optlen + 1);
                p = &p[optlen];
                if (p[0] != '"') {
                    mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                           "Terminating '\"' missing for '%s'\n", subopt);
                    return M_OPT_INVALID;
                }
                p = &p[1];
            } else if (p[0] == '%') {
                p = &p[1];
                optlen = (int)strtol(p, (char **)&p, 0);
                if (!p || p[0] != '%' || (optlen > strlen(p) - 1)) {
                    mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                           "Invalid length %i for '%s'\n", optlen, subopt);
                    return M_OPT_INVALID;
                }
                p = &p[1];
                av_strlcpy(subparam, p, optlen + 1);
                p = &p[optlen];
            } else {
                optlen = strcspn(p, ":");
                av_strlcpy(subparam, p, optlen + 1);
                p = &p[optlen];
            }
        }
        if (p[0] == ':')
            p = &p[1];
        else if (p[0]) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Incorrect termination for '%s'\n", subopt);
            return M_OPT_INVALID;
        }

        switch (sscanf_ret) {
        case 1:
            subparam[0] = 0;
        case 2:
            for (i = 0; subopts[i].name; i++)
                if (!strcmp(subopts[i].name, subopt))
                    break;
            if (!subopts[i].name) {
                mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                       "Option %s: Unknown suboption %s\n", name, subopt);
                return M_OPT_UNKNOWN;
            }
            r = m_option_parse(&subopts[i], subopt,
                               subparam[0] == 0 ? NULL : subparam, false,
                               NULL);
            if (r < 0)
                return r;
            if (dst) {
                lst = talloc_realloc(NULL, lst, char *, 2 * (nr + 2));
                lst[2 * nr] = talloc_strdup(NULL, subopt);
                lst[2 * nr + 1] = subparam[0] == 0 ? NULL :
                    talloc_strdup(NULL, subparam);
                memset(&lst[2 * (nr + 1)], 0, 2 * sizeof(char *));
                nr++;
            }
            break;
        }
    }

    talloc_free(subparam);
    talloc_free(subopt);
    if (dst)
        VAL(dst) = lst;

    return 1;
}

const m_option_type_t m_option_type_subconfig = {
    "Subconfig",
    "The syntax is -option opt1=foo:flag:opt2=blah",
    sizeof(int),
    M_OPT_TYPE_HAS_CHILD,
    parse_subconf,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

#include "libmpcodecs/img_format.h"

/* FIXME: snyc with img_format.h */
static struct {
    const char *name;
    unsigned int fmt;
} mp_imgfmt_list[] = {
    {"444p16le", IMGFMT_444P16_LE},
    {"444p16be", IMGFMT_444P16_BE},
    {"444p10le", IMGFMT_444P10_LE},
    {"444p10be", IMGFMT_444P10_BE},
    {"444p9le", IMGFMT_444P9_LE},
    {"444p9be", IMGFMT_444P9_BE},
    {"422p16le", IMGFMT_422P16_LE},
    {"422p16be", IMGFMT_422P16_BE},
    {"422p10le", IMGFMT_422P10_LE},
    {"422p10be", IMGFMT_422P10_BE},
    {"420p16le", IMGFMT_420P16_LE},
    {"420p16be", IMGFMT_420P16_BE},
    {"420p10le", IMGFMT_420P10_LE},
    {"420p10be", IMGFMT_420P10_BE},
    {"420p9le", IMGFMT_420P9_LE},
    {"420p9be", IMGFMT_420P9_BE},
    {"444p16", IMGFMT_444P16},
    {"444p10", IMGFMT_444P10},
    {"444p9", IMGFMT_444P9},
    {"422p16", IMGFMT_422P16},
    {"422p10", IMGFMT_422P10},
    {"420p10", IMGFMT_420P10},
    {"420p9", IMGFMT_420P9},
    {"420p16", IMGFMT_420P16},
    {"420a", IMGFMT_420A},
    {"444p", IMGFMT_444P},
    {"422p", IMGFMT_422P},
    {"411p", IMGFMT_411P},
    {"440p", IMGFMT_440P},
    {"yuy2", IMGFMT_YUY2},
    {"yvyu", IMGFMT_YVYU},
    {"uyvy", IMGFMT_UYVY},
    {"yvu9", IMGFMT_YVU9},
    {"if09", IMGFMT_IF09},
    {"yv12", IMGFMT_YV12},
    {"i420", IMGFMT_I420},
    {"iyuv", IMGFMT_IYUV},
    {"clpl", IMGFMT_CLPL},
    {"hm12", IMGFMT_HM12},
    {"y800", IMGFMT_Y800},
    {"y8", IMGFMT_Y8},
    {"nv12", IMGFMT_NV12},
    {"nv21", IMGFMT_NV21},
    {"bgr24", IMGFMT_BGR24},
    {"bgr32", IMGFMT_BGR32},
    {"bgr16", IMGFMT_BGR16},
    {"bgr15", IMGFMT_BGR15},
    {"bgr12", IMGFMT_BGR12},
    {"bgr8", IMGFMT_BGR8},
    {"bgr4", IMGFMT_BGR4},
    {"bg4b", IMGFMT_BG4B},
    {"bgr1", IMGFMT_BGR1},
    {"rgb48be", IMGFMT_RGB48BE},
    {"rgb48le", IMGFMT_RGB48LE},
    {"rgb48ne", IMGFMT_RGB48NE},
    {"rgb24", IMGFMT_RGB24},
    {"rgb32", IMGFMT_RGB32},
    {"rgb16", IMGFMT_RGB16},
    {"rgb15", IMGFMT_RGB15},
    {"rgb12", IMGFMT_RGB12},
    {"rgb8", IMGFMT_RGB8},
    {"rgb4", IMGFMT_RGB4},
    {"rg4b", IMGFMT_RG4B},
    {"rgb1", IMGFMT_RGB1},
    {"rgba", IMGFMT_RGBA},
    {"argb", IMGFMT_ARGB},
    {"bgra", IMGFMT_BGRA},
    {"abgr", IMGFMT_ABGR},
    {"mjpeg", IMGFMT_MJPEG},
    {"mjpg", IMGFMT_MJPEG},
    { NULL, 0 }
};

static int parse_imgfmt(const m_option_t *opt, const char *name,
                        const char *param, bool ambiguous_param, void *dst)
{
    uint32_t fmt = 0;
    int i;

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    if (!strcmp(param, "help")) {
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
        for (i = 0; mp_imgfmt_list[i].name; i++)
            mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s", mp_imgfmt_list[i].name);
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
        return M_OPT_EXIT - 1;
    }

    if (sscanf(param, "0x%x", &fmt) != 1) {
        for (i = 0; mp_imgfmt_list[i].name; i++) {
            if (!strcasecmp(param, mp_imgfmt_list[i].name)) {
                fmt = mp_imgfmt_list[i].fmt;
                break;
            }
        }
        if (!mp_imgfmt_list[i].name) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Option %s: unknown format name: '%s'\n", name, param);
            return M_OPT_INVALID;
        }
    }

    if (dst)
        *((uint32_t *)dst) = fmt;

    return 1;
}

const m_option_type_t m_option_type_imgfmt = {
    "Image format",
    "Please report any missing colorspaces.",
    sizeof(uint32_t),
    0,
    parse_imgfmt,
    NULL,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};

#include "libaf/af_format.h"

/* FIXME: snyc with af_format.h */
static struct {
    const char *name;
    unsigned int fmt;
} mp_afmt_list[] = {
    // SPECIAL
    {"mulaw", AF_FORMAT_MU_LAW},
    {"alaw", AF_FORMAT_A_LAW},
    {"mpeg2", AF_FORMAT_MPEG2},
    {"ac3le", AF_FORMAT_AC3_LE},
    {"ac3be", AF_FORMAT_AC3_BE},
    {"ac3ne", AF_FORMAT_AC3_NE},
    {"imaadpcm", AF_FORMAT_IMA_ADPCM},
    // ORDINARY
    {"u8", AF_FORMAT_U8},
    {"s8", AF_FORMAT_S8},
    {"u16le", AF_FORMAT_U16_LE},
    {"u16be", AF_FORMAT_U16_BE},
    {"u16ne", AF_FORMAT_U16_NE},
    {"s16le", AF_FORMAT_S16_LE},
    {"s16be", AF_FORMAT_S16_BE},
    {"s16ne", AF_FORMAT_S16_NE},
    {"u24le", AF_FORMAT_U24_LE},
    {"u24be", AF_FORMAT_U24_BE},
    {"u24ne", AF_FORMAT_U24_NE},
    {"s24le", AF_FORMAT_S24_LE},
    {"s24be", AF_FORMAT_S24_BE},
    {"s24ne", AF_FORMAT_S24_NE},
    {"u32le", AF_FORMAT_U32_LE},
    {"u32be", AF_FORMAT_U32_BE},
    {"u32ne", AF_FORMAT_U32_NE},
    {"s32le", AF_FORMAT_S32_LE},
    {"s32be", AF_FORMAT_S32_BE},
    {"s32ne", AF_FORMAT_S32_NE},
    {"floatle", AF_FORMAT_FLOAT_LE},
    {"floatbe", AF_FORMAT_FLOAT_BE},
    {"floatne", AF_FORMAT_FLOAT_NE},
    { NULL, 0 }
};

static int parse_afmt(const m_option_t *opt, const char *name,
                      const char *param, bool ambiguous_param, void *dst)
{
    uint32_t fmt = 0;
    int i;

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    if (!strcmp(param, "help")) {
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
        for (i = 0; mp_afmt_list[i].name; i++)
            mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s", mp_afmt_list[i].name);
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
        return M_OPT_EXIT - 1;
    }

    if (sscanf(param, "0x%x", &fmt) != 1) {
        for (i = 0; mp_afmt_list[i].name; i++) {
            if (!strcasecmp(param, mp_afmt_list[i].name)) {
                fmt = mp_afmt_list[i].fmt;
                break;
            }
        }
        if (!mp_afmt_list[i].name) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Option %s: unknown format name: '%s'\n", name, param);
            return M_OPT_INVALID;
        }
    }

    if (dst)
        *((uint32_t *)dst) = fmt;

    return 1;
}

const m_option_type_t m_option_type_afmt = {
    "Audio format",
    "Please report any missing formats.",
    sizeof(uint32_t),
    0,
    parse_afmt,
    NULL,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};


int parse_timestring(const char *str, double *time, char endchar)
{
    int a, b, len;
    double d;
    *time = 0; /* ensure initialization for error cases */
    if (sscanf(str, "%d:%d:%lf%n", &a, &b, &d, &len) >= 3)
        *time = 3600 * a + 60 * b + d;
    else if (sscanf(str, "%d:%lf%n", &a, &d, &len) >= 2)
        *time = 60 * a + d;
    else if (sscanf(str, "%lf%n", &d, &len) >= 1)
        *time = d;
    else
        return 0;  /* unsupported time format */
    if (str[len] && str[len] != endchar)
        return 0;  /* invalid extra characters at the end */
    return len;
}


static int parse_time(const m_option_t *opt, const char *name,
                      const char *param, bool ambiguous_param, void *dst)
{
    double time;

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    if (!parse_timestring(param, &time, 0)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: invalid time: '%s'\n",
               name, param);
        return M_OPT_INVALID;
    }

    if (dst)
        *(double *)dst = time;
    return 1;
}

const m_option_type_t m_option_type_time = {
    "Time",
    "",
    sizeof(double),
    0,
    parse_time,
    print_double,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};


// Time or size (-endpos)

static int parse_time_size(const m_option_t *opt, const char *name,
                           const char *param, bool ambiguous_param, void *dst)
{
    m_time_size_t ts;
    char unit[4];
    double end_at;

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    ts.pos = 0;
    /* End at size parsing */
    if (sscanf(param, "%lf%3s", &end_at, unit) == 2) {
        ts.type = END_AT_SIZE;
        if (!strcasecmp(unit, "b"))
            ;
        else if (!strcasecmp(unit, "kb"))
            end_at *= 1024;
        else if (!strcasecmp(unit, "mb"))
            end_at *= 1024 * 1024;
        else if (!strcasecmp(unit, "gb"))
            end_at *= 1024 * 1024 * 1024;
        else
            ts.type = END_AT_NONE;

        if (ts.type == END_AT_SIZE) {
            ts.pos  = end_at;
            goto out;
        }
    }

    /* End at time parsing. This has to be last because the parsing accepts
     * even a number followed by garbage */
    if (!parse_timestring(param, &end_at, 0)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "Option %s: invalid time or size: '%s'\n",
               name, param);
        return M_OPT_INVALID;
    }

    ts.type = END_AT_TIME;
    ts.pos  = end_at;
out:
    if (dst)
        *(m_time_size_t *)dst = ts;
    return 1;
}

const m_option_type_t m_option_type_time_size = {
    "Time or size",
    "",
    sizeof(m_time_size_t),
    0,
    parse_time_size,
    NULL,
    copy_opt,
    copy_opt,
    NULL,
    NULL
};


//// Objects (i.e. filters, etc) settings

#include "m_struct.h"

#undef VAL
#define VAL(x) (*(m_obj_settings_t **)(x))

static int find_obj_desc(const char *name, const m_obj_list_t *l,
                         const m_struct_t **ret)
{
    int i;
    char *n;

    for (i = 0; l->list[i]; i++) {
        n = M_ST_MB(char *, l->list[i], l->name_off);
        if (!strcmp(n, name)) {
            *ret = M_ST_MB(m_struct_t *, l->list[i], l->desc_off);
            return 1;
        }
    }
    return 0;
}

static int get_obj_param(const char *opt_name, const char *obj_name,
                         const m_struct_t *desc, char *str, int *nold,
                         int oldmax, char **dst)
{
    char *eq;
    const m_option_t *opt;
    int r;

    eq = strchr(str, '=');
    if (eq && eq == str)
        eq = NULL;

    if (eq) {
        char *p = eq + 1;
        if (p[0] == '\0')
            p = NULL;
        eq[0] = '\0';
        opt = m_option_list_find(desc->fields, str);
        if (!opt) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Option %s: %s doesn't have a %s parameter.\n",
                   opt_name, obj_name, str);
            return M_OPT_UNKNOWN;
        }
        r = m_option_parse(opt, str, p, false, NULL);
        if (r < 0) {
            if (r > M_OPT_EXIT)
                mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                       "Option %s: Error while parsing %s parameter %s (%s)\n",
                       opt_name, obj_name, str, p);
            eq[0] = '=';
            return r;
        }
        if (dst) {
            dst[0] = talloc_strdup(NULL, str);
            dst[1] = talloc_strdup(NULL, p);
        }
        eq[0] = '=';
    } else {
        if ((*nold) >= oldmax) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
                   opt_name, obj_name, oldmax, oldmax);
            return M_OPT_OUT_OF_RANGE;
        }
        opt = &desc->fields[(*nold)];
        r = m_option_parse(opt, opt->name, str, false, NULL);
        if (r < 0) {
            if (r > M_OPT_EXIT)
                mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                       "Option %s: Error while parsing %s parameter %s (%s)\n",
                       opt_name, obj_name, opt->name, str);
            return r;
        }
        if (dst) {
            dst[0] = talloc_strdup(NULL, opt->name);
            dst[1] = talloc_strdup(NULL, str);
        }
        (*nold)++;
    }
    return 1;
}

static int get_obj_params(const char *opt_name, const char *name, char *params,
                          const m_struct_t *desc, char separator, char ***_ret)
{
    int n = 0, nold = 0, nopts, r;
    char *ptr, *last_ptr = params;
    char **ret;

    if (!strcmp(params, "help")) { // Help
        char min[50], max[50];
        if (!desc->fields) {
            printf("%s doesn't have any options.\n\n", name);
            return M_OPT_EXIT - 1;
        }
        printf("\n Name                 Type            Min        Max\n\n");
        for (n = 0; desc->fields[n].name; n++) {
            const m_option_t *opt = &desc->fields[n];
            if (opt->type->flags & M_OPT_TYPE_HAS_CHILD)
                continue;
            if (opt->flags & M_OPT_MIN)
                sprintf(min, "%-8.0f", opt->min);
            else
                strcpy(min, "No");
            if (opt->flags & M_OPT_MAX)
                sprintf(max, "%-8.0f", opt->max);
            else
                strcpy(max, "No");
            printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
                   opt->name,
                   opt->type->name,
                   min,
                   max);
        }
        printf("\n");
        return M_OPT_EXIT - 1;
    }

    for (nopts = 0; desc->fields[nopts].name; nopts++)
        /* NOP */;

    // TODO : Check that each opt can be parsed
    r = 1;
    while (last_ptr && last_ptr[0] != '\0') {
        ptr = strchr(last_ptr, separator);
        if (!ptr) {
            r = get_obj_param(opt_name, name, desc, last_ptr, &nold, nopts,
                              NULL);
            n++;
            break;
        }
        if (ptr == last_ptr) { // Empty field, count it and go on
            nold++;
            last_ptr = ptr + 1;
            continue;
        }
        ptr[0] = '\0';
        r = get_obj_param(opt_name, name, desc, last_ptr, &nold, nopts, NULL);
        ptr[0] = separator;
        if (r < 0)
            break;
        n++;
        last_ptr = ptr + 1;
    }
    if (r < 0)
        return r;
    if (!last_ptr[0]) // count an empty field at the end, too
        nold++;
    if (nold > nopts) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Too many options for %s\n", name);
        return M_OPT_OUT_OF_RANGE;
    }
    if (!_ret) // Just test
        return 1;
    if (n == 0) // No options or only empty options
        return 1;

    ret = talloc_array(NULL, char *, (n + 2) * 2);
    n = nold = 0;
    last_ptr = params;

    while (last_ptr && last_ptr[0] != '\0') {
        ptr = strchr(last_ptr, separator);
        if (!ptr) {
            get_obj_param(opt_name, name, desc, last_ptr, &nold, nopts,
                          &ret[n * 2]);
            n++;
            break;
        }
        if (ptr == last_ptr) { // Empty field, count it and go on
            last_ptr = ptr + 1;
            nold++;
            continue;
        }
        ptr[0] = '\0';
        get_obj_param(opt_name, name, desc, last_ptr, &nold, nopts,
                      &ret[n * 2]);
        n++;
        last_ptr = ptr + 1;
    }
    ret[n * 2] = ret[n * 2 + 1] = NULL;
    *_ret = ret;

    return 1;
}

static int parse_obj_params(const m_option_t *opt, const char *name,
                            const char *param, bool ambiguous_param, void *dst)
{
    char **opts;
    int r;
    m_obj_params_t *p = opt->priv;
    const m_struct_t *desc;
    char *cpy;

    // We need the object desc
    if (!p)
        return M_OPT_INVALID;

    desc = p->desc;
    cpy = talloc_strdup(NULL, param);
    r = get_obj_params(name, desc->name, cpy, desc, p->separator,
                       dst ? &opts : NULL);
    talloc_free(cpy);
    if (r < 0)
        return r;
    if (!dst)
        return 1;
    if (!opts) // no arguments given
        return 1;

    for (r = 0; opts[r]; r += 2)
        m_struct_set(desc, dst, opts[r], opts[r + 1]);

    return 1;
}


const m_option_type_t m_option_type_obj_params = {
    "Object params",
    "",
    0,
    0,
    parse_obj_params,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

/// Some predefined types as a definition would be quite lengthy

/// Span arguments
static const m_span_t m_span_params_dflts = {
    -1, -1
};
static const m_option_t m_span_params_fields[] = {
    {"start", M_ST_OFF(m_span_t, start), CONF_TYPE_INT, M_OPT_MIN, 1, 0, NULL},
    {"end", M_ST_OFF(m_span_t, end), CONF_TYPE_INT, M_OPT_MIN, 1, 0, NULL},
    { NULL, NULL, 0, 0, 0, 0, NULL }
};
static const struct m_struct_st m_span_opts = {
    "m_span",
    sizeof(m_span_t),
    &m_span_params_dflts,
    m_span_params_fields
};
const m_obj_params_t m_span_params_def = {
    &m_span_opts,
    '-'
};

static int parse_obj_settings(const char *opt, char *str,
                              const m_obj_list_t *list,
                              m_obj_settings_t **_ret, int ret_n)
{
    int r;
    char *param, **plist = NULL;
    const m_struct_t *desc;
    m_obj_settings_t *ret = _ret ? *_ret : NULL;


    // Now check that the object exists
    param = strchr(str, '=');
    if (param) {
        param[0] = '\0';
        param++;
        if (strlen(param) <= 0)
            param = NULL;
    }


    if (!find_obj_desc(str, list, &desc)) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't exist.\n",
               opt, str);
        return M_OPT_INVALID;
    }

    if (param) {
        if (!desc && _ret) {
            if (!strcmp(param, "help")) {
                mp_msg(MSGT_CFGPARSER, MSGL_INFO,
                       "Option %s: %s have no option description.\n", opt, str);
                return M_OPT_EXIT - 1;
            }
            plist = talloc_zero_array(NULL, char *, 4);
            plist[0] = talloc_strdup(NULL, "_oldargs_");
            plist[1] = talloc_strdup(NULL, param);
        } else if (desc) {
            r = get_obj_params(opt, str, param, desc, ':',
                               _ret ? &plist : NULL);
            if (r < 0)
                return r;
        }
    }
    if (!_ret)
        return 1;

    ret = talloc_realloc(NULL, ret, struct m_obj_settings, ret_n + 2);
    memset(&ret[ret_n], 0, 2 * sizeof(m_obj_settings_t));
    ret[ret_n].name = talloc_strdup(NULL, str);
    ret[ret_n].attribs = plist;

    *_ret = ret;
    return 1;
}

static int obj_settings_list_del(const char *opt_name, const char *param,
                                 bool ambiguous_param, void *dst)
{
    char **str_list = NULL;
    int r, i, idx_max = 0;
    char *rem_id = "_removed_marker_";
    const m_option_t list_opt = {
        opt_name, NULL, CONF_TYPE_STRING_LIST,
        0, 0, 0, NULL
    };
    m_obj_settings_t *obj_list = dst ? VAL(dst) : NULL;

    if (dst && !obj_list) {
        mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: the list is empty.\n",
               opt_name);
        return 1;
    } else if (obj_list) {
        for (idx_max = 0; obj_list[idx_max].name != NULL; idx_max++)
            /* NOP */;
    }

    r = m_option_parse(&list_opt, opt_name, param, false, &str_list);
    if (r < 0 || !str_list)
        return r;

    for (r = 0; str_list[r]; r++) {
        int id;
        char *endptr;
        id = strtol(str_list[r], &endptr, 0);
        if (endptr == str_list[r]) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: invalid parameter. We need a list of integers which are the indices of the elements to remove.\n", opt_name);
            m_option_free(&list_opt, &str_list);
            return M_OPT_INVALID;
        }
        if (!obj_list)
            continue;
        if (id >= idx_max || id < -idx_max) {
            mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                   "Option %s: Index %d is out of range.\n", opt_name, id);
            continue;
        }
        if (id < 0)
            id = idx_max + id;
        talloc_free(obj_list[id].name);
        free_str_list(&(obj_list[id].attribs));
        obj_list[id].name = rem_id;
    }

    if (!dst) {
        m_option_free(&list_opt, &str_list);
        return 1;
    }

    for (i = 0; obj_list[i].name; i++) {
        while (obj_list[i].name == rem_id) {
            memmove(&obj_list[i], &obj_list[i + 1],
                    sizeof(m_obj_settings_t) * (idx_max - i));
            idx_max--;
        }
    }
    obj_list = talloc_realloc(NULL, obj_list, struct m_obj_settings,
                              idx_max + 1);
    VAL(dst) = obj_list;

    return 1;
}

static void free_obj_settings_list(void *dst)
{
    int n;
    m_obj_settings_t *d;

    if (!dst || !VAL(dst))
        return;

    d = VAL(dst);
    for (n = 0; d[n].name; n++) {
        talloc_free(d[n].name);
        free_str_list(&(d[n].attribs));
    }
    talloc_free(d);
    VAL(dst) = NULL;
}

static int parse_obj_settings_list(const m_option_t *opt, const char *name,
                                   const char *param, bool ambiguous_param,
                                   void *dst)
{
    int n = 0, r, len = strlen(opt->name);
    char *str;
    char *ptr, *last_ptr;
    m_obj_settings_t *res = NULL, *queue = NULL, *head = NULL;
    int op = OP_NONE;

    // We need the objects list
    if (!opt->priv)
        return M_OPT_INVALID;

    if (opt->name[len - 1] == '*' && ((int)strlen(name) > len - 1)) {
        const char *n = &name[len - 1];
        if (strcasecmp(n, "-add") == 0)
            op = OP_ADD;
        else if (strcasecmp(n, "-pre") == 0)
            op = OP_PRE;
        else if (strcasecmp(n, "-del") == 0)
            op = OP_DEL;
        else if (strcasecmp(n, "-clr") == 0)
            op = OP_CLR;
        else {
            char prefix[len];
            strncpy(prefix, opt->name, len - 1);
            prefix[len - 1] = '\0';
            mp_msg(MSGT_VFILTER, MSGL_ERR, "Option %s: unknown postfix %s\n"
                   "Supported postfixes are:\n"
                   "  %s-add\n"
                   " Append the given list to the current list\n\n"
                   "  %s-pre\n"
                   " Prepend the given list to the current list\n\n"
                   "  %s-del x,y,...\n"
                   " Remove the given elements. Take the list element index (starting from 0).\n"
                   " Negative index can be used (i.e. -1 is the last element)\n\n"
                   "  %s-clr\n"
                   " Clear the current list.\n",
                   name, n, prefix, prefix, prefix, prefix);

            return M_OPT_UNKNOWN;
        }
    }

    // Clear the list ??
    if (op == OP_CLR) {
        if (dst)
            free_obj_settings_list(dst);
        return 0;
    }

    if (param == NULL || strlen(param) == 0)
        return M_OPT_MISSING_PARAM;

    switch (op) {
    case OP_ADD:
        if (dst)
            head = VAL(dst);
        break;
    case OP_PRE:
        if (dst)
            queue = VAL(dst);
        break;
    case OP_DEL:
        return obj_settings_list_del(name, param, false, dst);
    case OP_NONE:
        if (dst && VAL(dst))
            free_obj_settings_list(dst);
        break;
    default:
        mp_msg(MSGT_VFILTER, MSGL_ERR, "Option %s: FIXME\n", name);
        return M_OPT_UNKNOWN;
    }

    if (!strcmp(param, "help")) {
        m_obj_list_t *ol = opt->priv;
        mp_msg(MSGT_VFILTER, MSGL_INFO, "Available video filters:\n");
        mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_FILTERS\n");
        for (n = 0; ol->list[n]; n++)
            mp_msg(MSGT_VFILTER, MSGL_INFO, "  %-15s: %s\n",
                   M_ST_MB(char *, ol->list[n], ol->name_off),
                   M_ST_MB(char *, ol->list[n], ol->info_off));
        mp_msg(MSGT_VFILTER, MSGL_INFO, "\n");
        return M_OPT_EXIT - 1;
    }
    ptr = str = talloc_strdup(NULL, param);

    while (ptr[0] != '\0') {
        last_ptr = ptr;
        ptr = get_nextsep(ptr, OPTION_LIST_SEPARATOR, 1);

        if (!ptr) {
            r = parse_obj_settings(name, last_ptr, opt->priv,
                                   dst ? &res : NULL, n);
            if (r < 0) {
                talloc_free(str);
                return r;
            }
            n++;
            break;
        }
        ptr[0] = '\0';
        r = parse_obj_settings(name, last_ptr, opt->priv, dst ? &res : NULL, n);
        if (r < 0) {
            talloc_free(str);
            return r;
        }
        ptr++;
        n++;
    }
    talloc_free(str);
    if (n == 0)
        return M_OPT_INVALID;

    if (((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
        ((opt->flags & M_OPT_MAX) && (n > opt->max)))
        return M_OPT_OUT_OF_RANGE;

    if (dst) {
        if (queue) {
            int qsize;
            for (qsize = 0; queue[qsize].name; qsize++)
                /* NOP */;
            res = talloc_realloc(NULL, res, struct m_obj_settings,
                                 qsize + n + 1);
            memcpy(&res[n], queue, (qsize + 1) * sizeof(m_obj_settings_t));
            n += qsize;
            talloc_free(queue);
        }
        if (head) {
            int hsize;
            for (hsize = 0; head[hsize].name; hsize++)
                /* NOP */;
            head = talloc_realloc(NULL, head, struct m_obj_settings,
                                  hsize + n + 1);
            memcpy(&head[hsize], res, (n + 1) * sizeof(m_obj_settings_t));
            talloc_free(res);
            res = head;
        }
        VAL(dst) = res;
    }
    return 1;
}

static void copy_obj_settings_list(const m_option_t *opt, void *dst,
                                   const void *src)
{
    m_obj_settings_t *d, *s;
    int n;

    if (!(dst && src))
        return;

    s = VAL(src);

    if (VAL(dst))
        free_obj_settings_list(dst);
    if (!s)
        return;



    for (n = 0; s[n].name; n++)
        /* NOP */;
    d = talloc_array(NULL, struct m_obj_settings, n + 1);
    for (n = 0; s[n].name; n++) {
        d[n].name = talloc_strdup(NULL, s[n].name);
        d[n].attribs = NULL;
        copy_str_list(NULL, &(d[n].attribs), &(s[n].attribs));
    }
    d[n].name = NULL;
    d[n].attribs = NULL;
    VAL(dst) = d;
}

const m_option_type_t m_option_type_obj_settings_list = {
    "Object settings list",
    "",
    sizeof(m_obj_settings_t *),
    M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
    parse_obj_settings_list,
    NULL,
    copy_obj_settings_list,
    copy_obj_settings_list,
    copy_obj_settings_list,
    free_obj_settings_list,
};



static int parse_obj_presets(const m_option_t *opt, const char *name,
                             const char *param, bool ambiguous_param,
                             void *dst)
{
    m_obj_presets_t *obj_p = (m_obj_presets_t *)opt->priv;
    const m_struct_t *in_desc;
    const m_struct_t *out_desc;
    int s, i;
    const unsigned char *pre;
    char *pre_name = NULL;

    if (!obj_p) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Presets need a "
               "pointer to a m_obj_presets_t in the priv field.\n", name);
        return M_OPT_PARSER_ERR;
    }

    if (!param)
        return M_OPT_MISSING_PARAM;

    pre = obj_p->presets;
    in_desc = obj_p->in_desc;
    out_desc = obj_p->out_desc ? obj_p->out_desc : obj_p->in_desc;
    s = in_desc->size;

    if (!strcmp(param, "help")) {
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available presets for %s->%s:",
               out_desc->name, name);
        for (pre = obj_p->presets;
             (pre_name = M_ST_MB(char *, pre, obj_p->name_off)); pre +=  s)
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s", pre_name);
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
        return M_OPT_EXIT - 1;
    }

    for (pre_name = M_ST_MB(char *, pre, obj_p->name_off); pre_name;
         pre +=  s, pre_name = M_ST_MB(char *, pre, obj_p->name_off))
        if (!strcmp(pre_name, param))
            break;
    if (!pre_name) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "Option %s: There is no preset named %s\n"
               "Available presets are:", name, param);
        for (pre = obj_p->presets;
             (pre_name = M_ST_MB(char *, pre, obj_p->name_off)); pre +=  s)
            mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s", pre_name);
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
        return M_OPT_INVALID;
    }

    if (!dst)
        return 1;

    for (i = 0; in_desc->fields[i].name; i++) {
        const m_option_t *out_opt = m_option_list_find(out_desc->fields,
                                                       in_desc->fields[i].name);
        if (!out_opt) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Option %s: Unable to find the target option for field %s.\n"
                   "Please report this to the developers.\n",
                   name, in_desc->fields[i].name);
            return M_OPT_PARSER_ERR;
        }
        m_option_copy(out_opt, M_ST_MB_P(dst, out_opt->p),
                      M_ST_MB_P(pre, in_desc->fields[i].p));
    }
    return 1;
}


const m_option_type_t m_option_type_obj_presets = {
    "Object presets",
    "",
    0,
    0,
    parse_obj_presets,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

static int parse_custom_url(const m_option_t *opt, const char *name,
                            const char *url, bool ambiguous_param, void *dst)
{
    int pos1, pos2, r, v6addr = 0;
    char *ptr1 = NULL, *ptr2 = NULL, *ptr3 = NULL, *ptr4 = NULL;
    m_struct_t *desc = opt->priv;

    if (!desc) {
        mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Custom URL needs "
               "a pointer to a m_struct_t in the priv field.\n", name);
        return M_OPT_PARSER_ERR;
    }

    // extract the protocol
    ptr1 = strstr(url, "://");
    if (ptr1 == NULL) {
        // Filename only
        if (m_option_list_find(desc->fields, "filename")) {
            m_struct_set(desc, dst, "filename", url);
            return 1;
        }
        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
               "Option %s: URL doesn't have a valid protocol!\n", name);
        return M_OPT_INVALID;
    }
    if (m_option_list_find(desc->fields, "string")) {
        if (strlen(ptr1) > 3) {
            m_struct_set(desc, dst, "string", ptr1 + 3);
            return 1;
        }
    }
    pos1 = ptr1 - url;
    if (dst && m_option_list_find(desc->fields, "protocol")) {
        ptr1[0] = '\0';
        r = m_struct_set(desc, dst, "protocol", url);
        ptr1[0] = ':';
        if (r < 0) {
            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                   "Option %s: Error while setting protocol.\n", name);
            return r;
        }
    }

    // jump the "://"
    ptr1 += 3;
    pos1 += 3;

    // check if a username:password is given
    ptr2 = strstr(ptr1, "@");
    ptr3 = strstr(ptr1, "/");
    if (ptr3 != NULL && ptr3 < ptr2) {
        // it isn't really a username but rather a part of the path
        ptr2 = NULL;
    }
    if (ptr2 != NULL) {

        // We got something, at least a username...
        if (!m_option_list_find(desc->fields, "username")) {
            mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                   "Option %s: This URL doesn't have a username part.\n", name);
            // skip
        } else {
            ptr3 = strstr(ptr1, ":");
            if (ptr3 != NULL && ptr3 < ptr2) {
                // We also have a password
                if (!m_option_list_find(desc->fields, "password")) {
                    mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                         "Option %s: This URL doesn't have a password part.\n",
                           name);
                    // skip
                } else { // Username and password
                    if (dst) {
                        ptr3[0] = '\0';
                        r = m_struct_set(desc, dst, "username", ptr1);
                        ptr3[0] = ':';
                        if (r < 0) {
                            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                                   "Option %s: Error while setting username.\n",
                                   name);
                            return r;
                        }
                        ptr2[0] = '\0';
                        r = m_struct_set(desc, dst, "password", ptr3 + 1);
                        ptr2[0] = '@';
                        if (r < 0) {
                            mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                                   "Option %s: Error while setting password.\n",
                                   name);
                            return r;
                        }
                    }
                }
            } else { // User name only
                ptr2[0] = '\0';
                r = m_struct_set(desc, dst, "username", ptr1);
                ptr2[0] = '@';
                if (r < 0) {
                    mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                           "Option %s: Error while setting username.\n", name);
                    return r;
                }
            }
        }
        ptr1 = ptr2 + 1;
        pos1 = ptr1 - url;
    }

    // Before looking for a port number check if we have an IPv6 type
    // numeric address.
    // In an IPv6 URL the numeric address should be inside square braces.
    ptr2 = strstr(ptr1, "[");
    ptr3 = strstr(ptr1, "]");
    // If the [] is after the first it isn't the hostname
    ptr4 = strstr(ptr1, "/");
    if (ptr2 != NULL && ptr3 != NULL && (ptr2 < ptr3)
        && (!ptr4 || ptr4 > ptr3)) {
        // we have an IPv6 numeric address
        ptr1++;
        pos1++;
        ptr2 = ptr3;
        v6addr = 1;
    } else
        ptr2 = ptr1;

    // look if the port is given
    ptr2 = strstr(ptr2, ":");
    // If the : is after the first / it isn't the port
    ptr3 = strstr(ptr1, "/");
    if (ptr3 && ptr3 - ptr2 < 0)
        ptr2 = NULL;
    if (ptr2 == NULL) {
        // No port is given
        // Look if a path is given
        if (ptr3 == NULL) {
            // No path/filename
            // So we have an URL like http://www.hostname.com
            pos2 = strlen(url);
        } else {
            // We have an URL like http://www.hostname.com/file.txt
            pos2 = ptr3 - url;
        }
    } else {
        // We have an URL beginning like http://www.hostname.com:1212
        // Get the port number
        if (!m_option_list_find(desc->fields, "port")) {
            mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                   "Option %s: This URL doesn't have a port part.\n", name);
            // skip
        } else {
            if (dst) {
                int p = atoi(ptr2 + 1);
                char tmp[100];
                snprintf(tmp, 99, "%d", p);
                r = m_struct_set(desc, dst, "port", tmp);
                if (r < 0) {
                    mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                           "Option %s: Error while setting port.\n", name);
                    return r;
                }
            }
        }
        pos2 = ptr2 - url;
    }
    if (v6addr)
        pos2--;
    // Get the hostname
    if (pos2 - pos1 > 0) {
        if (!m_option_list_find(desc->fields, "hostname")) {
            mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                   "Option %s: This URL doesn't have a hostname part.\n", name);
            // skip
        } else {
            char tmp[pos2 - pos1 + 1];
            strncpy(tmp, ptr1, pos2 - pos1);
            tmp[pos2 - pos1] = '\0';
            r = m_struct_set(desc, dst, "hostname", tmp);
            if (r < 0) {
                mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                       "Option %s: Error while setting hostname.\n", name);
                return r;
            }
        }
    }
    // Look if a path is given
    ptr2 = strstr(ptr1, "/");
    if (ptr2 != NULL) {
        // A path/filename is given
        // check if it's not a trailing '/'
        if (strlen(ptr2) > 1) {
            // copy the path/filename in the URL container
            if (!m_option_list_find(desc->fields, "filename")) {
                mp_msg(MSGT_CFGPARSER, MSGL_WARN,
                       "Option %s: This URL doesn't have a hostname part.\n",
                       name);
                // skip
            } else {
                if (dst) {
                    int l = strlen(ptr2 + 1) + 1;
                    char *fname = ptr2 + 1;
                    if (l > 1) {
                        fname = talloc_size(NULL, l);
                        url_unescape_string(fname, ptr2 + 1);
                    }
                    r = m_struct_set(desc, dst, "filename", fname);
                    if (fname != ptr2 + 1)
                        talloc_free(fname);
                    if (r < 0) {
                        mp_msg(MSGT_CFGPARSER, MSGL_ERR,
                               "Option %s: Error while setting filename.\n",
                               name);
                        return r;
                    }
                }
            }
        }
    }
    return 1;
}

/// TODO : Write the other needed funcs for 'normal' options
const m_option_type_t m_option_type_custom_url = {
    "Custom URL",
    "",
    0,
    0,
    parse_custom_url,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};