Adding upstream version 0.37.0.upstream/0.37.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

17 files changed, 10423 insertions, 0 deletions

diff --git a/options/m_config.h b/options/m_config.h
new file mode 100644
index 0000000..d2ce2b4
--- /dev/null
+++ b/options/m_config.h
@@ -0,0 +1 @@
+#include "m_config_core.h"
\ No newline at end of file
diff --git a/options/m_config_core.c b/options/m_config_core.c
new file mode 100644
index 0000000..08a76eb
--- /dev/null
+++ b/options/m_config_core.c
@@ -0,0 +1,876 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#include "common/common.h"
+#include "common/global.h"
+#include "common/msg_control.h"
+#include "common/msg.h"
+#include "m_config_core.h"
+#include "misc/dispatch.h"
+#include "options/m_option.h"
+#include "osdep/threads.h"
+
+// For use with m_config_cache.
+struct m_config_shadow {
+    mp_mutex lock;
+    // Incremented on every option change.
+    _Atomic uint64_t ts;
+    // -- immutable after init
+    // List of m_sub_options instances.
+    // Index 0 is the top-level and is always present.
+    // Immutable after init.
+    // Invariant: a parent is always at a lower index than any of its children.
+    struct m_config_group *groups;
+    int num_groups;
+    // -- protected by lock
+    struct m_config_data *data; // protected shadow copy of the option data
+    struct config_cache **listeners;
+    int num_listeners;
+};
+
+// Represents a sub-struct (OPT_SUBSTRUCT()).
+struct m_config_group {
+    const struct m_sub_options *group;
+    int opt_count;      // cached opt. count; group->opts[opt_count].name==NULL
+    int group_count;    // 1 + number of all sub groups owned by this (so
+                        // m_config_shadow.groups[idx..idx+group_count] is used
+                        // by the entire tree of sub groups included by this
+                        // group)
+    int parent_group;   // index of parent group into m_config_shadow.groups[],
+                        // or -1 for group 0
+    int parent_ptr;     // ptr offset in the parent group's data, or -1 if
+                        // none
+    const char *prefix; // concat_name(_, prefix, opt->name) => full name
+                        // (the parent names are already included in this)
+};
+
+// A copy of option data. Used for the main option struct, the shadow data,
+// and copies for m_config_cache.
+struct m_config_data {
+    struct m_config_shadow *shadow; // option definitions etc., main data copy
+    int group_index;                // start index into m_config.groups[]
+    struct m_group_data *gdata;     // user struct allocation (our copy of data)
+    int num_gdata;                  // (group_index+num_gdata = end index)
+};
+
+struct config_cache {
+    struct m_config_cache *public;
+
+    struct m_config_data *data;     // public data
+    struct m_config_data *src;      // global data (currently ==shadow->data)
+    struct m_config_shadow *shadow; // global metadata
+    int group_start, group_end;     // derived from data->group_index etc.
+    uint64_t ts;                    // timestamp of this data copy
+    bool in_list;                   // part of m_config_shadow->listeners[]
+    int upd_group;                  // for "incremental" change notification
+    int upd_opt;
+
+
+    // --- Implicitly synchronized by setting/unsetting wakeup_cb.
+    struct mp_dispatch_queue *wakeup_dispatch_queue;
+    void (*wakeup_dispatch_cb)(void *ctx);
+    void *wakeup_dispatch_cb_ctx;
+
+    // --- Protected by shadow->lock
+    void (*wakeup_cb)(void *ctx);
+    void *wakeup_cb_ctx;
+};
+
+// Per m_config_data state for each m_config_group.
+struct m_group_data {
+    char *udata;        // pointer to group user option struct
+    uint64_t ts;        // timestamp of the data copy
+};
+
+static void add_sub_group(struct m_config_shadow *shadow, const char *name_prefix,
+                          int parent_group_index, int parent_ptr,
+                          const struct m_sub_options *subopts);
+
+static struct m_group_data *m_config_gdata(struct m_config_data *data,
+                                           int group_index)
+{
+    if (group_index < data->group_index ||
+        group_index >= data->group_index + data->num_gdata)
+        return NULL;
+
+    return &data->gdata[group_index - data->group_index];
+}
+
+// Like concat_name(), but returns either a, b, or buf. buf/buf_size is used as
+// target for snprintf(). (buf_size is recommended to be MAX_OPT_NAME_LEN.)
+static const char *concat_name_buf(char *buf, size_t buf_size,
+                                   const char *a, const char *b)
+{
+    assert(a);
+    assert(b);
+    if (!a[0])
+        return b;
+    if (!b[0])
+        return a;
+    snprintf(buf, buf_size, "%s-%s", a, b);
+    return buf;
+}
+
+// Return full option name from prefix (a) and option name (b). Returns either
+// a, b, or a talloc'ed string under ta_parent.
+static const char *concat_name(void *ta_parent, const char *a, const char *b)
+{
+    char buf[M_CONFIG_MAX_OPT_NAME_LEN];
+    const char *r = concat_name_buf(buf, sizeof(buf), a, b);
+    return r == buf ? talloc_strdup(ta_parent, r) : r;
+}
+
+static bool iter_next(struct m_config_shadow *shadow, int group_start,
+                      int group_end, int32_t *p_id)
+{
+    int32_t id = *p_id;
+    int group_index = id == -1 ? group_start : id >> 16;
+    int opt_index = id == -1 ? -1 : id & 0xFFFF;
+
+    assert(group_index >= group_start && group_index <= group_end);
+
+    while (1) {
+        if (group_index >= group_end)
+            return false;
+
+        struct m_config_group *g = &shadow->groups[group_index];
+        const struct m_option *opts = g->group->opts;
+
+        assert(opt_index >= -1 && opt_index < g->opt_count);
+
+        opt_index += 1;
+
+        if (!opts || !opts[opt_index].name) {
+            group_index += 1;
+            opt_index = -1;
+            continue;
+        }
+
+        if (opts[opt_index].type == &m_option_type_subconfig)
+            continue;
+
+        *p_id = (group_index << 16) | opt_index;
+        return true;
+    }
+}
+
+bool m_config_shadow_get_next_opt(struct m_config_shadow *shadow, int32_t *p_id)
+{
+    return iter_next(shadow, 0, shadow->num_groups, p_id);
+}
+
+bool m_config_cache_get_next_opt(struct m_config_cache *cache, int32_t *p_id)
+{
+    return iter_next(cache->shadow, cache->internal->group_start,
+                     cache->internal->group_end, p_id);
+}
+
+static void get_opt_from_id(struct m_config_shadow *shadow, int32_t id,
+                            int *out_group_index, int *out_opt_index)
+{
+    int group_index = id >> 16;
+    int opt_index = id & 0xFFFF;
+
+    assert(group_index >= 0 && group_index < shadow->num_groups);
+    assert(opt_index >= 0 && opt_index < shadow->groups[group_index].opt_count);
+
+    *out_group_index = group_index;
+    *out_opt_index = opt_index;
+}
+
+const struct m_option *m_config_shadow_get_opt(struct m_config_shadow *shadow,
+                                               int32_t id)
+{
+    int group_index, opt_index;
+    get_opt_from_id(shadow, id, &group_index, &opt_index);
+
+    return &shadow->groups[group_index].group->opts[opt_index];
+}
+
+const char *m_config_shadow_get_opt_name(struct m_config_shadow *shadow,
+                                         int32_t id, char *buf, size_t buf_size)
+{
+    int group_index, opt_index;
+    get_opt_from_id(shadow, id, &group_index, &opt_index);
+
+    struct m_config_group *g = &shadow->groups[group_index];
+    return concat_name_buf(buf, buf_size, g->prefix,
+                           g->group->opts[opt_index].name);
+}
+
+const void *m_config_shadow_get_opt_default(struct m_config_shadow *shadow,
+                                            int32_t id)
+{
+    int group_index, opt_index;
+    get_opt_from_id(shadow, id, &group_index, &opt_index);
+
+    const struct m_sub_options *subopt = shadow->groups[group_index].group;
+    const struct m_option *opt = &subopt->opts[opt_index];
+
+    if (opt->offset < 0)
+        return NULL;
+
+    if (opt->defval)
+        return opt->defval;
+
+    if (subopt->defaults)
+        return (char *)subopt->defaults + opt->offset;
+
+    return &m_option_value_default;
+}
+
+void *m_config_cache_get_opt_data(struct m_config_cache *cache, int32_t id)
+{
+    int group_index, opt_index;
+    get_opt_from_id(cache->shadow, id, &group_index, &opt_index);
+
+    assert(group_index >= cache->internal->group_start &&
+           group_index < cache->internal->group_end);
+
+    struct m_group_data *gd = m_config_gdata(cache->internal->data, group_index);
+    const struct m_option *opt =
+        &cache->shadow->groups[group_index].group->opts[opt_index];
+
+    return gd && opt->offset >= 0 ? gd->udata + opt->offset : NULL;
+}
+
+static uint64_t get_opt_change_mask(struct m_config_shadow *shadow, int group_index,
+                                    int group_root, const struct m_option *opt)
+{
+    uint64_t changed = opt->flags & UPDATE_OPTS_MASK;
+    while (group_index != group_root) {
+        struct m_config_group *g = &shadow->groups[group_index];
+        changed |= g->group->change_flags;
+        group_index = g->parent_group;
+    }
+    return changed;
+}
+
+uint64_t m_config_cache_get_option_change_mask(struct m_config_cache *cache,
+                                               int32_t id)
+{
+    struct m_config_shadow *shadow = cache->shadow;
+    int group_index, opt_index;
+    get_opt_from_id(shadow, id, &group_index, &opt_index);
+
+    assert(group_index >= cache->internal->group_start &&
+           group_index < cache->internal->group_end);
+
+    return get_opt_change_mask(cache->shadow, group_index,
+                               cache->internal->data->group_index,
+                               &shadow->groups[group_index].group->opts[opt_index]);
+}
+
+// The memcpys are supposed to work around the strict aliasing violation,
+// that would result if we just dereferenced a void** (where the void** is
+// actually casted from struct some_type* ). The dummy struct type is in
+// theory needed, because void* and struct pointers could have different
+// representations, while pointers to different struct types don't.
+static void *substruct_read_ptr(const void *ptr)
+{
+    struct mp_dummy_ *res;
+    memcpy(&res, ptr, sizeof(res));
+    return res;
+}
+static void substruct_write_ptr(void *ptr, void *val)
+{
+    struct mp_dummy_ *src = val;
+    memcpy(ptr, &src, sizeof(src));
+}
+
+// Initialize a field with a given value. In case this is dynamic data, it has
+// to be allocated and copied. src can alias dst.
+static void init_opt_inplace(const struct m_option *opt, void *dst,
+                             const void *src)
+{
+    // The option will use dynamic memory allocation iff it has a free callback.
+    if (opt->type->free) {
+        union m_option_value temp;
+        memcpy(&temp, src, opt->type->size);
+        memset(dst, 0, opt->type->size);
+        m_option_copy(opt, dst, &temp);
+    } else if (src != dst) {
+        memcpy(dst, src, opt->type->size);
+    }
+}
+
+static void alloc_group(struct m_config_data *data, int group_index,
+                        struct m_config_data *copy)
+{
+    assert(group_index == data->group_index + data->num_gdata);
+    assert(group_index < data->shadow->num_groups);
+    struct m_config_group *group = &data->shadow->groups[group_index];
+    const struct m_sub_options *opts = group->group;
+
+    MP_TARRAY_GROW(data, data->gdata, data->num_gdata);
+    struct m_group_data *gdata = &data->gdata[data->num_gdata++];
+
+    struct m_group_data *copy_gdata =
+        copy ? m_config_gdata(copy, group_index) : NULL;
+
+    *gdata = (struct m_group_data){
+        .udata = talloc_zero_size(data, opts->size),
+        .ts = copy_gdata ? copy_gdata->ts : 0,
+    };
+
+    if (opts->defaults)
+        memcpy(gdata->udata, opts->defaults, opts->size);
+
+    char *copy_src = copy_gdata ? copy_gdata->udata : NULL;
+
+    for (int n = 0; opts->opts && opts->opts[n].name; n++) {
+        const struct m_option *opt = &opts->opts[n];
+
+        if (opt->offset < 0 || opt->type->size == 0)
+            continue;
+
+        void *dst = gdata->udata + opt->offset;
+        const void *defptr = opt->defval ? opt->defval : dst;
+        if (copy_src)
+            defptr = copy_src + opt->offset;
+
+        init_opt_inplace(opt, dst, defptr);
+    }
+
+    // If there's a parent, update its pointer to the new struct.
+    if (group->parent_group >= data->group_index && group->parent_ptr >= 0) {
+        struct m_group_data *parent_gdata =
+            m_config_gdata(data, group->parent_group);
+        assert(parent_gdata);
+
+        substruct_write_ptr(parent_gdata->udata + group->parent_ptr, gdata->udata);
+    }
+}
+
+static void free_option_data(void *p)
+{
+    struct m_config_data *data = p;
+
+    for (int i = 0; i < data->num_gdata; i++) {
+        struct m_group_data *gdata = &data->gdata[i];
+        struct m_config_group *group =
+            &data->shadow->groups[data->group_index + i];
+        const struct m_option *opts = group->group->opts;
+
+        for (int n = 0; opts && opts[n].name; n++) {
+            const struct m_option *opt = &opts[n];
+
+            if (opt->offset >= 0 && opt->type->size > 0)
+                m_option_free(opt, gdata->udata + opt->offset);
+        }
+    }
+}
+
+// Allocate data using the option description in shadow, starting at group_index
+// (index into m_config.groups[]).
+// If copy is not NULL, copy all data from there (for groups which are in both
+// m_config_data instances), in all other cases init the data with the defaults.
+static struct m_config_data *allocate_option_data(void *ta_parent,
+                                                  struct m_config_shadow *shadow,
+                                                  int group_index,
+                                                  struct m_config_data *copy)
+{
+    assert(group_index >= 0 && group_index < shadow->num_groups);
+    struct m_config_data *data = talloc_zero(ta_parent, struct m_config_data);
+    talloc_set_destructor(data, free_option_data);
+
+    data->shadow = shadow;
+    data->group_index = group_index;
+
+    struct m_config_group *root_group = &shadow->groups[group_index];
+    assert(root_group->group_count > 0);
+
+    for (int n = group_index; n < group_index + root_group->group_count; n++)
+        alloc_group(data, n, copy);
+
+    return data;
+}
+
+static void shadow_destroy(void *p)
+{
+    struct m_config_shadow *shadow = p;
+
+    // must all have been unregistered
+    assert(shadow->num_listeners == 0);
+
+    talloc_free(shadow->data);
+    mp_mutex_destroy(&shadow->lock);
+}
+
+struct m_config_shadow *m_config_shadow_new(const struct m_sub_options *root)
+{
+    struct m_config_shadow *shadow = talloc_zero(NULL, struct m_config_shadow);
+    talloc_set_destructor(shadow, shadow_destroy);
+    mp_mutex_init(&shadow->lock);
+
+    add_sub_group(shadow, NULL, -1, -1, root);
+
+    if (!root->size)
+        return shadow;
+
+    shadow->data = allocate_option_data(shadow, shadow, 0, NULL);
+
+    return shadow;
+}
+
+static void init_obj_settings_list(struct m_config_shadow *shadow,
+                                   int parent_group_index,
+                                   const struct m_obj_list *list)
+{
+    struct m_obj_desc desc;
+    for (int n = 0; ; n++) {
+        if (!list->get_desc(&desc, n))
+            break;
+        if (desc.global_opts) {
+            add_sub_group(shadow, NULL, parent_group_index, -1,
+                          desc.global_opts);
+        }
+        if (list->use_global_options && desc.options) {
+            struct m_sub_options *conf = talloc_ptrtype(shadow, conf);
+            *conf = (struct m_sub_options){
+                .prefix = desc.options_prefix,
+                .opts = desc.options,
+                .defaults = desc.priv_defaults,
+                .size = desc.priv_size,
+            };
+            add_sub_group(shadow, NULL, parent_group_index, -1, conf);
+        }
+    }
+}
+
+static void add_sub_group(struct m_config_shadow *shadow, const char *name_prefix,
+                          int parent_group_index, int parent_ptr,
+                          const struct m_sub_options *subopts)
+{
+    // Can't be used multiple times.
+    for (int n = 0; n < shadow->num_groups; n++)
+        assert(shadow->groups[n].group != subopts);
+
+    if (!name_prefix)
+        name_prefix = "";
+    if (subopts->prefix && subopts->prefix[0]) {
+        assert(!name_prefix[0]);
+        name_prefix = subopts->prefix;
+    }
+
+    // You can only use UPDATE_ flags here.
+    assert(!(subopts->change_flags & ~(unsigned)UPDATE_OPTS_MASK));
+
+    assert(parent_group_index >= -1 && parent_group_index < shadow->num_groups);
+
+    int group_index = shadow->num_groups++;
+    MP_TARRAY_GROW(shadow, shadow->groups, group_index);
+    shadow->groups[group_index] = (struct m_config_group){
+        .group = subopts,
+        .parent_group = parent_group_index,
+        .parent_ptr = parent_ptr,
+        .prefix = name_prefix,
+    };
+
+    for (int i = 0; subopts->opts && subopts->opts[i].name; i++) {
+        const struct m_option *opt = &subopts->opts[i];
+
+        if (opt->type == &m_option_type_subconfig) {
+            const struct m_sub_options *new_subopts = opt->priv;
+
+            // Providing default structs in-place is not allowed.
+            if (opt->offset >= 0 && subopts->defaults) {
+                void *ptr = (char *)subopts->defaults + opt->offset;
+                assert(!substruct_read_ptr(ptr));
+            }
+
+            const char *prefix = concat_name(shadow, name_prefix, opt->name);
+            add_sub_group(shadow, prefix, group_index, opt->offset, new_subopts);
+
+        } else if (opt->type == &m_option_type_obj_settings_list) {
+            const struct m_obj_list *objlist = opt->priv;
+            init_obj_settings_list(shadow, group_index, objlist);
+        }
+
+        shadow->groups[group_index].opt_count = i + 1;
+    }
+
+    if (subopts->get_sub_options) {
+        for (int i = 0; ; i++) {
+            const struct m_sub_options *sub = NULL;
+            if (!subopts->get_sub_options(i, &sub))
+                break;
+            if (sub)
+                add_sub_group(shadow, NULL, group_index, -1, sub);
+        }
+    }
+
+    shadow->groups[group_index].group_count = shadow->num_groups - group_index;
+}
+
+static void cache_destroy(void *p)
+{
+    struct m_config_cache *cache = p;
+
+    // (technically speaking, being able to call them both without anything
+    // breaking is a feature provided by these functions)
+    m_config_cache_set_wakeup_cb(cache, NULL, NULL);
+    m_config_cache_set_dispatch_change_cb(cache, NULL, NULL, NULL);
+}
+
+struct m_config_cache *m_config_cache_from_shadow(void *ta_parent,
+                                            struct m_config_shadow *shadow,
+                                            const struct m_sub_options *group)
+{
+    int group_index = -1;
+
+    for (int n = 0; n < shadow->num_groups; n++) {
+        if (shadow->groups[n].group == group) {
+            group_index = n;
+            break;
+        }
+    }
+
+    assert(group_index >= 0); // invalid group (or not in option tree)
+
+    struct cache_alloc {
+        struct m_config_cache a;
+        struct config_cache b;
+    };
+    struct cache_alloc *alloc = talloc_zero(ta_parent, struct cache_alloc);
+    assert((void *)&alloc->a == (void *)alloc);
+    struct m_config_cache *cache = &alloc->a;
+    talloc_set_destructor(cache, cache_destroy);
+    cache->internal = &alloc->b;
+    cache->shadow = shadow;
+
+    struct config_cache *in = cache->internal;
+    in->shadow = shadow;
+    in->src = shadow->data;
+
+    mp_mutex_lock(&shadow->lock);
+    in->data = allocate_option_data(cache, shadow, group_index, in->src);
+    mp_mutex_unlock(&shadow->lock);
+
+    cache->opts = in->data->gdata[0].udata;
+
+    in->group_start = in->data->group_index;
+    in->group_end = in->group_start + in->data->num_gdata;
+    assert(shadow->groups[in->group_start].group_count == in->data->num_gdata);
+
+    in->upd_group = -1;
+
+    return cache;
+}
+
+struct m_config_cache *m_config_cache_alloc(void *ta_parent,
+                                            struct mpv_global *global,
+                                            const struct m_sub_options *group)
+{
+    return m_config_cache_from_shadow(ta_parent, global->config, group);
+}
+
+static void update_next_option(struct m_config_cache *cache, void **p_opt)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_data *dst = in->data;
+    struct m_config_data *src = in->src;
+
+    assert(src->group_index == 0); // must be the option root currently
+
+    *p_opt = NULL;
+
+    while (in->upd_group < dst->group_index + dst->num_gdata) {
+        struct m_group_data *gsrc = m_config_gdata(src, in->upd_group);
+        struct m_group_data *gdst = m_config_gdata(dst, in->upd_group);
+        assert(gsrc && gdst);
+
+        if (gdst->ts < gsrc->ts) {
+            struct m_config_group *g = &dst->shadow->groups[in->upd_group];
+            const struct m_option *opts = g->group->opts;
+
+            while (opts && opts[in->upd_opt].name) {
+                const struct m_option *opt = &opts[in->upd_opt];
+
+                if (opt->offset >= 0 && opt->type->size) {
+                    void *dsrc = gsrc->udata + opt->offset;
+                    void *ddst = gdst->udata + opt->offset;
+
+                    if (!m_option_equal(opt, ddst, dsrc)) {
+                        uint64_t ch = get_opt_change_mask(dst->shadow,
+                                        in->upd_group, dst->group_index, opt);
+
+                        if (cache->debug) {
+                            char *vdst = m_option_print(opt, ddst);
+                            char *vsrc = m_option_print(opt, dsrc);
+                            mp_warn(cache->debug, "Option '%s' changed from "
+                                    "'%s' to' %s' (flags = 0x%"PRIx64")\n",
+                                    opt->name, vdst, vsrc, ch);
+                            talloc_free(vdst);
+                            talloc_free(vsrc);
+                        }
+
+                        m_option_copy(opt, ddst, dsrc);
+                        cache->change_flags |= ch;
+
+                        in->upd_opt++; // skip this next time
+                        *p_opt = ddst;
+                        return;
+                    }
+                }
+
+                in->upd_opt++;
+            }
+
+            gdst->ts = gsrc->ts;
+        }
+
+        in->upd_group++;
+        in->upd_opt = 0;
+    }
+
+    in->upd_group = -1;
+}
+
+static bool cache_check_update(struct m_config_cache *cache)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_shadow *shadow = in->shadow;
+
+    // Using atomics and checking outside of the lock - it's unknown whether
+    // this makes it faster or slower. Just cargo culting it.
+    uint64_t new_ts = atomic_load(&shadow->ts);
+    if (in->ts >= new_ts)
+        return false;
+
+    in->ts = new_ts;
+    in->upd_group = in->data->group_index;
+    in->upd_opt = 0;
+    return true;
+}
+
+bool m_config_cache_update(struct m_config_cache *cache)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_shadow *shadow = in->shadow;
+
+    if (!cache_check_update(cache))
+        return false;
+
+    mp_mutex_lock(&shadow->lock);
+    bool res = false;
+    while (1) {
+        void *p;
+        update_next_option(cache, &p);
+        if (!p)
+            break;
+        res = true;
+    }
+    mp_mutex_unlock(&shadow->lock);
+    return res;
+}
+
+bool m_config_cache_get_next_changed(struct m_config_cache *cache, void **opt)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_shadow *shadow = in->shadow;
+
+    *opt = NULL;
+    if (!cache_check_update(cache) && in->upd_group < 0)
+        return false;
+
+    mp_mutex_lock(&shadow->lock);
+    update_next_option(cache, opt);
+    mp_mutex_unlock(&shadow->lock);
+    return !!*opt;
+}
+
+static void find_opt(struct m_config_shadow *shadow, struct m_config_data *data,
+                     void *ptr, int *group_idx, int *opt_idx)
+{
+    *group_idx = -1;
+    *opt_idx = -1;
+
+    for (int n = data->group_index; n < data->group_index + data->num_gdata; n++)
+    {
+        struct m_group_data *gd = m_config_gdata(data, n);
+        struct m_config_group *g = &shadow->groups[n];
+        const struct m_option *opts = g->group->opts;
+
+        for (int i = 0; opts && opts[i].name; i++) {
+            const struct m_option *opt = &opts[i];
+
+            if (opt->offset >= 0 && opt->type->size &&
+                ptr == gd->udata + opt->offset)
+            {
+                *group_idx = n;
+                *opt_idx = i;
+                return;
+            }
+        }
+    }
+}
+
+bool m_config_cache_write_opt(struct m_config_cache *cache, void *ptr)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_shadow *shadow = in->shadow;
+
+    int group_idx = -1;
+    int opt_idx = -1;
+    find_opt(shadow, in->data, ptr, &group_idx, &opt_idx);
+
+    // ptr was not in cache->opts, or no option declaration matching it.
+    assert(group_idx >= 0);
+
+    struct m_config_group *g = &shadow->groups[group_idx];
+    const struct m_option *opt = &g->group->opts[opt_idx];
+
+    mp_mutex_lock(&shadow->lock);
+
+    struct m_group_data *gdst = m_config_gdata(in->data, group_idx);
+    struct m_group_data *gsrc = m_config_gdata(in->src, group_idx);
+    assert(gdst && gsrc);
+
+    bool changed = !m_option_equal(opt, gsrc->udata + opt->offset, ptr);
+    if (changed) {
+        m_option_copy(opt, gsrc->udata + opt->offset, ptr);
+
+        gsrc->ts = atomic_fetch_add(&shadow->ts, 1) + 1;
+
+        for (int n = 0; n < shadow->num_listeners; n++) {
+            struct config_cache *listener = shadow->listeners[n];
+            if (listener->wakeup_cb && m_config_gdata(listener->data, group_idx))
+                listener->wakeup_cb(listener->wakeup_cb_ctx);
+        }
+    }
+
+    mp_mutex_unlock(&shadow->lock);
+
+    return changed;
+}
+
+void m_config_cache_set_wakeup_cb(struct m_config_cache *cache,
+                                  void (*cb)(void *ctx), void *cb_ctx)
+{
+    struct config_cache *in = cache->internal;
+    struct m_config_shadow *shadow = in->shadow;
+
+    mp_mutex_lock(&shadow->lock);
+    if (in->in_list) {
+        for (int n = 0; n < shadow->num_listeners; n++) {
+            if (shadow->listeners[n] == in) {
+                MP_TARRAY_REMOVE_AT(shadow->listeners, shadow->num_listeners, n);
+                break;
+            }
+        }
+        for (int n = 0; n < shadow->num_listeners; n++)
+            assert(shadow->listeners[n] != in); // only 1 wakeup_cb per cache
+        // (The deinitialization path relies on this to free all memory.)
+        if (!shadow->num_listeners) {
+            talloc_free(shadow->listeners);
+            shadow->listeners = NULL;
+        }
+    }
+    if (cb) {
+        MP_TARRAY_APPEND(NULL, shadow->listeners, shadow->num_listeners, in);
+        in->in_list = true;
+        in->wakeup_cb = cb;
+        in->wakeup_cb_ctx = cb_ctx;
+    }
+    mp_mutex_unlock(&shadow->lock);
+}
+
+static void dispatch_notify(void *p)
+{
+    struct config_cache *in = p;
+
+    assert(in->wakeup_dispatch_queue);
+    mp_dispatch_enqueue_notify(in->wakeup_dispatch_queue,
+                               in->wakeup_dispatch_cb,
+                               in->wakeup_dispatch_cb_ctx);
+}
+
+void m_config_cache_set_dispatch_change_cb(struct m_config_cache *cache,
+                                           struct mp_dispatch_queue *dispatch,
+                                           void (*cb)(void *ctx), void *cb_ctx)
+{
+    struct config_cache *in = cache->internal;
+
+    // Removing the old one is tricky. First make sure no new notifications will
+    // come.
+    m_config_cache_set_wakeup_cb(cache, NULL, NULL);
+    // Remove any pending notifications (assume we're on the same thread as
+    // any potential mp_dispatch_queue_process() callers).
+    if (in->wakeup_dispatch_queue) {
+        mp_dispatch_cancel_fn(in->wakeup_dispatch_queue,
+                              in->wakeup_dispatch_cb,
+                              in->wakeup_dispatch_cb_ctx);
+    }
+
+    in->wakeup_dispatch_queue = NULL;
+    in->wakeup_dispatch_cb = NULL;
+    in->wakeup_dispatch_cb_ctx = NULL;
+
+    if (cb) {
+        in->wakeup_dispatch_queue = dispatch;
+        in->wakeup_dispatch_cb = cb;
+        in->wakeup_dispatch_cb_ctx = cb_ctx;
+        m_config_cache_set_wakeup_cb(cache, dispatch_notify, in);
+    }
+}
+
+void *mp_get_config_group(void *ta_parent, struct mpv_global *global,
+                          const struct m_sub_options *group)
+{
+    struct m_config_cache *cache = m_config_cache_alloc(NULL, global, group);
+    // Make talloc_free(cache->opts) free the entire cache.
+    ta_set_parent(cache->opts, ta_parent);
+    ta_set_parent(cache, cache->opts);
+    return cache->opts;
+}
+
+static const struct m_config_group *find_group(struct mpv_global *global,
+                                               const struct m_option *cfg)
+{
+    struct m_config_shadow *shadow = global->config;
+
+    for (int n = 0; n < shadow->num_groups; n++) {
+        if (shadow->groups[n].group->opts == cfg)
+            return &shadow->groups[n];
+    }
+
+    return NULL;
+}
+
+void *m_config_group_from_desc(void *ta_parent, struct mp_log *log,
+        struct mpv_global *global, struct m_obj_desc *desc, const char *name)
+{
+    const struct m_config_group *group = find_group(global, desc->options);
+    if (group) {
+        return mp_get_config_group(ta_parent, global, group->group);
+    } else {
+        void *d = talloc_zero_size(ta_parent, desc->priv_size);
+        if (desc->priv_defaults)
+            memcpy(d, desc->priv_defaults, desc->priv_size);
+        return d;
+    }
+}
diff --git a/options/m_config_core.h b/options/m_config_core.h
new file mode 100644
index 0000000..a955842
--- /dev/null
+++ b/options/m_config_core.h
@@ -0,0 +1,194 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_M_CONFIG_H
+#define MPLAYER_M_CONFIG_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+struct mp_dispatch_queue;
+struct m_sub_options;
+struct m_option_type;
+struct m_option;
+struct mpv_global;
+
+// This can be used to create and synchronize per-thread option structs,
+// which then can be read without synchronization. No concurrent access to
+// the cache itself is allowed.
+struct m_config_cache {
+    // The struct as indicated by m_config_cache_alloc's group parameter.
+    // (Internally the same as internal->gdata[0]->udata.)
+    void *opts;
+    // Accumulated change flags. The user can set this to 0 to unset all flags.
+    // They are set when calling any of the update functions. A flag is only set
+    // once the new value is visible in ->opts.
+    uint64_t change_flags;
+
+    // Set to non-NULL for logging all option changes as they are retrieved
+    // with one of the update functions (like m_config_cache_update()).
+    struct mp_log *debug;
+
+    // Global instance of option data. Read only.
+    struct m_config_shadow *shadow;
+
+    // Do not access.
+    struct config_cache *internal;
+};
+
+// Maximum possibly option name buffer length (as it appears to the user).
+#define M_CONFIG_MAX_OPT_NAME_LEN 80
+
+// Create a mirror copy from the global options.
+// Keep in mind that a m_config_cache object is not thread-safe; it merely
+// provides thread-safe access to the global options. All API functions for
+// the same m_config_cache object must synchronized, unless otherwise noted.
+// This does not create an initial change event (m_config_cache_update() will
+// return false), but note that a change might be asynchronously signaled at any
+// time.
+// This simply calls m_config_cache_from_shadow(ta_parent, global->shadow, group).
+//  ta_parent: parent for the returned allocation
+//  global: option data source
+//  group: the option group to return
+struct m_config_cache *m_config_cache_alloc(void *ta_parent,
+                                            struct mpv_global *global,
+                                            const struct m_sub_options *group);
+
+// If any of the options in the group possibly changes, call this callback. The
+// callback must not actually access the cache or anything option related.
+// Instead, it must wake up the thread that normally accesses the cache.
+void m_config_cache_set_wakeup_cb(struct m_config_cache *cache,
+                                  void (*cb)(void *ctx), void *cb_ctx);
+
+// If any of the options in the group change, call this callback on the given
+// dispatch queue. This is higher level than m_config_cache_set_wakeup_cb(),
+// and you can do anything you want in the callback (assuming the dispatch
+// queue is processed in the same thread that accesses m_config_cache API).
+// To ensure clean shutdown, you must destroy the m_config_cache (or unset the
+// callback) before the dispatch queue is destroyed.
+void m_config_cache_set_dispatch_change_cb(struct m_config_cache *cache,
+                                           struct mp_dispatch_queue *dispatch,
+                                           void (*cb)(void *ctx), void *cb_ctx);
+
+// Update the options in cache->opts to current global values. Return whether
+// there was an update notification at all (which may or may not indicate that
+// some options have changed).
+// Keep in mind that while the cache->opts pointer does not change, the option
+// data itself will (e.g. string options might be reallocated).
+// New change flags are or-ed into cache->change_flags with this call (if you
+// use them, you should probably do cache->change_flags=0 before this call).
+bool m_config_cache_update(struct m_config_cache *cache);
+
+// Check for changes and return fine grained change information.
+// Warning: this conflicts with m_config_cache_update(). If you call
+//          m_config_cache_update(), all options will be marked as "not changed",
+//          and this function will return false. Also, calling this function and
+//          then m_config_cache_update() is not supported, and may skip updating
+//          some fields.
+// This returns true as long as there is a changed option, and false if all
+// changed options have been returned.
+// If multiple options have changed, the new option value is visible only once
+// this function has returned the change for it.
+//  out_ptr: pointer to a void*, which is set to the cache->opts field associated
+//           with the changed option if the function returns true; set to NULL
+//           if no option changed.
+//  returns: *out_ptr!=NULL (true if there was a changed option)
+bool m_config_cache_get_next_changed(struct m_config_cache *cache, void **out_ptr);
+
+// Copy the option field pointed to by ptr to the global option storage. This
+// is sort of similar to m_config_set_option_raw(), except doesn't require
+// access to the main thread. (And you can't pass any flags.)
+// You write the new value to the option struct, and then call this function
+// with the pointer to it. You will not get a change notification for it (though
+// you might still get a redundant wakeup callback).
+// Changing the option struct and not calling this function before any update
+// function (like m_config_cache_update()) will leave the value inconsistent,
+// and will possibly (but not necessarily) overwrite it with the next update
+// call.
+//  ptr: points to any field in cache->opts that is managed by an option. If
+//       this is not the case, the function crashes for your own good.
+//  returns: if true, this was an update; if false, shadow had same value
+bool m_config_cache_write_opt(struct m_config_cache *cache, void *ptr);
+
+// Like m_config_cache_alloc(), but return the struct (m_config_cache->opts)
+// directly, with no way to update the config. Basically this returns a copy
+// with a snapshot of the current option values.
+void *mp_get_config_group(void *ta_parent, struct mpv_global *global,
+                          const struct m_sub_options *group);
+
+// Allocate a priv struct that is backed by global options (like AOs and VOs,
+// anything that uses m_obj_list.use_global_options == true).
+// The result contains a snapshot of the current option values of desc->options.
+// For convenience, desc->options can be NULL; then priv struct is allocated
+// with just zero (or priv_defaults if set).
+// Bad function.
+struct m_obj_desc;
+void *m_config_group_from_desc(void *ta_parent, struct mp_log *log,
+        struct mpv_global *global, struct m_obj_desc *desc, const char *name);
+
+// Allocate new option shadow storage with all options set to defaults.
+// root must stay valid for the lifetime of the return value.
+// Result can be freed with ta_free().
+struct m_config_shadow *m_config_shadow_new(const struct m_sub_options *root);
+
+// See m_config_cache_alloc().
+struct m_config_cache *m_config_cache_from_shadow(void *ta_parent,
+                                            struct m_config_shadow *shadow,
+                                            const struct m_sub_options *group);
+
+// Iterate over all registered global options. *p_id must be set to -1 when this
+// is called for the first time. Each time this call returns true, *p_id is set
+// to a new valid option ID. p_id must not be changed for the next call. If
+// false is returned, iteration ends.
+bool m_config_shadow_get_next_opt(struct m_config_shadow *shadow, int32_t *p_id);
+
+// Similar to m_config_shadow_get_next_opt(), but return only options that are
+// covered by the m_config_cache.
+bool m_config_cache_get_next_opt(struct m_config_cache *cache, int32_t *p_id);
+
+// Return the m_option that was used to declare this option.
+// id must be a valid option ID as returned by m_config_shadow_get_next_opt() or
+// m_config_cache_get_next_opt().
+const struct m_option *m_config_shadow_get_opt(struct m_config_shadow *shadow,
+                                               int32_t id);
+
+// Return the full (global) option name. buf must be supplied, but may not
+// always be used. It should have the size M_CONFIG_MAX_OPT_NAME_LEN.
+// The returned point points either to buf or a static string.
+// id must be a valid option ID as returned by m_config_shadow_get_next_opt() or
+// m_config_cache_get_next_opt().
+const char *m_config_shadow_get_opt_name(struct m_config_shadow *shadow,
+                                         int32_t id, char *buf, size_t buf_size);
+
+// Pointer to default value, using m_option.type. NULL if option without data.
+// id must be a valid option ID as returned by m_config_shadow_get_next_opt() or
+// m_config_cache_get_next_opt().
+const void *m_config_shadow_get_opt_default(struct m_config_shadow *shadow,
+                                            int32_t id);
+
+// Return the pointer to the allocated option data (the same pointers that are
+// returned by m_config_cache_get_next_changed()). NULL if option without data.
+// id must be a valid option ID as returned by m_config_cache_get_next_opt().
+void *m_config_cache_get_opt_data(struct m_config_cache *cache, int32_t id);
+
+// Return or-ed UPDATE_OPTS_MASK part of the option and containing sub-options.
+// id must be a valid option ID as returned by m_config_cache_get_next_opt().
+uint64_t m_config_cache_get_option_change_mask(struct m_config_cache *cache,
+                                               int32_t id);
+
+#endif /* MPLAYER_M_CONFIG_H */
diff --git a/options/m_config_frontend.c b/options/m_config_frontend.c
new file mode 100644
index 0000000..9b54389
--- /dev/null
+++ b/options/m_config_frontend.c
@@ -0,0 +1,1080 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <float.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#include "libmpv/client.h"
+
+#include "common/common.h"
+#include "common/global.h"
+#include "common/msg_control.h"
+#include "common/msg.h"
+#include "m_config_frontend.h"
+#include "m_config.h"
+#include "misc/dispatch.h"
+#include "misc/node.h"
+#include "options/m_option.h"
+#include "osdep/threads.h"
+
+extern const char mp_help_text[];
+
+// Profiles allow to predefine some sets of options that can then
+// be applied later on with the internal -profile option.
+#define MAX_PROFILE_DEPTH 20
+// Maximal include depth.
+#define MAX_RECURSION_DEPTH 8
+
+struct m_profile {
+    struct m_profile *next;
+    char *name;
+    char *desc;
+    char *cond;
+    int restore_mode;
+    int num_opts;
+    // Option/value pair array.
+    // name,value = opts[n*2+0],opts[n*2+1]
+    char **opts;
+    // For profile restoring.
+    struct m_opt_backup *backups;
+};
+
+// In the file local case, this contains the old global value.
+// It's also used for profile restoring.
+struct m_opt_backup {
+    struct m_opt_backup *next;
+    struct m_config_option *co;
+    int flags;
+    void *backup, *nval;
+};
+
+static const struct m_option profile_restore_mode_opt = {
+    .name = "profile-restore",
+    .type = &m_option_type_choice,
+    M_CHOICES({"default", 0}, {"copy", 1}, {"copy-equal", 2}),
+};
+
+static void list_profiles(struct m_config *config)
+{
+    MP_INFO(config, "Available profiles:\n");
+    for (struct m_profile *p = config->profiles; p; p = p->next)
+        MP_INFO(config, "\t%s\t%s\n", p->name, p->desc ? p->desc : "");
+    MP_INFO(config, "\n");
+}
+
+static int show_profile(struct m_config *config, bstr param)
+{
+    struct m_profile *p;
+    if (!param.len) {
+        list_profiles(config);
+        return M_OPT_EXIT;
+    }
+    if (!(p = m_config_get_profile(config, param))) {
+        MP_ERR(config, "Unknown profile '%.*s'.\n", BSTR_P(param));
+        return M_OPT_EXIT;
+    }
+    if (!config->profile_depth)
+        MP_INFO(config, "Profile %s: %s\n", p->name,
+                p->desc ? p->desc : "");
+    config->profile_depth++;
+    if (p->cond) {
+        MP_INFO(config, "%*sprofile-cond=%s\n", config->profile_depth, "",
+                p->cond);
+    }
+    for (int i = 0; i < p->num_opts; i++) {
+        MP_INFO(config, "%*s%s=%s\n", config->profile_depth, "",
+                p->opts[2 * i], p->opts[2 * i + 1]);
+
+        if (config->profile_depth < MAX_PROFILE_DEPTH
+            && !strcmp(p->opts[2*i], "profile")) {
+            char *e, *list = p->opts[2 * i + 1];
+            while ((e = strchr(list, ','))) {
+                int l = e - list;
+                if (!l)
+                    continue;
+                show_profile(config, (bstr){list, e - list});
+                list = e + 1;
+            }
+            if (list[0] != '\0')
+                show_profile(config, bstr0(list));
+        }
+    }
+    config->profile_depth--;
+    if (!config->profile_depth)
+        MP_INFO(config, "\n");
+    return M_OPT_EXIT;
+}
+
+static struct m_config *m_config_from_obj_desc(void *talloc_ctx,
+                                               struct mp_log *log,
+                                               struct mpv_global *global,
+                                               struct m_obj_desc *desc)
+{
+    struct m_sub_options *root = talloc_ptrtype(NULL, root);
+    *root = (struct m_sub_options){
+        .opts = desc->options,
+        // (global == NULL got repurposed to mean "no alloc")
+        .size = global ? desc->priv_size : 0,
+        .defaults = desc->priv_defaults,
+    };
+
+    struct m_config *c = m_config_new(talloc_ctx, log, root);
+    talloc_steal(c, root);
+    c->global = global;
+    return c;
+}
+
+struct m_config *m_config_from_obj_desc_noalloc(void *talloc_ctx,
+                                                struct mp_log *log,
+                                                struct m_obj_desc *desc)
+{
+    return m_config_from_obj_desc(talloc_ctx, log, NULL, desc);
+}
+
+static int m_config_set_obj_params(struct m_config *config, struct mp_log *log,
+                                   struct mpv_global *global,
+                                   struct m_obj_desc *desc, char **args)
+{
+    for (int n = 0; args && args[n * 2 + 0]; n++) {
+        bstr opt = bstr0(args[n * 2 + 0]);
+        bstr val = bstr0(args[n * 2 + 1]);
+        if (m_config_set_option_cli(config, opt, val, 0) < 0)
+            return -1;
+    }
+
+    return 0;
+}
+
+struct m_config *m_config_from_obj_desc_and_args(void *ta_parent,
+    struct mp_log *log, struct mpv_global *global, struct m_obj_desc *desc,
+    char **args)
+{
+    struct m_config *config = m_config_from_obj_desc(ta_parent, log, global, desc);
+    if (m_config_set_obj_params(config, log, global, desc, args) < 0)
+        goto error;
+
+    return config;
+error:
+    talloc_free(config);
+    return NULL;
+}
+
+static void backup_dtor(void *p)
+{
+    struct m_opt_backup *bc = p;
+    m_option_free(bc->co->opt, bc->backup);
+    if (bc->nval)
+        m_option_free(bc->co->opt, bc->nval);
+}
+
+#define BACKUP_LOCAL 1
+#define BACKUP_NVAL 2
+static void ensure_backup(struct m_opt_backup **list, int flags,
+                          struct m_config_option *co)
+{
+    if (!co->data)
+        return;
+    for (struct m_opt_backup *cur = *list; cur; cur = cur->next) {
+        if (cur->co->data == co->data) // comparing data ptr catches aliases
+            return;
+    }
+    struct m_opt_backup *bc = talloc_ptrtype(NULL, bc);
+    talloc_set_destructor(bc, backup_dtor);
+    *bc = (struct m_opt_backup) {
+        .co = co,
+        .backup = talloc_zero_size(bc, co->opt->type->size),
+        .nval = flags & BACKUP_NVAL
+            ? talloc_zero_size(bc, co->opt->type->size) : NULL,
+        .flags = flags,
+    };
+    m_option_copy(co->opt, bc->backup, co->data);
+    bc->next = *list;
+    *list = bc;
+    if (bc->flags & BACKUP_LOCAL)
+        co->is_set_locally = true;
+}
+
+static void restore_backups(struct m_opt_backup **list, struct m_config *config)
+{
+    while (*list) {
+        struct m_opt_backup *bc = *list;
+        *list = bc->next;
+
+        if (!bc->nval || m_option_equal(bc->co->opt, bc->co->data, bc->nval))
+            m_config_set_option_raw(config, bc->co, bc->backup, 0);
+
+        if (bc->flags & BACKUP_LOCAL)
+            bc->co->is_set_locally = false;
+        talloc_free(bc);
+    }
+}
+
+void m_config_restore_backups(struct m_config *config)
+{
+    restore_backups(&config->backup_opts, config);
+}
+
+bool m_config_watch_later_backup_opt_changed(struct m_config *config,
+                                             char *opt_name)
+{
+    struct m_config_option *co = m_config_get_co(config, bstr0(opt_name));
+    if (!co) {
+        MP_ERR(config, "Option %s not found.\n", opt_name);
+        return false;
+    }
+
+    for (struct m_opt_backup *bc = config->watch_later_backup_opts; bc;
+         bc = bc->next) {
+        if (strcmp(bc->co->name, co->name) == 0) {
+            struct m_config_option *bc_co = (struct m_config_option *)bc->backup;
+            return !m_option_equal(co->opt, co->data, bc_co);
+        }
+    }
+
+    return false;
+}
+
+void m_config_backup_opt(struct m_config *config, const char *opt)
+{
+    struct m_config_option *co = m_config_get_co(config, bstr0(opt));
+    if (co) {
+        ensure_backup(&config->backup_opts, BACKUP_LOCAL, co);
+    } else {
+        MP_ERR(config, "Option %s not found.\n", opt);
+    }
+}
+
+void m_config_backup_all_opts(struct m_config *config)
+{
+    for (int n = 0; n < config->num_opts; n++)
+        ensure_backup(&config->backup_opts, BACKUP_LOCAL, &config->opts[n]);
+}
+
+void m_config_backup_watch_later_opts(struct m_config *config)
+{
+    for (int n = 0; n < config->num_opts; n++)
+        ensure_backup(&config->watch_later_backup_opts, 0, &config->opts[n]);
+}
+
+struct m_config_option *m_config_get_co_raw(const struct m_config *config,
+                                            struct bstr name)
+{
+    if (!name.len)
+        return NULL;
+
+    for (int n = 0; n < config->num_opts; n++) {
+        struct m_config_option *co = &config->opts[n];
+        struct bstr coname = bstr0(co->name);
+        if (bstrcmp(coname, name) == 0)
+            return co;
+    }
+
+    return NULL;
+}
+
+// Like m_config_get_co_raw(), but resolve aliases.
+static struct m_config_option *m_config_get_co_any(const struct m_config *config,
+                                                   struct bstr name)
+{
+    struct m_config_option *co = m_config_get_co_raw(config, name);
+    if (!co)
+        return NULL;
+
+    const char *prefix = config->is_toplevel ? "--" : "";
+    if (co->opt->type == &m_option_type_alias) {
+        const char *alias = (const char *)co->opt->priv;
+        if (co->opt->deprecation_message && !co->warning_was_printed) {
+            if (co->opt->deprecation_message[0]) {
+                MP_WARN(config, "Warning: option %s%s was replaced with "
+                        "%s%s: %s\n", prefix, co->name, prefix, alias,
+                        co->opt->deprecation_message);
+            } else {
+                MP_WARN(config, "Warning: option %s%s was replaced with "
+                        "%s%s and might be removed in the future.\n",
+                        prefix, co->name, prefix, alias);
+            }
+            co->warning_was_printed = true;
+        }
+        return m_config_get_co_any(config, bstr0(alias));
+    } else if (co->opt->type == &m_option_type_removed) {
+        if (!co->warning_was_printed) {
+            char *msg = co->opt->priv;
+            if (msg) {
+                MP_FATAL(config, "Option %s%s was removed: %s\n",
+                         prefix, co->name, msg);
+            } else {
+                MP_FATAL(config, "Option %s%s was removed.\n",
+                         prefix, co->name);
+            }
+            co->warning_was_printed = true;
+        }
+        return NULL;
+    } else if (co->opt->deprecation_message) {
+        if (!co->warning_was_printed) {
+            MP_WARN(config, "Warning: option %s%s is deprecated "
+                    "and might be removed in the future (%s).\n",
+                    prefix, co->name, co->opt->deprecation_message);
+            co->warning_was_printed = true;
+        }
+    }
+    return co;
+}
+
+struct m_config_option *m_config_get_co(const struct m_config *config,
+                                        struct bstr name)
+{
+    struct m_config_option *co = m_config_get_co_any(config, name);
+    // CLI aliases should not be real options, and are explicitly handled by
+    // m_config_set_option_cli(). So pretend it does not exist.
+    if (co && co->opt->type == &m_option_type_cli_alias)
+        co = NULL;
+    return co;
+}
+
+int m_config_get_co_count(struct m_config *config)
+{
+    return config->num_opts;
+}
+
+struct m_config_option *m_config_get_co_index(struct m_config *config, int index)
+{
+    return &config->opts[index];
+}
+
+const void *m_config_get_co_default(const struct m_config *config,
+                                    struct m_config_option *co)
+{
+    return m_config_shadow_get_opt_default(config->shadow, co->opt_id);
+}
+
+const char *m_config_get_positional_option(const struct m_config *config, int p)
+{
+    int pos = 0;
+    for (int n = 0; n < config->num_opts; n++) {
+        struct m_config_option *co = &config->opts[n];
+        if (!co->opt->deprecation_message) {
+            if (pos == p)
+                return co->name;
+            pos++;
+        }
+    }
+    return NULL;
+}
+
+// return: <0: M_OPT_ error, 0: skip, 1: check, 2: set
+static int handle_set_opt_flags(struct m_config *config,
+                                struct m_config_option *co, int flags)
+{
+    int optflags = co->opt->flags;
+    bool set = !(flags & M_SETOPT_CHECK_ONLY);
+
+    if ((flags & M_SETOPT_PRE_PARSE_ONLY) && !(optflags & M_OPT_PRE_PARSE))
+        return 0;
+
+    if ((flags & M_SETOPT_PRESERVE_CMDLINE) && co->is_set_from_cmdline)
+        set = false;
+
+    if ((flags & M_SETOPT_NO_OVERWRITE) &&
+        (co->is_set_from_cmdline || co->is_set_from_config))
+        set = false;
+
+    if ((flags & M_SETOPT_NO_PRE_PARSE) && (optflags & M_OPT_PRE_PARSE))
+        return M_OPT_INVALID;
+
+    // Check if this option isn't forbidden in the current mode
+    if ((flags & M_SETOPT_FROM_CONFIG_FILE) && (optflags & M_OPT_NOCFG)) {
+        MP_ERR(config, "The %s option can't be used in a config file.\n",
+               co->name);
+        return M_OPT_INVALID;
+    }
+    if ((flags & M_SETOPT_BACKUP) && set)
+        ensure_backup(&config->backup_opts, BACKUP_LOCAL, co);
+
+    return set ? 2 : 1;
+}
+
+void m_config_mark_co_flags(struct m_config_option *co, int flags)
+{
+    if (flags & M_SETOPT_FROM_CMDLINE)
+        co->is_set_from_cmdline = true;
+
+    if (flags & M_SETOPT_FROM_CONFIG_FILE)
+        co->is_set_from_config = true;
+}
+
+// Special options that don't really fit into the option handling model. They
+// usually store no data, but trigger actions. Caller is assumed to have called
+// handle_set_opt_flags() to make sure the option can be set.
+// Returns M_OPT_UNKNOWN if the option is not a special option.
+static int m_config_handle_special_options(struct m_config *config,
+                                           struct m_config_option *co,
+                                           void *data, int flags)
+{
+    if (config->use_profiles && strcmp(co->name, "profile") == 0) {
+        char **list = *(char ***)data;
+
+        if (list && list[0] && !list[1] && strcmp(list[0], "help") == 0) {
+            if (!config->profiles) {
+                MP_INFO(config, "No profiles have been defined.\n");
+                return M_OPT_EXIT;
+            }
+            list_profiles(config);
+            return M_OPT_EXIT;
+        }
+
+        for (int n = 0; list && list[n]; n++) {
+            int r = m_config_set_profile(config, list[n], flags);
+            if (r < 0)
+                return r;
+        }
+        return 0;
+    }
+
+    if (config->includefunc && strcmp(co->name, "include") == 0) {
+        char *param = *(char **)data;
+        if (!param || !param[0])
+            return M_OPT_MISSING_PARAM;
+        if (config->recursion_depth >= MAX_RECURSION_DEPTH) {
+            MP_ERR(config, "Maximum 'include' nesting depth exceeded.\n");
+            return M_OPT_INVALID;
+        }
+        config->recursion_depth += 1;
+        config->includefunc(config->includefunc_ctx, param, flags);
+        config->recursion_depth -= 1;
+        if (config->recursion_depth == 0 && config->profile_depth == 0)
+            m_config_finish_default_profile(config, flags);
+        return 1;
+    }
+
+    if (config->use_profiles && strcmp(co->name, "show-profile") == 0)
+        return show_profile(config, bstr0(*(char **)data));
+
+    if (config->is_toplevel && (strcmp(co->name, "h") == 0 ||
+                                strcmp(co->name, "help") == 0))
+    {
+        char *h = *(char **)data;
+        mp_info(config->log, "%s", mp_help_text);
+        if (h && h[0])
+            m_config_print_option_list(config, h);
+        return M_OPT_EXIT;
+    }
+
+    if (strcmp(co->name, "list-options") == 0) {
+        m_config_print_option_list(config, "*");
+        return M_OPT_EXIT;
+    }
+
+    return M_OPT_UNKNOWN;
+}
+
+// This notification happens when anyone other than m_config->cache (i.e. not
+// through m_config_set_option_raw() or related) changes any options.
+static void async_change_cb(void *p)
+{
+    struct m_config *config = p;
+
+    void *ptr;
+    while (m_config_cache_get_next_changed(config->cache, &ptr)) {
+        // Regrettable linear search, might degenerate to quadratic.
+        for (int n = 0; n < config->num_opts; n++) {
+            struct m_config_option *co = &config->opts[n];
+            if (co->data == ptr) {
+                if (config->option_change_callback) {
+                    config->option_change_callback(
+                        config->option_change_callback_ctx, co,
+                        config->cache->change_flags, false);
+                }
+                break;
+            }
+        }
+        config->cache->change_flags = 0;
+    }
+}
+
+void m_config_set_update_dispatch_queue(struct m_config *config,
+                                        struct mp_dispatch_queue *dispatch)
+{
+    m_config_cache_set_dispatch_change_cb(config->cache, dispatch,
+                                          async_change_cb, config);
+}
+
+static void config_destroy(void *p)
+{
+    struct m_config *config = p;
+    config->option_change_callback = NULL;
+    m_config_restore_backups(config);
+
+    struct m_opt_backup **list = &config->watch_later_backup_opts;
+    while (*list) {
+        struct m_opt_backup *bc = *list;
+        *list = bc->next;
+        talloc_free(bc);
+    }
+
+    talloc_free(config->cache);
+    talloc_free(config->shadow);
+}
+
+struct m_config *m_config_new(void *talloc_ctx, struct mp_log *log,
+                              const struct m_sub_options *root)
+{
+    struct m_config *config = talloc(talloc_ctx, struct m_config);
+    talloc_set_destructor(config, config_destroy);
+    *config = (struct m_config){.log = log,};
+
+    config->shadow = m_config_shadow_new(root);
+
+    if (root->size) {
+        config->cache = m_config_cache_from_shadow(config, config->shadow, root);
+        config->optstruct = config->cache->opts;
+    }
+
+    int32_t optid = -1;
+    while (m_config_shadow_get_next_opt(config->shadow, &optid)) {
+        char buf[M_CONFIG_MAX_OPT_NAME_LEN];
+        const char *opt_name =
+            m_config_shadow_get_opt_name(config->shadow, optid, buf, sizeof(buf));
+
+        struct m_config_option co = {
+            .name = talloc_strdup(config, opt_name),
+            .opt = m_config_shadow_get_opt(config->shadow, optid),
+            .opt_id = optid,
+        };
+
+        if (config->cache)
+            co.data = m_config_cache_get_opt_data(config->cache, optid);
+
+        MP_TARRAY_APPEND(config, config->opts, config->num_opts, co);
+    }
+
+    return config;
+}
+
+// Normally m_config_cache will not send notifications when _we_ change our
+// own stuff. For whatever funny reasons, we need that, though.
+static void force_self_notify_change_opt(struct m_config *config,
+                                         struct m_config_option *co,
+                                         bool self_notification)
+{
+    int changed =
+        m_config_cache_get_option_change_mask(config->cache, co->opt_id);
+
+    if (config->option_change_callback) {
+        config->option_change_callback(config->option_change_callback_ctx, co,
+                                       changed, self_notification);
+    }
+}
+
+static void notify_opt(struct m_config *config, void *ptr, bool self_notification)
+{
+    for (int n = 0; n < config->num_opts; n++) {
+        struct m_config_option *co = &config->opts[n];
+        if (co->data == ptr) {
+            if (m_config_cache_write_opt(config->cache, co->data))
+                force_self_notify_change_opt(config, co, self_notification);
+            return;
+        }
+    }
+    // ptr doesn't point to any config->optstruct field declared in the
+    // option list?
+    assert(false);
+}
+
+void m_config_notify_change_opt_ptr(struct m_config *config, void *ptr)
+{
+    notify_opt(config, ptr, true);
+}
+
+void m_config_notify_change_opt_ptr_notify(struct m_config *config, void *ptr)
+{
+    // (the notify bool is inverted: by not marking it as self-notification,
+    // the mpctx option change handler actually applies it)
+    notify_opt(config, ptr, false);
+}
+
+int m_config_set_option_raw(struct m_config *config,
+                            struct m_config_option *co,
+                            void *data, int flags)
+{
+    if (!co)
+        return M_OPT_UNKNOWN;
+
+    int r = handle_set_opt_flags(config, co, flags);
+    if (r <= 1)
+        return r;
+
+    r = m_config_handle_special_options(config, co, data, flags);
+    if (r != M_OPT_UNKNOWN)
+        return r;
+
+    // This affects some special options like "playlist", "v". Maybe these
+    // should work, or maybe not. For now they would require special code.
+    if (!co->data)
+        return flags & M_SETOPT_FROM_CMDLINE ? 0 : M_OPT_UNKNOWN;
+
+    if (config->profile_backup_tmp)
+        ensure_backup(config->profile_backup_tmp, config->profile_backup_flags, co);
+
+    m_config_mark_co_flags(co, flags);
+
+    m_option_copy(co->opt, co->data, data);
+    if (m_config_cache_write_opt(config->cache, co->data))
+        force_self_notify_change_opt(config, co, false);
+
+    return 0;
+}
+
+// Handle CLI exceptions to option handling.
+// Used to turn "--no-foo" into "--foo=no".
+// It also handles looking up "--vf-add" as "--vf".
+static struct m_config_option *m_config_mogrify_cli_opt(struct m_config *config,
+                                                        struct bstr *name,
+                                                        bool *out_negate,
+                                                        int *out_add_flags)
+{
+    *out_negate = false;
+    *out_add_flags = 0;
+
+    struct m_config_option *co = m_config_get_co(config, *name);
+    if (co)
+        return co;
+
+    // Turn "--no-foo" into "foo" + set *out_negate.
+    bstr no_name = *name;
+    if (!co && bstr_eatstart0(&no_name, "no-")) {
+        co = m_config_get_co(config, no_name);
+
+        // Not all choice types have this value - if they don't, then parsing
+        // them will simply result in an error. Good enough.
+        if (!co || !(co->opt->type->flags & M_OPT_TYPE_CHOICE))
+            return NULL;
+
+        *name = no_name;
+        *out_negate = true;
+        return co;
+    }
+
+    // Resolve CLI alias. (We don't allow you to combine them with "--no-".)
+    co = m_config_get_co_any(config, *name);
+    if (co && co->opt->type == &m_option_type_cli_alias)
+        *name = bstr0((char *)co->opt->priv);
+
+    // Might be a suffix "action", like "--vf-add". Expensively check for
+    // matches. (We don't allow you to combine them with "--no-".)
+    for (int n = 0; n < config->num_opts; n++) {
+        co = &config->opts[n];
+        struct bstr basename = bstr0(co->name);
+
+        if (!bstr_startswith(*name, basename))
+            continue;
+
+        // Aliased option + a suffix action, e.g. --opengl-shaders-append
+        if (co->opt->type == &m_option_type_alias)
+            co = m_config_get_co_any(config, basename);
+        if (!co)
+            continue;
+
+        const struct m_option_type *type = co->opt->type;
+        for (int i = 0; type->actions && type->actions[i].name; i++) {
+            const struct m_option_action *action = &type->actions[i];
+            bstr suffix = bstr0(action->name);
+
+            if (bstr_endswith(*name, suffix) &&
+                (name->len == basename.len + 1 + suffix.len) &&
+                name->start[basename.len] == '-')
+            {
+                *out_add_flags = action->flags;
+                return co;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+int m_config_set_option_cli(struct m_config *config, struct bstr name,
+                            struct bstr param, int flags)
+{
+    int r;
+    assert(config != NULL);
+
+    bool negate;
+    struct m_config_option *co =
+        m_config_mogrify_cli_opt(config, &name, &negate, &(int){0});
+
+    if (!co) {
+        r = M_OPT_UNKNOWN;
+        goto done;
+    }
+
+    if (negate) {
+        if (param.len) {
+            r = M_OPT_DISALLOW_PARAM;
+            goto done;
+        }
+
+        param = bstr0("no");
+    }
+
+    // This is the only mandatory function
+    assert(co->opt->type->parse);
+
+    r = handle_set_opt_flags(config, co, flags);
+    if (r <= 0)
+        goto done;
+
+    if (r == 2) {
+        MP_VERBOSE(config, "Setting option '%.*s' = '%.*s' (flags = %d)\n",
+                   BSTR_P(name), BSTR_P(param), flags);
+    }
+
+    union m_option_value val = m_option_value_default;
+
+    // Some option types are "impure" and work on the existing data.
+    // (Prime examples: --vf-add, --sub-file)
+    if (co->data)
+        m_option_copy(co->opt, &val, co->data);
+
+    r = m_option_parse(config->log, co->opt, name, param, &val);
+
+    if (r >= 0)
+        r = m_config_set_option_raw(config, co, &val, flags);
+
+    m_option_free(co->opt, &val);
+
+done:
+    if (r < 0 && r != M_OPT_EXIT) {
+        MP_ERR(config, "Error parsing option %.*s (%s)\n",
+               BSTR_P(name), m_option_strerror(r));
+        r = M_OPT_INVALID;
+    }
+    return r;
+}
+
+int m_config_set_option_node(struct m_config *config, bstr name,
+                             struct mpv_node *data, int flags)
+{
+    int r;
+
+    struct m_config_option *co = m_config_get_co(config, name);
+    if (!co)
+        return M_OPT_UNKNOWN;
+
+    // Do this on an "empty" type to make setting the option strictly overwrite
+    // the old value, as opposed to e.g. appending to lists.
+    union m_option_value val = m_option_value_default;
+
+    if (data->format == MPV_FORMAT_STRING) {
+        bstr param = bstr0(data->u.string);
+        r = m_option_parse(mp_null_log, co->opt, name, param, &val);
+    } else {
+        r = m_option_set_node(co->opt, &val, data);
+    }
+
+    if (r >= 0)
+        r = m_config_set_option_raw(config, co, &val, flags);
+
+    if (mp_msg_test(config->log, MSGL_V)) {
+        char *s = m_option_type_node.print(NULL, data);
+        MP_DBG(config, "Setting option '%.*s' = %s (flags = %d) -> %d\n",
+               BSTR_P(name), s ? s : "?", flags, r);
+        talloc_free(s);
+    }
+
+    m_option_free(co->opt, &val);
+    return r;
+}
+
+int m_config_option_requires_param(struct m_config *config, bstr name)
+{
+    bool negate;
+    int flags;
+    struct m_config_option *co =
+        m_config_mogrify_cli_opt(config, &name, &negate, &flags);
+
+    if (!co)
+        return M_OPT_UNKNOWN;
+
+    if (negate || (flags & M_OPT_TYPE_OPTIONAL_PARAM))
+        return 0;
+
+    return m_option_required_params(co->opt);
+}
+
+static int sort_opt_compare(const void *pa, const void *pb)
+{
+    const struct m_config_option *a = pa;
+    const struct m_config_option *b = pb;
+    return strcasecmp(a->name, b->name);
+}
+
+void m_config_print_option_list(const struct m_config *config, const char *name)
+{
+    char min[50], max[50];
+    int count = 0;
+    const char *prefix = config->is_toplevel ? "--" : "";
+
+    struct m_config_option *sorted =
+        talloc_memdup(NULL, config->opts, config->num_opts * sizeof(sorted[0]));
+    if (config->is_toplevel)
+        qsort(sorted, config->num_opts, sizeof(sorted[0]), sort_opt_compare);
+
+    MP_INFO(config, "Options:\n\n");
+    for (int i = 0; i < config->num_opts; i++) {
+        struct m_config_option *co = &sorted[i];
+        const struct m_option *opt = co->opt;
+        if (strcmp(name, "*") != 0 && !strstr(co->name, name))
+            continue;
+        MP_INFO(config, " %s%-30s", prefix, co->name);
+        if (opt->type == &m_option_type_choice) {
+            MP_INFO(config, " Choices:");
+            const struct m_opt_choice_alternatives *alt = opt->priv;
+            for (int n = 0; alt[n].name; n++)
+                MP_INFO(config, " %s", alt[n].name);
+            if (opt->min < opt->max)
+                MP_INFO(config, " (or an integer)");
+        } else {
+            MP_INFO(config, " %s", opt->type->name);
+        }
+        if ((opt->type->flags & M_OPT_TYPE_USES_RANGE) && opt->min < opt->max) {
+            snprintf(min, sizeof(min), "any");
+            snprintf(max, sizeof(max), "any");
+            if (opt->min != DBL_MIN)
+                snprintf(min, sizeof(min), "%.14g", opt->min);
+            if (opt->max != DBL_MAX)
+                snprintf(max, sizeof(max), "%.14g", opt->max);
+            MP_INFO(config, " (%s to %s)", min, max);
+        }
+        char *def = NULL;
+        const void *defptr = m_config_get_co_default(config, co);
+        if (!defptr)
+            defptr = &m_option_value_default;
+        if (defptr)
+            def = m_option_pretty_print(opt, defptr);
+        if (def) {
+            MP_INFO(config, " (default: %s)", def);
+            talloc_free(def);
+        }
+        if (opt->flags & M_OPT_NOCFG)
+            MP_INFO(config, " [not in config files]");
+        if (opt->flags & M_OPT_FILE)
+            MP_INFO(config, " [file]");
+        if (opt->deprecation_message)
+            MP_INFO(config, " [deprecated]");
+        if (opt->type == &m_option_type_alias)
+            MP_INFO(config, " for %s", (char *)opt->priv);
+        if (opt->type == &m_option_type_cli_alias)
+            MP_INFO(config, " for --%s (CLI/config files only)", (char *)opt->priv);
+        MP_INFO(config, "\n");
+        for (int n = 0; opt->type->actions && opt->type->actions[n].name; n++) {
+            const struct m_option_action *action = &opt->type->actions[n];
+            MP_INFO(config, "    %s%s-%s\n", prefix, co->name, action->name);
+            count++;
+        }
+        count++;
+    }
+    MP_INFO(config, "\nTotal: %d options\n", count);
+    talloc_free(sorted);
+}
+
+char **m_config_list_options(void *ta_parent, const struct m_config *config)
+{
+    char **list = talloc_new(ta_parent);
+    int count = 0;
+    for (int i = 0; i < config->num_opts; i++) {
+        struct m_config_option *co = &config->opts[i];
+        // For use with CONF_TYPE_STRING_LIST, it's important not to set list
+        // as allocation parent.
+        char *s = talloc_strdup(ta_parent, co->name);
+        MP_TARRAY_APPEND(ta_parent, list, count, s);
+    }
+    MP_TARRAY_APPEND(ta_parent, list, count, NULL);
+    return list;
+}
+
+struct m_profile *m_config_get_profile(const struct m_config *config, bstr name)
+{
+    for (struct m_profile *p = config->profiles; p; p = p->next) {
+        if (bstr_equals0(name, p->name))
+            return p;
+    }
+    return NULL;
+}
+
+struct m_profile *m_config_get_profile0(const struct m_config *config,
+                                        char *name)
+{
+    return m_config_get_profile(config, bstr0(name));
+}
+
+struct m_profile *m_config_add_profile(struct m_config *config, char *name)
+{
+    if (!name || !name[0])
+        name = "default";
+    struct m_profile *p = m_config_get_profile0(config, name);
+    if (p)
+        return p;
+    p = talloc_zero(config, struct m_profile);
+    p->name = talloc_strdup(p, name);
+    p->next = config->profiles;
+    config->profiles = p;
+    return p;
+}
+
+int m_config_set_profile_option(struct m_config *config, struct m_profile *p,
+                                bstr name, bstr val)
+{
+    if (bstr_equals0(name, "profile-desc")) {
+        talloc_free(p->desc);
+        p->desc = bstrto0(p, val);
+        return 0;
+    }
+    if (bstr_equals0(name, "profile-cond")) {
+        TA_FREEP(&p->cond);
+        val = bstr_strip(val);
+        if (val.len)
+            p->cond = bstrto0(p, val);
+        return 0;
+    }
+    if (bstr_equals0(name, profile_restore_mode_opt.name)) {
+        return m_option_parse(config->log, &profile_restore_mode_opt, name, val,
+                              &p->restore_mode);
+    }
+
+    int i = m_config_set_option_cli(config, name, val,
+                                    M_SETOPT_CHECK_ONLY |
+                                    M_SETOPT_FROM_CONFIG_FILE);
+    if (i < 0)
+        return i;
+    p->opts = talloc_realloc(p, p->opts, char *, 2 * (p->num_opts + 2));
+    p->opts[p->num_opts * 2] = bstrto0(p, name);
+    p->opts[p->num_opts * 2 + 1] = bstrto0(p, val);
+    p->num_opts++;
+    p->opts[p->num_opts * 2] = p->opts[p->num_opts * 2 + 1] = NULL;
+    return 1;
+}
+
+static struct m_profile *find_check_profile(struct m_config *config, char *name)
+{
+    struct m_profile *p = m_config_get_profile0(config, name);
+    if (!p) {
+        MP_WARN(config, "Unknown profile '%s'.\n", name);
+        return NULL;
+    }
+    if (config->profile_depth > MAX_PROFILE_DEPTH) {
+        MP_WARN(config, "WARNING: Profile inclusion too deep.\n");
+        return NULL;
+    }
+    return p;
+}
+
+int m_config_set_profile(struct m_config *config, char *name, int flags)
+{
+    MP_VERBOSE(config, "Applying profile '%s'...\n", name);
+    struct m_profile *p = find_check_profile(config, name);
+    if (!p)
+        return M_OPT_INVALID;
+
+    if (!config->profile_backup_tmp && p->restore_mode) {
+        config->profile_backup_tmp = &p->backups;
+        config->profile_backup_flags = p->restore_mode == 2 ? BACKUP_NVAL : 0;
+    }
+
+    config->profile_depth++;
+    for (int i = 0; i < p->num_opts; i++) {
+        m_config_set_option_cli(config,
+                                bstr0(p->opts[2 * i]),
+                                bstr0(p->opts[2 * i + 1]),
+                                flags | M_SETOPT_FROM_CONFIG_FILE);
+    }
+    config->profile_depth--;
+
+    if (config->profile_backup_tmp == &p->backups) {
+        config->profile_backup_tmp = NULL;
+
+        for (struct m_opt_backup *bc = p->backups; bc; bc = bc->next) {
+            if (bc && bc->nval)
+                m_option_copy(bc->co->opt, bc->nval, bc->co->data);
+            talloc_steal(p, bc);
+        }
+    }
+
+    return 0;
+}
+
+int m_config_restore_profile(struct m_config *config, char *name)
+{
+    MP_VERBOSE(config, "Restoring from profile '%s'...\n", name);
+    struct m_profile *p = find_check_profile(config, name);
+    if (!p)
+        return M_OPT_INVALID;
+
+    if (!p->backups)
+        MP_WARN(config, "Profile '%s' contains no restore data.\n", name);
+
+    restore_backups(&p->backups, config);
+
+    return 0;
+}
+
+void m_config_finish_default_profile(struct m_config *config, int flags)
+{
+    struct m_profile *p = m_config_add_profile(config, NULL);
+    m_config_set_profile(config, p->name, flags);
+    p->num_opts = 0;
+}
+
+struct mpv_node m_config_get_profiles(struct m_config *config)
+{
+    struct mpv_node root;
+    node_init(&root, MPV_FORMAT_NODE_ARRAY, NULL);
+
+    for (m_profile_t *profile = config->profiles; profile; profile = profile->next)
+    {
+        struct mpv_node *entry = node_array_add(&root, MPV_FORMAT_NODE_MAP);
+
+        node_map_add_string(entry, "name", profile->name);
+        if (profile->desc)
+            node_map_add_string(entry, "profile-desc", profile->desc);
+        if (profile->cond)
+            node_map_add_string(entry, "profile-cond", profile->cond);
+        if (profile->restore_mode) {
+            char *s =
+                m_option_print(&profile_restore_mode_opt, &profile->restore_mode);
+            node_map_add_string(entry, profile_restore_mode_opt.name, s);
+            talloc_free(s);
+        }
+
+        struct mpv_node *opts =
+            node_map_add(entry, "options", MPV_FORMAT_NODE_ARRAY);
+
+        for (int n = 0; n < profile->num_opts; n++) {
+            struct mpv_node *opt_entry = node_array_add(opts, MPV_FORMAT_NODE_MAP);
+            node_map_add_string(opt_entry, "key", profile->opts[n * 2 + 0]);
+            node_map_add_string(opt_entry, "value", profile->opts[n * 2 + 1]);
+        }
+    }
+
+    return root;
+}
diff --git a/options/m_config_frontend.h b/options/m_config_frontend.h
new file mode 100644
index 0000000..6108d9f
--- /dev/null
+++ b/options/m_config_frontend.h
@@ -0,0 +1,266 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "common/common.h"
+#include "common/global.h"
+#include "common/msg.h"
+#include "common/msg_control.h"
+#include "m_config_core.h"
+#include "misc/bstr.h"
+#include "misc/dispatch.h"
+#include "options/m_option.h"
+
+// m_config provides an API to manipulate the config variables in MPlayer.
+// It makes use of the Options API to provide a context stack that
+// allows saving and later restoring the state of all variables.
+
+typedef struct m_profile m_profile_t;
+struct m_option;
+struct m_option_type;
+struct m_sub_options;
+struct m_obj_desc;
+struct m_obj_settings;
+struct mp_log;
+struct mp_dispatch_queue;
+
+// Config option
+struct m_config_option {
+    bool is_set_from_cmdline : 1;   // Set by user from command line
+    bool is_set_from_config : 1;    // Set by a config file
+    bool is_set_locally : 1;        // Has a backup entry
+    bool warning_was_printed : 1;
+    int32_t opt_id;                 // For some m_config APIs
+    const char *name;               // Full name (ie option-subopt)
+    const struct m_option *opt;     // Option description
+    void *data;                     // Raw value of the option
+};
+
+// Config object
+/** \ingroup Config */
+typedef struct m_config {
+    struct mp_log *log;
+    struct mpv_global *global; // can be NULL
+
+    // Registered options.
+    struct m_config_option *opts; // all options, even suboptions
+    int num_opts;
+
+    // List of defined profiles.
+    struct m_profile *profiles;
+    // Depth when recursively including profiles.
+    int profile_depth;
+    // Temporary during profile application.
+    struct m_opt_backup **profile_backup_tmp;
+    int profile_backup_flags;
+
+    struct m_opt_backup *backup_opts;
+    struct m_opt_backup *watch_later_backup_opts;
+
+    bool use_profiles;
+    bool is_toplevel;
+    int (*includefunc)(void *ctx, char *filename, int flags);
+    void *includefunc_ctx;
+
+    // Notification after an option was successfully written to.
+    // Uses flags as set in UPDATE_OPTS_MASK.
+    // self_update==true means the update was caused by a call to
+    // m_config_notify_change_opt_ptr(). If false, it's caused either by
+    // m_config_set_option_*() (and similar) calls or external updates.
+    void (*option_change_callback)(void *ctx, struct m_config_option *co,
+                                   int flags, bool self_update);
+    void *option_change_callback_ctx;
+
+    // For the command line parser
+    int recursion_depth;
+
+    void *optstruct; // struct mpopts or other
+
+    // Private. Non-NULL if data was allocated. m_config_option.data uses it.
+    // API users call m_config_set_update_dispatch_queue() to get async updates.
+    struct m_config_cache *cache;
+
+    // Private. Thread-safe shadow memory; only set for the main m_config.
+    struct m_config_shadow *shadow;
+} m_config_t;
+
+// Create a new config object.
+//  talloc_ctx: talloc parent context for the m_config allocation
+//  root: description of all options
+// Note that the m_config object will keep pointers to root and log.
+struct m_config *m_config_new(void *talloc_ctx, struct mp_log *log,
+                              const struct m_sub_options *root);
+
+// Create a m_config for the given desc. This is for --af/--vf, which have
+// different sub-options for every filter (represented by separate desc
+// structs).
+// args is an array of key/value pairs (args=[k0, v0, k1, v1, ..., NULL]).
+struct m_config *m_config_from_obj_desc_and_args(void *ta_parent,
+    struct mp_log *log, struct mpv_global *global, struct m_obj_desc *desc,
+    char **args);
+
+// Like m_config_from_obj_desc_and_args(), but don't allocate option the
+// struct, i.e. m_config.optstruct==NULL. This is used by the sub-option
+// parser (--af/--vf, to a lesser degree --ao/--vo) to check sub-option names
+// and types.
+struct m_config *m_config_from_obj_desc_noalloc(void *talloc_ctx,
+                                                struct mp_log *log,
+                                                struct m_obj_desc *desc);
+
+// Make sure the option is backed up. If it's already backed up, do nothing.
+// All backed up options can be restored with m_config_restore_backups().
+void m_config_backup_opt(struct m_config *config, const char *opt);
+
+// Call m_config_backup_opt() on all options.
+void m_config_backup_all_opts(struct m_config *config);
+
+// Backup options on startup so that quit-watch-later can compare the current
+// values to their backups, and save them only if they have been changed.
+void m_config_backup_watch_later_opts(struct m_config *config);
+
+// Restore all options backed up with m_config_backup_opt(), and delete the
+// backups afterwards.
+void m_config_restore_backups(struct m_config *config);
+
+// Whether opt_name is different from its initial value.
+bool m_config_watch_later_backup_opt_changed(struct m_config *config,
+                                             char *opt_name);
+
+enum {
+    M_SETOPT_PRE_PARSE_ONLY = 1,    // Silently ignore non-M_OPT_PRE_PARSE opt.
+    M_SETOPT_CHECK_ONLY = 2,        // Don't set, just check name/value
+    M_SETOPT_FROM_CONFIG_FILE = 4,  // Reject M_OPT_NOCFG opt. (print error)
+    M_SETOPT_FROM_CMDLINE = 8,      // Mark as set by command line
+    M_SETOPT_BACKUP = 16,           // Call m_config_backup_opt() before
+    M_SETOPT_PRESERVE_CMDLINE = 32, // Don't set if already marked as FROM_CMDLINE
+    M_SETOPT_NO_PRE_PARSE = 128,    // Reject M_OPT_PREPARSE options
+    M_SETOPT_NO_OVERWRITE = 256,    // Skip options marked with FROM_*
+};
+
+// Set the named option to the given string. This is for command line and config
+// file use only.
+// flags: combination of M_SETOPT_* flags (0 for normal operation)
+// Returns >= 0 on success, otherwise see OptionParserReturn.
+int m_config_set_option_cli(struct m_config *config, struct bstr name,
+                            struct bstr param, int flags);
+
+// Similar to m_config_set_option_cli(), but set as data in its native format.
+// This takes care of some details like sending change notifications.
+// The type data points to is as in: co->opt
+int m_config_set_option_raw(struct m_config *config, struct m_config_option *co,
+                            void *data, int flags);
+
+void m_config_mark_co_flags(struct m_config_option *co, int flags);
+
+// Convert the mpv_node to raw option data, then call m_config_set_option_raw().
+struct mpv_node;
+int m_config_set_option_node(struct m_config *config, bstr name,
+                             struct mpv_node *data, int flags);
+
+// Return option descriptor. You shouldn't use this.
+struct m_config_option *m_config_get_co(const struct m_config *config,
+                                        struct bstr name);
+// Same as above, but does not resolve aliases or trigger warning messages.
+struct m_config_option *m_config_get_co_raw(const struct m_config *config,
+                                            struct bstr name);
+
+// Special uses only. Look away.
+int m_config_get_co_count(struct m_config *config);
+struct m_config_option *m_config_get_co_index(struct m_config *config, int index);
+const void *m_config_get_co_default(const struct m_config *config,
+                                    struct m_config_option *co);
+
+// Return the n-th option by position. n==0 is the first option. If there are
+// less than (n + 1) options, return NULL.
+const char *m_config_get_positional_option(const struct m_config *config, int n);
+
+// Return a hint to the option parser whether a parameter is/may be required.
+// The option may still accept empty/non-empty parameters independent from
+// this, and this function is useful only for handling ambiguous options like
+// flags (e.g. "--a" is ok, "--a=yes" is also ok).
+// Returns: error code (<0), or number of expected params (0, 1)
+int m_config_option_requires_param(struct m_config *config, bstr name);
+
+// Notify m_config_cache users that the option has (probably) changed its value.
+// This will force a self-notification back to config->option_change_callback.
+void m_config_notify_change_opt_ptr(struct m_config *config, void *ptr);
+
+// Exactly like m_config_notify_change_opt_ptr(), but the option change callback
+// (config->option_change_callback()) is invoked with self_update=false, if at all.
+void m_config_notify_change_opt_ptr_notify(struct m_config *config, void *ptr);
+
+// Return all (visible) option names as NULL terminated string list.
+char **m_config_list_options(void *ta_parent, const struct m_config *config);
+
+void m_config_print_option_list(const struct m_config *config, const char *name);
+
+
+/*  Find the profile with the given name.
+ *  \param config The config object.
+ *  \param arg The profile's name.
+ *  \return The profile object or NULL.
+ */
+struct m_profile *m_config_get_profile0(const struct m_config *config,
+                                        char *name);
+struct m_profile *m_config_get_profile(const struct m_config *config, bstr name);
+
+// Apply and clear the default profile - it's the only profile that new config
+// files do not simply append to (for configfile parser).
+void m_config_finish_default_profile(struct m_config *config, int flags);
+
+/*  Get the profile with the given name, creating it if necessary.
+ *  \param config The config object.
+ *  \param arg The profile's name.
+ *  \return The profile object.
+ */
+struct m_profile *m_config_add_profile(struct m_config *config, char *name);
+
+/*  Add an option to a profile.
+ *  Used by the config file parser when defining a profile.
+ *
+ *  \param config The config object.
+ *  \param p The profile object.
+ *  \param name The option's name.
+ *  \param val The option's value.
+ */
+int m_config_set_profile_option(struct m_config *config, struct m_profile *p,
+                                bstr name, bstr val);
+
+/*  Enables profile usage
+ *  Used by the config file parser when loading a profile.
+ *
+ *  \param config The config object.
+ *  \param p The profile object.
+ *  \param flags M_SETOPT_* bits
+ * Returns error code (<0) or 0 on success
+ */
+int m_config_set_profile(struct m_config *config, char *name, int flags);
+
+// Attempt to "unset" a profile if possible.
+int m_config_restore_profile(struct m_config *config, char *name);
+
+struct mpv_node m_config_get_profiles(struct m_config *config);
+
+// Run async option updates here. This will call option_change_callback() on it.
+void m_config_set_update_dispatch_queue(struct m_config *config,
+                                        struct mp_dispatch_queue *dispatch);
diff --git a/options/m_option.c b/options/m_option.c
new file mode 100644
index 0000000..1b1ac0a
--- /dev/null
+++ b/options/m_option.c
@@ -0,0 +1,3866 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/// \file
+/// \ingroup Options
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <libavutil/common.h>
+
+#include "libmpv/client.h"
+#include "player/client.h"
+
+#include "mpv_talloc.h"
+#include "common/common.h"
+#include "common/msg.h"
+#include "common/msg_control.h"
+#include "misc/json.h"
+#include "misc/node.h"
+#include "m_option.h"
+#include "m_config_frontend.h"
+
+#if HAVE_DOS_PATHS
+#define OPTION_PATH_SEPARATOR ';'
+#else
+#define OPTION_PATH_SEPARATOR ':'
+#endif
+
+const char m_option_path_separator = OPTION_PATH_SEPARATOR;
+
+// For integer types: since min/max are floats and may not be able to represent
+// the real min/max, and since opt.min/.max may use +/-INFINITY, some care has
+// to be taken. (Also tricky rounding.)
+#define OPT_INT_MIN(opt, T, Tm) ((opt)->min < (opt)->max \
+    ? ((opt)->min <= (double)(Tm) ? (Tm) : (T)((opt)->min)) : (Tm))
+#define OPT_INT_MAX(opt, T, Tm) ((opt)->min < (opt)->max \
+    ? ((opt)->max >= (double)(Tm) ? (Tm) : (T)((opt)->max)) : (Tm))
+
+int m_option_parse(struct mp_log *log, const m_option_t *opt,
+                   struct bstr name, struct bstr param, void *dst)
+{
+    int r = M_OPT_INVALID;
+    if (bstr_equals0(param, "help") && opt->help) {
+        r = opt->help(log, opt, name);
+        if (r < 0)
+            return r;
+    }
+
+    r = opt->type->parse(log, opt, name, param, dst);
+    if (r < 0)
+        return r;
+
+    if (opt->validate) {
+        r = opt->validate(log, opt, name, dst);
+        if (r < 0) {
+            if (opt->type->free)
+                opt->type->free(dst);
+            return r;
+        }
+    }
+    return 1;
+}
+
+char *m_option_strerror(int code)
+{
+    switch (code) {
+    case M_OPT_UNKNOWN:
+        return "option not found";
+    case M_OPT_MISSING_PARAM:
+        return "option requires parameter";
+    case M_OPT_INVALID:
+        return "option parameter could not be parsed";
+    case M_OPT_OUT_OF_RANGE:
+        return "parameter is outside values allowed for option";
+    case M_OPT_DISALLOW_PARAM:
+        return "option doesn't take a parameter";
+    default:
+        return "parser error";
+    }
+}
+
+int m_option_required_params(const m_option_t *opt)
+{
+    if (opt->type->flags & M_OPT_TYPE_OPTIONAL_PARAM)
+        return 0;
+    if (opt->flags & M_OPT_OPTIONAL_PARAM)
+        return 0;
+    if (opt->type == &m_option_type_choice) {
+        const struct m_opt_choice_alternatives *alt;
+        for (alt = opt->priv; alt->name; alt++) {
+            if (strcmp(alt->name, "yes") == 0)
+                return 0;
+        }
+    }
+    return 1;
+}
+
+int m_option_set_node_or_string(struct mp_log *log, const m_option_t *opt,
+                                const char *name, void *dst, struct mpv_node *src)
+{
+    if (src->format == MPV_FORMAT_STRING) {
+        // The af and vf option unfortunately require this, because the
+        // option name includes the "action".
+        bstr optname = bstr0(name), a, b;
+        if (bstr_split_tok(optname, "/", &a, &b))
+            optname = b;
+        return m_option_parse(log, opt, optname, bstr0(src->u.string), dst);
+    } else {
+        return m_option_set_node(opt, dst, src);
+    }
+}
+
+// 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);
+}
+
+// Bool
+
+#define VAL(x) (*(bool *)(x))
+
+static int parse_bool(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    if (bstr_equals0(param, "yes") || !param.len) {
+        if (dst)
+            VAL(dst) = 1;
+        return 1;
+    }
+    if (bstr_equals0(param, "no")) {
+        if (dst)
+            VAL(dst) = 0;
+        return 1;
+    }
+    bool is_help = bstr_equals0(param, "help");
+    if (is_help) {
+        mp_info(log, "Valid values for %.*s flag are:\n", BSTR_P(name));
+    } else {
+        mp_fatal(log, "Invalid parameter for %.*s flag: %.*s\n",
+                 BSTR_P(name), BSTR_P(param));
+        mp_info(log, "Valid values are:\n");
+    }
+    mp_info(log, "    yes\n");
+    mp_info(log, "    no\n");
+    mp_info(log, "    (passing nothing)\n");
+    return is_help ? M_OPT_EXIT : M_OPT_INVALID;
+}
+
+static char *print_bool(const m_option_t *opt, const void *val)
+{
+    return talloc_strdup(NULL, VAL(val) ? "yes" : "no");
+}
+
+static void add_bool(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    if (fabs(add) < 0.5)
+        return;
+    bool state = !!VAL(val);
+    state = wrap ? !state : add > 0;
+    VAL(val) = state ? 1 : 0;
+}
+
+static int bool_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_FLAG)
+        return M_OPT_UNKNOWN;
+    VAL(dst) = !!src->u.flag;
+    return 1;
+}
+
+static int bool_get(const m_option_t *opt, void *ta_parent,
+                    struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_FLAG;
+    dst->u.flag = !!VAL(src);
+    return 1;
+}
+
+static bool bool_equal(const m_option_t *opt, void *a, void *b)
+{
+    return VAL(a) == VAL(b);
+}
+
+const m_option_type_t m_option_type_bool = {
+    .name  = "Flag", // same as m_option_type_flag; transparent to user
+    .size  = sizeof(bool),
+    .flags = M_OPT_TYPE_OPTIONAL_PARAM | M_OPT_TYPE_CHOICE,
+    .parse = parse_bool,
+    .print = print_bool,
+    .copy  = copy_opt,
+    .add   = add_bool,
+    .set   = bool_set,
+    .get   = bool_get,
+    .equal = bool_equal,
+};
+
+#undef VAL
+
+// Flag
+
+#define VAL(x) (*(int *)(x))
+
+static int parse_flag(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    bool bdst = false;
+    int r = parse_bool(log, opt, name, param, &bdst);
+    if (dst)
+        VAL(dst) = bdst;
+    return r;
+}
+
+static char *print_flag(const m_option_t *opt, const void *val)
+{
+    return print_bool(opt, &(bool){VAL(val)});
+}
+
+static void add_flag(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    bool bval = VAL(val);
+    add_bool(opt, &bval, add, wrap);
+    VAL(val) = bval;
+}
+
+static int flag_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    bool bdst = false;
+    int r = bool_set(opt, &bdst, src);
+    if (r >= 0)
+        VAL(dst) = bdst;
+    return r;
+}
+
+static int flag_get(const m_option_t *opt, void *ta_parent,
+                    struct mpv_node *dst, void *src)
+{
+    return bool_get(opt, ta_parent, dst, &(bool){VAL(src)});
+}
+
+static bool flag_equal(const m_option_t *opt, void *a, void *b)
+{
+    return VAL(a) == VAL(b);
+}
+
+// Only exists for libmpv interopability and should not be used anywhere.
+const m_option_type_t m_option_type_flag = {
+    // need yes or no in config files
+    .name  = "Flag",
+    .size  = sizeof(int),
+    .flags = M_OPT_TYPE_OPTIONAL_PARAM | M_OPT_TYPE_CHOICE,
+    .parse = parse_flag,
+    .print = print_flag,
+    .copy  = copy_opt,
+    .add   = add_flag,
+    .set   = flag_set,
+    .get   = flag_get,
+    .equal = flag_equal,
+};
+
+// Integer
+
+#undef VAL
+
+static int clamp_longlong(const m_option_t *opt, long long i_min, long long i_max,
+                          void *val)
+{
+    long long v = *(long long *)val;
+    int r = 0;
+    long long min = OPT_INT_MIN(opt, long long, i_min);
+    long long max = OPT_INT_MAX(opt, long long, i_max);
+    if (v > max) {
+        v = max;
+        r = M_OPT_OUT_OF_RANGE;
+    }
+    if (v < min) {
+        v = min;
+        r = M_OPT_OUT_OF_RANGE;
+    }
+    *(long long *)val = v;
+    return r;
+}
+
+static int parse_longlong(struct mp_log *log, const m_option_t *opt,
+                          long long i_min, long long i_max,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    struct bstr rest;
+    long long tmp_int = bstrtoll(param, &rest, 10);
+    if (rest.len)
+        tmp_int = bstrtoll(param, &rest, 0);
+    if (rest.len) {
+        mp_err(log, "The %.*s option must be an integer: %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_INVALID;
+    }
+
+    long long min = OPT_INT_MIN(opt, long long, i_min);
+    if (tmp_int < min) {
+        mp_err(log, "The %.*s option must be >= %lld: %.*s\n",
+               BSTR_P(name), min, BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    long long max = OPT_INT_MAX(opt, long long, i_max);
+    if (tmp_int > max) {
+        mp_err(log, "The %.*s option must be <= %lld: %.*s\n",
+               BSTR_P(name), max, BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    if (dst)
+        *(long long *)dst = tmp_int;
+
+    return 1;
+}
+
+static int clamp_int64(const m_option_t *opt, void *val)
+{
+    long long tmp = *(int64_t *)val;
+    int r = clamp_longlong(opt, INT64_MIN, INT64_MAX, &tmp);
+    *(int64_t *)val = tmp;
+    return r;
+}
+
+static int parse_int(struct mp_log *log, const m_option_t *opt,
+                     struct bstr name, struct bstr param, void *dst)
+{
+    long long tmp;
+    int r = parse_longlong(log, opt, INT_MIN, INT_MAX, name, param, &tmp);
+    if (r >= 0 && dst)
+        *(int *)dst = tmp;
+    return r;
+}
+
+static int parse_int64(struct mp_log *log, const m_option_t *opt,
+                       struct bstr name, struct bstr param, void *dst)
+{
+    long long tmp;
+    int r = parse_longlong(log, opt, INT64_MIN, INT64_MAX, name, param, &tmp);
+    if (r >= 0 && dst)
+        *(int64_t *)dst = tmp;
+    return r;
+}
+
+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", *(const int *)val);
+}
+
+static void add_int64(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    int64_t v = *(int64_t *)val;
+
+    clamp_int64(opt, &v);
+
+    v = v + add;
+
+    bool is64 = opt->type->size == sizeof(int64_t);
+    int64_t nmin = is64 ? INT64_MIN : INT_MIN;
+    int64_t nmax = is64 ? INT64_MAX : INT_MAX;
+
+    int64_t min = OPT_INT_MIN(opt, int64_t, nmin);
+    int64_t max = OPT_INT_MAX(opt, int64_t, nmax);
+
+    if (v < min)
+        v = wrap ? max : min;
+    if (v > max)
+        v = wrap ? min : max;
+
+    *(int64_t *)val = v;
+}
+
+static void add_int(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    int64_t tmp = *(int *)val;
+    add_int64(opt, &tmp, add, wrap);
+    *(int *)val = tmp;
+}
+
+static void multiply_int64(const m_option_t *opt, void *val, double f)
+{
+    double v = *(int64_t *)val * f;
+    int64_t iv = v;
+    if (v < INT64_MIN)
+        iv = INT64_MIN;
+    if (v >= (double)INT64_MAX)
+        iv = INT64_MAX;
+    *(int64_t *)val = iv;
+    clamp_int64(opt, val);
+}
+
+static void multiply_int(const m_option_t *opt, void *val, double f)
+{
+    int64_t tmp = *(int *)val;
+    multiply_int64(opt, &tmp, f);
+    *(int *)val = MPCLAMP(tmp, INT_MIN, INT_MAX);
+}
+
+static int int64_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_INT64)
+        return M_OPT_UNKNOWN;
+    int64_t val = src->u.int64;
+    if (val < OPT_INT_MIN(opt, int64_t, INT64_MIN))
+        return M_OPT_OUT_OF_RANGE;
+    if (val > OPT_INT_MAX(opt, int64_t, INT64_MAX))
+        return M_OPT_OUT_OF_RANGE;
+    *(int64_t *)dst = val;
+    return 1;
+}
+
+static int int_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    int64_t val;
+    int r = int64_set(opt, &val, src);
+    if (r >= 0) {
+        if (val < INT_MIN || val > INT_MAX)
+            return M_OPT_OUT_OF_RANGE;
+        *(int *)dst = val;
+    }
+    return r;
+}
+
+static int int64_get(const m_option_t *opt, void *ta_parent,
+                     struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_INT64;
+    dst->u.int64 = *(int64_t *)src;
+    return 1;
+}
+
+static int int_get(const m_option_t *opt, void *ta_parent,
+                   struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_INT64;
+    dst->u.int64 = *(int *)src;
+    return 1;
+}
+
+static bool int_equal(const m_option_t *opt, void *a, void *b)
+{
+    return *(int *)a == *(int *)b;
+}
+
+static bool int64_equal(const m_option_t *opt, void *a, void *b)
+{
+    return *(int64_t *)a == *(int64_t *)b;
+}
+
+const m_option_type_t m_option_type_int = {
+    .name  = "Integer",
+    .flags = M_OPT_TYPE_USES_RANGE,
+    .size  = sizeof(int),
+    .parse = parse_int,
+    .print = print_int,
+    .copy  = copy_opt,
+    .add = add_int,
+    .multiply = multiply_int,
+    .set   = int_set,
+    .get   = int_get,
+    .equal = int_equal,
+};
+
+const m_option_type_t m_option_type_int64 = {
+    .name  = "Integer64",
+    .flags = M_OPT_TYPE_USES_RANGE,
+    .size  = sizeof(int64_t),
+    .parse = parse_int64,
+    .print = print_int,
+    .copy  = copy_opt,
+    .add = add_int64,
+    .multiply = multiply_int64,
+    .set   = int64_set,
+    .get   = int64_get,
+    .equal = int64_equal,
+};
+
+static int parse_byte_size(struct mp_log *log, const m_option_t *opt,
+                           struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    struct bstr r;
+    long long tmp_int = bstrtoll(param, &r, 0);
+    int64_t unit = 1;
+    if (r.len) {
+        if (bstrcasecmp0(r, "b") == 0) {
+            unit = 1;
+        } else if (bstrcasecmp0(r, "kib") == 0 || bstrcasecmp0(r, "k") == 0) {
+            unit = 1024;
+        } else if (bstrcasecmp0(r, "mib") == 0 || bstrcasecmp0(r, "m") == 0) {
+            unit = 1024 * 1024;
+        } else if (bstrcasecmp0(r, "gib") == 0 || bstrcasecmp0(r, "g") == 0) {
+            unit = 1024 * 1024 * 1024;
+        } else if (bstrcasecmp0(r, "tib") == 0 || bstrcasecmp0(r, "t") == 0) {
+            unit = 1024 * 1024 * 1024 * 1024LL;
+        } else {
+            mp_err(log, "The %.*s option must be an integer: %.*s\n",
+                   BSTR_P(name), BSTR_P(param));
+            mp_err(log, "The following suffixes are also allowed: "
+                   "KiB, MiB, GiB, TiB, B, K, M, G, T.\n");
+            return M_OPT_INVALID;
+        }
+    }
+
+    if (tmp_int < 0) {
+        mp_err(log, "The %.*s option does not support negative numbers: %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    if (INT64_MAX / unit < tmp_int) {
+        mp_err(log, "The %.*s option overflows: %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    tmp_int *= unit;
+
+    int64_t min = OPT_INT_MIN(opt, int64_t, INT64_MIN);
+    if (tmp_int < min) {
+        mp_err(log, "The %.*s option must be >= %"PRId64": %.*s\n",
+               BSTR_P(name), min, BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    int64_t max = OPT_INT_MAX(opt, int64_t, INT64_MAX);
+    if (tmp_int > max) {
+        mp_err(log, "The %.*s option must be <= %"PRId64": %.*s\n",
+               BSTR_P(name), max, BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+    if (dst)
+        *(int64_t *)dst = tmp_int;
+
+    return 1;
+}
+
+char *format_file_size(int64_t size)
+{
+    double s = size;
+    if (size < 1024)
+        return talloc_asprintf(NULL, "%.0f B", s);
+
+    if (size < (1024 * 1024))
+        return talloc_asprintf(NULL, "%.3f KiB", s / (1024.0));
+
+    if (size < (1024 * 1024 * 1024))
+        return talloc_asprintf(NULL, "%.3f MiB", s / (1024.0 * 1024.0));
+
+    if (size < (1024LL * 1024LL * 1024LL * 1024LL))
+        return talloc_asprintf(NULL, "%.3f GiB", s / (1024.0 * 1024.0 * 1024.0));
+
+    return talloc_asprintf(NULL, "%.3f TiB", s / (1024.0 * 1024.0 * 1024.0 * 1024.0));
+}
+
+static char *pretty_print_byte_size(const m_option_t *opt, const void *val)
+{
+    return format_file_size(*(int64_t *)val);
+}
+
+const m_option_type_t m_option_type_byte_size = {
+    .name  = "ByteSize",
+    .flags = M_OPT_TYPE_USES_RANGE,
+    .size  = sizeof(int64_t),
+    .parse = parse_byte_size,
+    .print = print_int,
+    .pretty_print = pretty_print_byte_size,
+    .copy  = copy_opt,
+    .add = add_int64,
+    .multiply = multiply_int64,
+    .set   = int64_set,
+    .get   = int64_get,
+    .equal = int64_equal,
+};
+
+const char *m_opt_choice_str(const struct m_opt_choice_alternatives *choices,
+                             int value)
+{
+    for (const struct m_opt_choice_alternatives *c = choices; c->name; c++) {
+        if (c->value == value)
+            return c->name;
+    }
+    return NULL;
+}
+
+static void print_choice_values(struct mp_log *log, const struct m_option *opt)
+{
+    const struct m_opt_choice_alternatives *alt = opt->priv;
+    for ( ; alt->name; alt++)
+        mp_info(log, "    %s\n", alt->name[0] ? alt->name : "(passing nothing)");
+    if (opt->min < opt->max)
+        mp_info(log, "    %g-%g (integer range)\n", opt->min, opt->max);
+}
+
+static int parse_choice(struct mp_log *log, const struct m_option *opt,
+                        struct bstr name, struct bstr param, void *dst)
+{
+    const struct m_opt_choice_alternatives *alt = opt->priv;
+    for ( ; alt->name; alt++) {
+        if (!bstrcmp0(param, alt->name))
+            break;
+    }
+    if (!alt->name && param.len == 0) {
+        // allow flag-style options, e.g. "--mute" implies "--mute=yes"
+        for (alt = opt->priv; alt->name; alt++) {
+            if (!strcmp("yes", alt->name))
+                break;
+        }
+    }
+    if (!alt->name) {
+        if (!bstrcmp0(param, "help")) {
+            mp_info(log, "Valid values for option %.*s are:\n", BSTR_P(name));
+            print_choice_values(log, opt);
+            return M_OPT_EXIT;
+        }
+        if (param.len == 0)
+            return M_OPT_MISSING_PARAM;
+        if (opt->min < opt->max) {
+            long long val;
+            if (parse_longlong(mp_null_log, opt, INT_MIN, INT_MAX, name, param,
+                               &val) == 1)
+            {
+                if (dst)
+                    *(int *)dst = val;
+                return 1;
+            }
+        }
+        mp_fatal(log, "Invalid value for option %.*s: %.*s\n",
+                 BSTR_P(name), BSTR_P(param));
+        mp_info(log, "Valid values are:\n");
+        print_choice_values(log, opt);
+        return M_OPT_INVALID;
+    }
+    if (dst)
+        *(int *)dst = alt->value;
+
+    return 1;
+}
+
+static void choice_get_min_max(const struct m_option *opt, int *min, int *max)
+{
+    assert(opt->type == &m_option_type_choice);
+    *min = INT_MAX;
+    *max = INT_MIN;
+    for (const struct m_opt_choice_alternatives *alt = opt->priv; alt->name; alt++) {
+        *min = MPMIN(*min, alt->value);
+        *max = MPMAX(*max, alt->value);
+    }
+    if (opt->min < opt->max) {
+        *min = MPMIN(*min, opt->min);
+        *max = MPMAX(*max, opt->max);
+    }
+}
+
+static void check_choice(int dir, int val, bool *found, int *best, int choice)
+{
+    if ((dir == -1 && (!(*found) || choice > (*best)) && choice < val) ||
+        (dir == +1 && (!(*found) || choice < (*best)) && choice > val))
+    {
+        *found = true;
+        *best = choice;
+    }
+}
+
+static void add_choice(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    assert(opt->type == &m_option_type_choice);
+    int dir = add > 0 ? +1 : -1;
+    bool found = false;
+    int ival = *(int *)val;
+    int best = 0; // init. value unused
+
+    if (fabs(add) < 0.5)
+        return;
+
+    if (opt->min < opt->max) {
+        int newval = ival + add;
+        if (ival >= opt->min && ival <= opt->max &&
+            newval >= opt->min && newval <= opt->max)
+        {
+            found = true;
+            best = newval;
+        } else {
+            check_choice(dir, ival, &found, &best, opt->min);
+            check_choice(dir, ival, &found, &best, opt->max);
+        }
+    }
+
+    for (const struct m_opt_choice_alternatives *alt = opt->priv; alt->name; alt++)
+        check_choice(dir, ival, &found, &best, alt->value);
+
+    if (!found) {
+        int min, max;
+        choice_get_min_max(opt, &min, &max);
+        best = (dir == -1) ^ wrap ? min : max;
+    }
+
+    *(int *)val = best;
+}
+
+static int choice_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    char buf[80];
+    char *src_str = NULL;
+    if (src->format == MPV_FORMAT_INT64) {
+        snprintf(buf, sizeof(buf), "%" PRId64, src->u.int64);
+        src_str = buf;
+    } else if (src->format == MPV_FORMAT_STRING) {
+        src_str = src->u.string;
+    } else if (src->format == MPV_FORMAT_FLAG) {
+        src_str = src->u.flag ? "yes" : "no";
+    }
+    if (!src_str)
+        return M_OPT_UNKNOWN;
+    int val = 0;
+    int r = parse_choice(mp_null_log, opt, (bstr){0}, bstr0(src_str), &val);
+    if (r >= 0)
+        *(int *)dst = val;
+    return r;
+}
+
+static const struct m_opt_choice_alternatives *get_choice(const m_option_t *opt,
+                                                          const void *val,
+                                                          int *out_val)
+{
+    int v = *(int *)val;
+    const struct m_opt_choice_alternatives *alt;
+    for (alt = opt->priv; alt->name; alt++) {
+        if (alt->value == v)
+            return alt;
+    }
+    if (opt->min < opt->max) {
+        if (v >= opt->min && v <= opt->max) {
+            *out_val = v;
+            return NULL;
+        }
+    }
+    MP_ASSERT_UNREACHABLE();
+}
+
+static int choice_get(const m_option_t *opt, void *ta_parent,
+                      struct mpv_node *dst, void *src)
+{
+    int ival = 0;
+    const struct m_opt_choice_alternatives *alt = get_choice(opt, src, &ival);
+    // If a choice string looks like a number, return it as number
+    if (alt) {
+        char *end = NULL;
+        ival = strtol(alt->name, &end, 10);
+        if (end && !end[0])
+            alt = NULL;
+    }
+    if (alt) {
+        int b = -1;
+        if (strcmp(alt->name, "yes") == 0) {
+            b = 1;
+        } else if (strcmp(alt->name, "no") == 0) {
+            b = 0;
+        }
+        if (b >= 0) {
+            dst->format = MPV_FORMAT_FLAG;
+            dst->u.flag = b;
+        } else {
+            dst->format = MPV_FORMAT_STRING;
+            dst->u.string = talloc_strdup(ta_parent, alt->name);
+        }
+    } else {
+        dst->format = MPV_FORMAT_INT64;
+        dst->u.int64 = ival;
+    }
+    return 1;
+}
+
+static char *print_choice(const m_option_t *opt, const void *val)
+{
+    int ival = 0;
+    const struct m_opt_choice_alternatives *alt = get_choice(opt, val, &ival);
+    return alt ? talloc_strdup(NULL, alt->name)
+               : talloc_asprintf(NULL, "%d", ival);
+}
+
+const struct m_option_type m_option_type_choice = {
+    .name  = "Choice",
+    .size  = sizeof(int),
+    .flags = M_OPT_TYPE_CHOICE | M_OPT_TYPE_USES_RANGE,
+    .parse = parse_choice,
+    .print = print_choice,
+    .copy  = copy_opt,
+    .add   = add_choice,
+    .set   = choice_set,
+    .get   = choice_get,
+    .equal = int_equal,
+};
+
+static int apply_flag(const struct m_option *opt, int *val, bstr flag)
+{
+    const struct m_opt_choice_alternatives *alt;
+    for (alt = opt->priv; alt->name; alt++) {
+        if (bstr_equals0(flag, alt->name)) {
+            if (*val & alt->value)
+                return M_OPT_INVALID;
+            *val |= alt->value;
+            return 0;
+        }
+    }
+    return M_OPT_UNKNOWN;
+}
+
+static const char *find_next_flag(const struct m_option *opt, int *val)
+{
+    const struct m_opt_choice_alternatives *best = NULL;
+    const struct m_opt_choice_alternatives *alt;
+    for (alt = opt->priv; alt->name; alt++) {
+        if (alt->value && (alt->value & (*val)) == alt->value) {
+            if (!best || av_popcount64(alt->value) > av_popcount64(best->value))
+                best = alt;
+        }
+    }
+    if (best) {
+        *val = *val & ~(unsigned)best->value;
+        return best->name;
+    }
+    *val = 0; // if there are still flags left, there's not much we can do
+    return NULL;
+}
+
+static int parse_flags(struct mp_log *log, const struct m_option *opt,
+                       struct bstr name, struct bstr param, void *dst)
+{
+    int value = 0;
+    while (param.len) {
+        bstr flag;
+        bstr_split_tok(param, "+", &flag, &param);
+        int r = apply_flag(opt, &value, flag);
+        if (r == M_OPT_UNKNOWN) {
+            mp_fatal(log, "Invalid flag for option %.*s: %.*s\n",
+                     BSTR_P(name), BSTR_P(flag));
+            mp_info(log, "Valid flags are:\n");
+            const struct m_opt_choice_alternatives *alt;
+            for (alt = opt->priv; alt->name; alt++)
+                mp_info(log, "    %s\n", alt->name);
+            mp_info(log, "Flags can usually be combined with '+'.\n");
+            return M_OPT_INVALID;
+        } else if (r < 0) {
+            mp_fatal(log, "Option %.*s: flag '%.*s' conflicts with a previous "
+                     "flag value.\n", BSTR_P(name), BSTR_P(flag));
+            return M_OPT_INVALID;
+        }
+    }
+    if (dst)
+        *(int *)dst = value;
+    return 1;
+}
+
+static int flags_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    int value = 0;
+    if (src->format != MPV_FORMAT_NODE_ARRAY)
+        return M_OPT_UNKNOWN;
+    struct mpv_node_list *srclist = src->u.list;
+    for (int n = 0; n < srclist->num; n++) {
+        if (srclist->values[n].format != MPV_FORMAT_STRING)
+            return M_OPT_INVALID;
+        if (apply_flag(opt, &value, bstr0(srclist->values[n].u.string)) < 0)
+            return M_OPT_INVALID;
+    }
+    *(int *)dst = value;
+    return 0;
+}
+
+static int flags_get(const m_option_t *opt, void *ta_parent,
+                     struct mpv_node *dst, void *src)
+{
+    int value = *(int *)src;
+
+    dst->format = MPV_FORMAT_NODE_ARRAY;
+    dst->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+    struct mpv_node_list *list = dst->u.list;
+    while (1) {
+        const char *flag = find_next_flag(opt, &value);
+        if (!flag)
+            break;
+
+        struct mpv_node node;
+        node.format = MPV_FORMAT_STRING;
+        node.u.string = (char *)flag;
+        MP_TARRAY_APPEND(list, list->values, list->num, node);
+    }
+
+    return 1;
+}
+
+static char *print_flags(const m_option_t *opt, const void *val)
+{
+    int value = *(int *)val;
+    char *res = talloc_strdup(NULL, "");
+    while (1) {
+        const char *flag = find_next_flag(opt, &value);
+        if (!flag)
+            break;
+
+        res = talloc_asprintf_append_buffer(res, "%s%s", res[0] ? "+" : "", flag);
+    }
+    return res;
+}
+
+const struct m_option_type m_option_type_flags = {
+    .name  = "Flags",
+    .size  = sizeof(int),
+    .parse = parse_flags,
+    .print = print_flags,
+    .copy  = copy_opt,
+    .set   = flags_set,
+    .get   = flags_get,
+    .equal = int_equal,
+};
+
+// Float
+
+#undef VAL
+#define VAL(x) (*(double *)(x))
+
+static int clamp_double(const m_option_t *opt, void *val)
+{
+    double v = VAL(val);
+    int r = 0;
+    if (opt->min < opt->max) {
+        if (v > opt->max) {
+            v = opt->max;
+            r = M_OPT_OUT_OF_RANGE;
+        }
+        if (v < opt->min) {
+            v = opt->min;
+            r = M_OPT_OUT_OF_RANGE;
+        }
+    }
+    // (setting max/min to INFINITY/-INFINITY is allowed)
+    if (!isfinite(v) && v != opt->max && v != opt->min) {
+        v = opt->min;
+        r = M_OPT_OUT_OF_RANGE;
+    }
+    VAL(val) = v;
+    return r;
+}
+
+static int parse_double(struct mp_log *log, const m_option_t *opt,
+                        struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    struct bstr rest;
+    double tmp_float = bstrtod(param, &rest);
+
+    if (bstr_eatstart0(&rest, ":") || bstr_eatstart0(&rest, "/"))
+        tmp_float /= bstrtod(rest, &rest);
+
+    if ((opt->flags & M_OPT_DEFAULT_NAN) && bstr_equals0(param, "default")) {
+        tmp_float = NAN;
+        goto done;
+    }
+
+    if (rest.len) {
+        mp_err(log, "The %.*s option must be a floating point number or a "
+               "ratio (numerator[:/]denominator): %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_INVALID;
+    }
+
+    if (clamp_double(opt, &tmp_float) < 0) {
+        mp_err(log, "The %.*s option is out of range: %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_OUT_OF_RANGE;
+    }
+
+done:
+    if (dst)
+        VAL(dst) = tmp_float;
+    return 1;
+}
+
+static char *print_double(const m_option_t *opt, const void *val)
+{
+    double f = VAL(val);
+    if (isnan(f) && (opt->flags & M_OPT_DEFAULT_NAN))
+        return talloc_strdup(NULL, "default");
+    return talloc_asprintf(NULL, "%f", f);
+}
+
+static char *print_double_7g(const m_option_t *opt, const void *val)
+{
+    double f = VAL(val);
+    if (isnan(f))
+        return print_double(opt, val);
+    // Truncate anything < 1e-4 to avoid switching to scientific notation
+    if (fabs(f) < 1e-4) {
+        return talloc_strdup(NULL, "0");
+    } else {
+        return talloc_asprintf(NULL, "%.7g", f);
+    }
+}
+
+static void add_double(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    double v = VAL(val);
+
+    v = v + add;
+
+    double min = opt->min < opt->max ? opt->min : -INFINITY;
+    double max = opt->min < opt->max ? opt->max : +INFINITY;
+
+    if (v < min)
+        v = wrap ? max : min;
+    if (v > max)
+        v = wrap ? min : max;
+
+    VAL(val) = v;
+}
+
+static void multiply_double(const m_option_t *opt, void *val, double f)
+{
+    *(double *)val *= f;
+    clamp_double(opt, val);
+}
+
+static int double_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    double val;
+    if (src->format == MPV_FORMAT_INT64) {
+        // Can't always be represented exactly, but don't care.
+        val = src->u.int64;
+    } else if (src->format == MPV_FORMAT_DOUBLE) {
+        val = src->u.double_;
+    } else {
+        return M_OPT_UNKNOWN;
+    }
+    if (clamp_double(opt, &val) < 0)
+        return M_OPT_OUT_OF_RANGE;
+    *(double *)dst = val;
+    return 1;
+}
+
+static int double_get(const m_option_t *opt, void *ta_parent,
+                      struct mpv_node *dst, void *src)
+{
+    double f = *(double *)src;
+    if (isnan(f) && (opt->flags & M_OPT_DEFAULT_NAN)) {
+        dst->format = MPV_FORMAT_STRING;
+        dst->u.string = talloc_strdup(ta_parent, "default");
+    } else {
+        dst->format = MPV_FORMAT_DOUBLE;
+        dst->u.double_ = f;
+    }
+    return 1;
+}
+
+static bool double_equal(const m_option_t *opt, void *a, void *b)
+{
+    double fa = VAL(a), fb = VAL(b);
+    if (isnan(fa) || isnan(fb))
+        return isnan(fa) == isnan(fb);
+    return fa == fb;
+}
+
+const m_option_type_t m_option_type_double = {
+    // double precision float or ratio (numerator[:/]denominator)
+    .name  = "Double",
+    .flags = M_OPT_TYPE_USES_RANGE,
+    .size  = sizeof(double),
+    .parse = parse_double,
+    .print = print_double,
+    .pretty_print = print_double_7g,
+    .copy  = copy_opt,
+    .add = add_double,
+    .multiply = multiply_double,
+    .set   = double_set,
+    .get   = double_get,
+    .equal = double_equal,
+};
+
+static int parse_double_aspect(struct mp_log *log, const m_option_t *opt,
+                               struct bstr name, struct bstr param, void *dst)
+{
+    if (bstr_equals0(param, "no")) {
+        if (dst)
+            VAL(dst) = 0.0;
+        return 1;
+    }
+    return parse_double(log, opt, name, param, dst);
+}
+
+const m_option_type_t m_option_type_aspect = {
+    .name  = "Aspect",
+    .size  = sizeof(double),
+    .flags = M_OPT_TYPE_CHOICE | M_OPT_TYPE_USES_RANGE,
+    .parse = parse_double_aspect,
+    .print = print_double,
+    .pretty_print = print_double_7g,
+    .copy  = copy_opt,
+    .add = add_double,
+    .multiply = multiply_double,
+    .set   = double_set,
+    .get   = double_get,
+    .equal = double_equal,
+};
+
+#undef VAL
+#define VAL(x) (*(float *)(x))
+
+static int parse_float(struct mp_log *log, const m_option_t *opt,
+                       struct bstr name, struct bstr param, void *dst)
+{
+    double tmp;
+    int r = parse_double(log, opt, name, param, &tmp);
+    if (r == 1 && dst)
+        VAL(dst) = tmp;
+    return r;
+}
+
+static char *print_float(const m_option_t *opt, const void *val)
+{
+    double tmp = VAL(val);
+    return print_double(opt, &tmp);
+}
+
+static char *print_float_f3(const m_option_t *opt, const void *val)
+{
+    double tmp = VAL(val);
+    return print_double_7g(opt, &tmp);
+}
+
+static void add_float(const m_option_t *opt, void *val, double add, bool wrap)
+{
+    double tmp = VAL(val);
+    add_double(opt, &tmp, add, wrap);
+    VAL(val) = tmp;
+}
+
+static void multiply_float(const m_option_t *opt, void *val, double f)
+{
+    double tmp = VAL(val);
+    multiply_double(opt, &tmp, f);
+    VAL(val) = tmp;
+}
+
+static int float_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    double tmp;
+    int r = double_set(opt, &tmp, src);
+    if (r >= 0)
+        VAL(dst) = tmp;
+    return r;
+}
+
+static int float_get(const m_option_t *opt, void *ta_parent,
+                     struct mpv_node *dst, void *src)
+{
+    double tmp = VAL(src);
+    return double_get(opt, ta_parent, dst, &tmp);
+}
+
+static bool float_equal(const m_option_t *opt, void *a, void *b)
+{
+    return double_equal(opt, &(double){VAL(a)}, &(double){VAL(b)});
+}
+
+const m_option_type_t m_option_type_float = {
+    // floating point number or ratio (numerator[:/]denominator)
+    .name  = "Float",
+    .flags = M_OPT_TYPE_USES_RANGE,
+    .size  = sizeof(float),
+    .parse = parse_float,
+    .print = print_float,
+    .pretty_print = print_float_f3,
+    .copy  = copy_opt,
+    .add = add_float,
+    .multiply = multiply_float,
+    .set   = float_set,
+    .get   = float_get,
+    .equal = float_equal,
+};
+
+///////////// String
+
+#undef VAL
+#define VAL(x) (*(char **)(x))
+
+static int parse_str(struct mp_log *log, const m_option_t *opt,
+                     struct bstr name, struct bstr param, void *dst)
+{
+    if (dst) {
+        talloc_free(VAL(dst));
+        VAL(dst) = bstrdup0(NULL, param);
+    }
+
+    return 0;
+}
+
+static char *print_str(const m_option_t *opt, const void *val)
+{
+    return talloc_strdup(NULL, VAL(val) ? VAL(val) : "");
+}
+
+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 int str_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_STRING)
+        return M_OPT_UNKNOWN;
+    char *s = src->u.string;
+    int r = s ? 0 : M_OPT_INVALID;
+    if (r >= 0)
+        copy_str(opt, dst, &s);
+    return r;
+}
+
+static int str_get(const m_option_t *opt, void *ta_parent,
+                   struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_STRING;
+    dst->u.string = talloc_strdup(ta_parent, VAL(src) ? VAL(src) : "");
+    return 1;
+}
+
+static bool str_equal(const m_option_t *opt, void *a, void *b)
+{
+    return bstr_equals(bstr0(VAL(a)), bstr0(VAL(b)));
+}
+
+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 = {
+    .name  = "String",
+    .size  = sizeof(char *),
+    .parse = parse_str,
+    .print = print_str,
+    .copy  = copy_str,
+    .free  = free_str,
+    .set   = str_set,
+    .get   = str_get,
+    .equal = str_equal,
+};
+
+//////////// String list
+
+#undef VAL
+#define VAL(x) (*(char ***)(x))
+
+#define OP_NONE 0
+#define OP_ADD 1
+#define OP_PRE 2
+#define OP_CLR 3
+#define OP_TOGGLE 4
+#define OP_APPEND 5
+#define OP_REMOVE 6
+
+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;
+    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 struct bstr get_nextsep(struct bstr *ptr, char sep, bool modify)
+{
+    struct bstr str = *ptr;
+    struct bstr orig = str;
+    for (;;) {
+        int idx = sep ? bstrchr(str, sep) : -1;
+        if (idx > 0 && str.start[idx - 1] == '\\') {
+            if (modify) {
+                memmove(str.start + idx - 1, str.start + idx, str.len - idx);
+                str.len--;
+                str = bstr_cut(str, idx);
+            } else
+                str = bstr_cut(str, idx + 1);
+        } else {
+            str = bstr_cut(str, idx < 0 ? str.len : idx);
+            break;
+        }
+    }
+    *ptr = str;
+    return bstr_splice(orig, 0, str.start - orig.start);
+}
+
+static int find_list_bstr(char **list, bstr item)
+{
+    for (int n = 0; list && list[n]; n++) {
+        if (bstr_equals0(item, list[n]))
+            return n;
+    }
+    return -1;
+}
+
+static int parse_str_list_impl(struct mp_log *log, const m_option_t *opt,
+                               struct bstr name, struct bstr param, void *dst,
+                               int default_op)
+{
+    char **res;
+    int op = default_op;
+    bool multi = true;
+
+    if (bstr_endswith0(name, "-add")) {
+        op = OP_ADD;
+    } else if (bstr_endswith0(name, "-append")) {
+        op = OP_ADD;
+        multi = false;
+    } else if (bstr_endswith0(name, "-pre")) {
+        op = OP_PRE;
+    } else if (bstr_endswith0(name, "-clr")) {
+        op = OP_CLR;
+    } else if (bstr_endswith0(name, "-set")) {
+        op = OP_NONE;
+    } else if (bstr_endswith0(name, "-toggle")) {
+        op = OP_TOGGLE;
+    } else if (bstr_endswith0(name, "-remove")) {
+        op = OP_REMOVE;
+    }
+
+    if (op == OP_TOGGLE || op == OP_REMOVE) {
+        if (dst) {
+            char **list = VAL(dst);
+            bool found = false;
+            int index = 0;
+            do {
+                index = find_list_bstr(list, param);
+                if (index >= 0) {
+                    found = true;
+                    char *old = list[index];
+                    for (int n = index; list[n]; n++)
+                        list[n] = list[n + 1];
+                    talloc_free(old);
+                }
+            } while (index >= 0);
+            if (found)
+                return 1;
+        }
+        if (op == OP_REMOVE)
+            return 1; // ignore if not found
+        op = OP_ADD;
+        multi = false;
+    }
+
+    // Clear the list ??
+    if (op == OP_CLR) {
+        if (dst)
+            free_str_list(dst);
+        return 0;
+    }
+
+    // All other ops need a param
+    if (param.len == 0 && op != OP_NONE)
+        return M_OPT_MISSING_PARAM;
+
+    char separator = opt->priv ? *(char *)opt->priv : OPTION_LIST_SEPARATOR;
+    if (!multi)
+        separator = 0; // specially handled
+    int n = 0;
+    struct bstr str = param;
+    while (str.len) {
+        get_nextsep(&str, separator, 0);
+        str = bstr_cut(str, 1);
+        n++;
+    }
+    if (n == 0 && op != OP_NONE)
+        return M_OPT_INVALID;
+
+    if (!dst)
+        return 1;
+
+    res = talloc_array(NULL, char *, n + 2);
+    str = bstrdup(NULL, param);
+    char *ptr = str.start;
+    n = 0;
+
+    while (1) {
+        struct bstr el = get_nextsep(&str, separator, 1);
+        res[n] = bstrdup0(NULL, el);
+        n++;
+        if (!str.len)
+            break;
+        str = bstr_cut(str, 1);
+    }
+    res[n] = NULL;
+    talloc_free(ptr);
+
+    if (op != OP_NONE && n > 1) {
+        mp_warn(log, "Passing multiple arguments to %.*s is deprecated!\n",
+                BSTR_P(name));
+    }
+
+    switch (op) {
+    case OP_ADD:
+        return str_list_add(res, n, dst, 0);
+    case OP_PRE:
+        return str_list_add(res, n, dst, 1);
+    }
+
+    if (VAL(dst))
+        free_str_list(dst);
+    VAL(dst) = res;
+
+    if (!res[0])
+        free_str_list(dst);
+
+    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 talloc_strdup(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;
+}
+
+static int str_list_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_NODE_ARRAY)
+        return M_OPT_UNKNOWN;
+    struct mpv_node_list *srclist = src->u.list;
+    for (int n = 0; n < srclist->num; n++) {
+        if (srclist->values[n].format != MPV_FORMAT_STRING)
+            return M_OPT_INVALID;
+    }
+    free_str_list(dst);
+    if (srclist->num > 0) {
+        VAL(dst) = talloc_array(NULL, char*, srclist->num + 1);
+        for (int n = 0; n < srclist->num; n++)
+            VAL(dst)[n] = talloc_strdup(NULL, srclist->values[n].u.string);
+        VAL(dst)[srclist->num] = NULL;
+    }
+    return 1;
+}
+
+static int str_list_get(const m_option_t *opt, void *ta_parent,
+                        struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_NODE_ARRAY;
+    dst->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+    struct mpv_node_list *list = dst->u.list;
+    for (int n = 0; VAL(src) && VAL(src)[n]; n++) {
+        struct mpv_node node;
+        node.format = MPV_FORMAT_STRING;
+        node.u.string = talloc_strdup(list, VAL(src)[n]);
+        MP_TARRAY_APPEND(list, list->values, list->num, node);
+    }
+    return 1;
+}
+
+static int parse_str_list(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    return parse_str_list_impl(log, opt, name, param, dst, OP_NONE);
+}
+
+static bool str_list_equal(const m_option_t *opt, void *a, void *b)
+{
+    char **la = VAL(a);
+    char **lb = VAL(b);
+
+    bool a_empty = !la || !la[0];
+    bool b_empty = !lb || !lb[0];
+    if (a_empty || b_empty)
+        return a_empty == b_empty;
+
+    for (int n = 0; la[n] || lb[n]; n++) {
+        if (!la[n] || !lb[n])
+            return false;
+        if (strcmp(la[n], lb[n]) != 0)
+            return false;
+    }
+
+    return true;
+}
+
+const m_option_type_t m_option_type_string_list = {
+    .name  = "String list",
+    .size  = sizeof(char **),
+    .parse = parse_str_list,
+    .print = print_str_list,
+    .copy  = copy_str_list,
+    .free  = free_str_list,
+    .get   = str_list_get,
+    .set   = str_list_set,
+    .equal = str_list_equal,
+    .actions = (const struct m_option_action[]){
+        {"add"},
+        {"append"},
+        {"clr",         M_OPT_TYPE_OPTIONAL_PARAM},
+        {"pre"},
+        {"set"},
+        {"toggle"},
+        {"remove"},
+        {0}
+    },
+};
+
+static int read_subparam(struct mp_log *log, bstr optname, char *termset,
+                         bstr *str, bstr *out_subparam);
+
+static int keyvalue_list_find_key(char **lst, bstr str)
+{
+    for (int n = 0; lst && lst[n] && lst[n + 1]; n += 2) {
+        if (bstr_equals0(str, lst[n]))
+            return n / 2;
+    }
+    return -1;
+}
+
+static void keyvalue_list_del_key(char **lst, int index)
+{
+    int count = 0;
+    for (int n = 0; lst && lst[n]; n++)
+        count++;
+    assert(index * 2 + 1 < count);
+    count += 1; // terminating item
+    talloc_free(lst[index * 2 + 0]);
+    talloc_free(lst[index * 2 + 1]);
+    MP_TARRAY_REMOVE_AT(lst, count, index * 2 + 1);
+    MP_TARRAY_REMOVE_AT(lst, count, index * 2 + 0);
+}
+
+static int parse_keyvalue_list(struct mp_log *log, const m_option_t *opt,
+                               struct bstr name, struct bstr param, void *dst)
+{
+    char **lst = NULL;
+    int num = 0;
+    int r = 0;
+    bool append = false;
+    bool full_value = false;
+
+    if ((opt->flags & M_OPT_HAVE_HELP) && bstr_equals0(param, "help"))
+        param = bstr0("help=");
+
+    if (bstr_endswith0(name, "-add")) {
+        append = true;
+    } else if (bstr_endswith0(name, "-append")) {
+        append = full_value = true;
+    } else if (bstr_endswith0(name, "-remove")) {
+        lst = dst ? VAL(dst) : NULL;
+        int index = dst ? keyvalue_list_find_key(lst, param) : -1;
+        if (index >= 0) {
+            keyvalue_list_del_key(lst, index);
+            VAL(dst) = lst;
+        }
+        return 1;
+    }
+
+    if (append && dst) {
+        lst = VAL(dst);
+        for (int n = 0; lst && lst[n]; n++)
+            num++;
+    }
+
+    while (param.len) {
+        bstr key, val;
+        r = read_subparam(log, name, "=", &param, &key);
+        if (r < 0)
+            break;
+        if (!bstr_eatstart0(&param, "=")) {
+            mp_err(log, "Expected '=' and a value.\n");
+            r = M_OPT_INVALID;
+            break;
+        }
+        if (full_value) {
+            val = param;
+            param.len = 0;
+        } else {
+            r = read_subparam(log, name, ",", &param, &val);
+            if (r < 0)
+                break;
+        }
+        if (dst) {
+            int index = keyvalue_list_find_key(lst, key);
+            if (index >= 0) {
+                keyvalue_list_del_key(lst, index);
+                num -= 2;
+            }
+            MP_TARRAY_APPEND(NULL, lst, num, bstrto0(NULL, key));
+            MP_TARRAY_APPEND(NULL, lst, num, bstrto0(NULL, val));
+            MP_TARRAY_APPEND(NULL, lst, num, NULL);
+            num -= 1;
+        }
+
+        if (!bstr_eatstart0(&param, ",") && !bstr_eatstart0(&param, ":"))
+            break;
+
+        if (append) {
+            mp_warn(log, "Passing more than 1 argument to %.*s is deprecated!\n",
+                    BSTR_P(name));
+        }
+    }
+
+    if (param.len) {
+        mp_err(log, "Unparsable garbage at end of option value: '%.*s'\n",
+               BSTR_P(param));
+        r = M_OPT_INVALID;
+    }
+
+    if (dst) {
+        if (!append)
+            free_str_list(dst);
+        VAL(dst) = lst;
+        if (r < 0)
+            free_str_list(dst);
+    } else {
+        free_str_list(&lst);
+    }
+    return r;
+}
+
+static char *print_keyvalue_list(const m_option_t *opt, const void *src)
+{
+    char **lst = VAL(src);
+    char *ret = talloc_strdup(NULL, "");
+    for (int n = 0; lst && lst[n] && lst[n + 1]; n += 2) {
+        if (ret[0])
+            ret = talloc_strdup_append(ret, ",");
+        ret = talloc_asprintf_append(ret, "%s=%s", lst[n], lst[n + 1]);
+    }
+    return ret;
+}
+
+static int keyvalue_list_set(const m_option_t *opt, void *dst,
+                             struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_NODE_MAP)
+        return M_OPT_UNKNOWN;
+    struct mpv_node_list *srclist = src->u.list;
+    for (int n = 0; n < srclist->num; n++) {
+        if (srclist->values[n].format != MPV_FORMAT_STRING)
+            return M_OPT_INVALID;
+    }
+    free_str_list(dst);
+    if (srclist->num > 0) {
+        VAL(dst) = talloc_array(NULL, char*, (srclist->num + 1) * 2);
+        for (int n = 0; n < srclist->num; n++) {
+            VAL(dst)[n * 2 + 0] = talloc_strdup(NULL, srclist->keys[n]);
+            VAL(dst)[n * 2 + 1] = talloc_strdup(NULL, srclist->values[n].u.string);
+        }
+        VAL(dst)[srclist->num * 2 + 0] = NULL;
+        VAL(dst)[srclist->num * 2 + 1] = NULL;
+    }
+    return 1;
+}
+
+static int keyvalue_list_get(const m_option_t *opt, void *ta_parent,
+                             struct mpv_node *dst, void *src)
+{
+    dst->format = MPV_FORMAT_NODE_MAP;
+    dst->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+    struct mpv_node_list *list = dst->u.list;
+    for (int n = 0; VAL(src) && VAL(src)[n * 2 + 0]; n++) {
+        MP_TARRAY_GROW(list, list->values, list->num);
+        MP_TARRAY_GROW(list, list->keys, list->num);
+        list->keys[list->num] = talloc_strdup(list, VAL(src)[n * 2 + 0]);
+        list->values[list->num] = (struct mpv_node){
+            .format = MPV_FORMAT_STRING,
+            .u.string = talloc_strdup(list, VAL(src)[n * 2 + 1]),
+        };
+        list->num++;
+    }
+    return 1;
+}
+
+const m_option_type_t m_option_type_keyvalue_list = {
+    .name  = "Key/value list",
+    .size  = sizeof(char **),
+    .parse = parse_keyvalue_list,
+    .print = print_keyvalue_list,
+    .copy  = copy_str_list,
+    .free  = free_str_list,
+    .get   = keyvalue_list_get,
+    .set   = keyvalue_list_set,
+    .equal = str_list_equal,
+    .actions = (const struct m_option_action[]){
+        {"add"},
+        {"append"},
+        {"set"},
+        {"remove"},
+        {0}
+    },
+};
+
+
+#undef VAL
+#define VAL(x) (*(char **)(x))
+
+static int check_msg_levels(struct mp_log *log, char **list)
+{
+    for (int n = 0; list && list[n * 2 + 0]; n++) {
+        char *level = list[n * 2 + 1];
+        if (mp_msg_find_level(level) < 0 && strcmp(level, "no") != 0) {
+            mp_err(log, "Invalid message level '%s'\n", level);
+            return M_OPT_INVALID;
+        }
+    }
+    return 1;
+}
+
+static int parse_msglevels(struct mp_log *log, const m_option_t *opt,
+                           struct bstr name, struct bstr param, void *dst)
+{
+    if (bstr_equals0(param, "help")) {
+        mp_info(log, "Syntax:\n\n   --msg-level=module1=level,module2=level,...\n\n"
+                     "'module' is output prefix as shown with -v, or a prefix\n"
+                     "of it. level is one of:\n\n"
+                     "  fatal error warn info status v debug trace\n\n"
+                     "The level specifies the minimum log level a message\n"
+                     "must have to be printed.\n"
+                     "The special module name 'all' affects all modules.\n");
+        return M_OPT_EXIT;
+    }
+
+    char **dst_copy = NULL;
+    int r = m_option_type_keyvalue_list.parse(log, opt, name, param, &dst_copy);
+    if (r >= 0)
+        r = check_msg_levels(log, dst_copy);
+
+    if (r >= 0)
+        m_option_type_keyvalue_list.copy(opt, dst, &dst_copy);
+    m_option_type_keyvalue_list.free(&dst_copy);
+    return r;
+}
+
+static int set_msglevels(const m_option_t *opt, void *dst,
+                             struct mpv_node *src)
+{
+    char **dst_copy = NULL;
+    int r = m_option_type_keyvalue_list.set(opt, &dst_copy, src);
+    if (r >= 0)
+        r = check_msg_levels(mp_null_log, dst_copy);
+
+    if (r >= 0)
+        m_option_type_keyvalue_list.copy(opt, dst, &dst_copy);
+    m_option_type_keyvalue_list.free(&dst_copy);
+    return r;
+}
+
+const m_option_type_t m_option_type_msglevels = {
+    .name = "Output verbosity levels",
+    .size  = sizeof(char **),
+    .parse = parse_msglevels,
+    .print = print_keyvalue_list,
+    .copy  = copy_str_list,
+    .free  = free_str_list,
+    .get   = keyvalue_list_get,
+    .set   = set_msglevels,
+    .equal = str_list_equal,
+};
+
+static int parse_print(struct mp_log *log, const m_option_t *opt,
+                       struct bstr name, struct bstr param, void *dst)
+{
+    ((m_opt_print_fn) opt->priv)(log);
+    return M_OPT_EXIT;
+}
+
+const m_option_type_t m_option_type_print_fn = {
+    .name  = "Print",
+    .flags = M_OPT_TYPE_OPTIONAL_PARAM,
+    .parse = parse_print,
+};
+
+static int parse_dummy_flag(struct mp_log *log, const m_option_t *opt,
+                            struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len) {
+        mp_err(log, "Invalid parameter for %.*s flag: %.*s\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_DISALLOW_PARAM;
+    }
+    return 0;
+}
+
+const m_option_type_t m_option_type_dummy_flag = {
+    // can only be activated
+    .name  = "Flag",
+    .flags = M_OPT_TYPE_OPTIONAL_PARAM,
+    .parse = parse_dummy_flag,
+};
+
+#undef VAL
+
+// Read s sub-option name, or a positional sub-opt value.
+// termset is a string containing the set of chars that terminate an option.
+// Return 0 on success, M_OPT_ error code otherwise.
+// optname is for error reporting.
+static int read_subparam(struct mp_log *log, bstr optname, char *termset,
+                         bstr *str, bstr *out_subparam)
+{
+    bstr p = *str;
+    bstr subparam = {0};
+
+    if (bstr_eatstart0(&p, "\"")) {
+        int optlen = bstrcspn(p, "\"");
+        subparam = bstr_splice(p, 0, optlen);
+        p = bstr_cut(p, optlen);
+        if (!bstr_startswith0(p, "\"")) {
+            mp_err(log, "Terminating '\"' missing for '%.*s'\n",
+                   BSTR_P(optname));
+            return M_OPT_INVALID;
+        }
+        p = bstr_cut(p, 1);
+    } else if (bstr_eatstart0(&p, "[")) {
+        bstr s = p;
+        int balance = 1;
+        while (p.len && balance > 0) {
+            if (p.start[0] == '[') {
+                balance++;
+            } else if (p.start[0] == ']') {
+                balance--;
+            }
+            p = bstr_cut(p, 1);
+        }
+        if (balance != 0) {
+            mp_err(log, "Terminating ']' missing for '%.*s'\n",
+                   BSTR_P(optname));
+            return M_OPT_INVALID;
+        }
+        subparam = bstr_splice(s, 0, s.len - p.len - 1);
+    } else if (bstr_eatstart0(&p, "%")) {
+        int optlen = bstrtoll(p, &p, 0);
+        if (!bstr_startswith0(p, "%") || (optlen > p.len - 1)) {
+            mp_err(log, "Invalid length %d for '%.*s'\n",
+                   optlen, BSTR_P(optname));
+            return M_OPT_INVALID;
+        }
+        subparam = bstr_splice(p, 1, optlen + 1);
+        p = bstr_cut(p, optlen + 1);
+    } else {
+        // Skip until the next character that could possibly be a meta
+        // character in option parsing.
+        int optlen = bstrcspn(p, termset);
+        subparam = bstr_splice(p, 0, optlen);
+        p = bstr_cut(p, optlen);
+    }
+
+    *str = p;
+    *out_subparam = subparam;
+    return 0;
+}
+
+// Return 0 on success, otherwise error code
+// On success, set *out_name and *out_val, and advance *str
+// out_val.start is NULL if there was no parameter.
+// optname is for error reporting.
+static int split_subconf(struct mp_log *log, bstr optname, bstr *str,
+                         bstr *out_name, bstr *out_val)
+{
+    bstr p = *str;
+    bstr subparam = {0};
+    bstr subopt;
+    int r = read_subparam(log, optname, ":=,\\%\"'[]", &p, &subopt);
+    if (r < 0)
+        return r;
+    if (bstr_eatstart0(&p, "=")) {
+        r = read_subparam(log, subopt, ":=,\\%\"'[]", &p, &subparam);
+        if (r < 0)
+            return r;
+    }
+    *str = p;
+    *out_name = subopt;
+    *out_val = subparam;
+    return 0;
+}
+
+#undef VAL
+
+// Split the string on the given split character.
+// out_arr is at least max entries long.
+// Return number of out_arr entries filled.
+static int split_char(bstr str, unsigned char split, int max, bstr *out_arr)
+{
+    if (max < 1)
+        return 0;
+
+    int count = 0;
+    while (1) {
+        int next = bstrchr(str, split);
+        if (next >= 0 && max - count > 1) {
+            out_arr[count++] = bstr_splice(str, 0, next);
+            str = bstr_cut(str, next + 1);
+        } else {
+            out_arr[count++] = str;
+            break;
+        }
+    }
+    return count;
+}
+
+static int parse_color(struct mp_log *log, const m_option_t *opt,
+                       struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    bool is_help = bstr_equals0(param, "help");
+    if (is_help)
+        goto exit;
+
+    bstr val = param;
+    struct m_color color = {0};
+
+    if (bstr_eatstart0(&val, "#")) {
+        // #[AA]RRGGBB
+        if (val.len != 6 && val.len != 8)
+            goto exit;
+        bool has_alpha = val.len == 8;
+        uint32_t c = bstrtoll(val, &val, 16);
+        if (val.len)
+            goto exit;
+        color = (struct m_color) {
+            (c >> 16) & 0xFF,
+            (c >> 8) & 0xFF,
+            c & 0xFF,
+            has_alpha ? (c >> 24) & 0xFF : 0xFF,
+        };
+    } else {
+        bstr comp_str[5];
+        int num = split_char(param, '/', 5, comp_str);
+        if (num < 1 || num > 4)
+            goto exit;
+        double comp[4] = {0, 0, 0, 1};
+        for (int n = 0; n < num; n++) {
+            bstr rest;
+            double d = bstrtod(comp_str[n], &rest);
+            if (rest.len || !comp_str[n].len || d < 0 || d > 1 || !isfinite(d))
+                goto exit;
+            comp[n] = d;
+        }
+        if (num == 2)
+            comp[3] = comp[1];
+        if (num < 3)
+            comp[2] = comp[1] = comp[0];
+        color = (struct m_color) { comp[0] * 0xFF, comp[1] * 0xFF,
+                                   comp[2] * 0xFF, comp[3] * 0xFF };
+    }
+
+    if (dst)
+        *((struct m_color *)dst) = color;
+
+    return 1;
+
+exit:
+    if (!is_help) {
+        mp_err(log, "Option %.*s: invalid color: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+    }
+    mp_info(log, "Valid colors must be in the form #RRGGBB or #AARRGGBB (in hex)\n"
+            "or in the form 'r/g/b/a', where each component is a value in the\n"
+            "range 0.0-1.0. (Also allowed: 'gray', 'gray/a', 'r/g/b').\n");
+    return is_help ? M_OPT_EXIT : M_OPT_INVALID;
+}
+
+static char *print_color(const m_option_t *opt, const void *val)
+{
+    const struct m_color *c = val;
+    return talloc_asprintf(NULL, "#%02X%02X%02X%02X", c->a, c->r, c->g, c->b);
+}
+
+static bool color_equal(const m_option_t *opt, void *a, void *b)
+{
+    struct m_color *ca = a;
+    struct m_color *cb = b;
+    return ca->a == cb->a && ca->r == cb->r && ca->g == cb->g && ca->b == cb->b;
+}
+
+const m_option_type_t m_option_type_color = {
+    .name  = "Color",
+    .size  = sizeof(struct m_color),
+    .parse = parse_color,
+    .print = print_color,
+    .copy  = copy_opt,
+    .equal = color_equal,
+};
+
+
+// Parse a >=0 number starting at s. Set s to the string following the number.
+// If the number ends with '%', eat that and set *out_per to true, but only
+// if the number is between 0-100; if not, don't eat anything, even the number.
+static bool eat_num_per(bstr *s, int *out_num, bool *out_per)
+{
+    bstr rest;
+    long long v = bstrtoll(*s, &rest, 10);
+    if (s->len == rest.len || v < INT_MIN || v > INT_MAX)
+        return false;
+    *out_num = v;
+    *out_per = false;
+    *s = rest;
+    if (bstr_eatstart0(&rest, "%") && v >= 0 && v <= 100) {
+        *out_per = true;
+        *s = rest;
+    }
+    return true;
+}
+
+static bool parse_geometry_str(struct m_geometry *gm, bstr s)
+{
+    *gm = (struct m_geometry) { .x = INT_MIN, .y = INT_MIN };
+    if (s.len == 0)
+        return true;
+    // Approximate grammar:
+    // [[W][xH]][{+-}X{+-}Y][/WS] | [X:Y]
+    // (meaning: [optional] {one character of} one|alternative)
+    // Every number can be followed by '%'
+    int num;
+    bool per;
+
+#define READ_NUM(F, F_PER) do {         \
+    if (!eat_num_per(&s, &num, &per))   \
+        goto error;                     \
+    gm->F = num;                        \
+    gm->F_PER = per;                    \
+} while(0)
+
+#define READ_SIGN(F) do {               \
+    if (bstr_eatstart0(&s, "+")) {      \
+        gm->F = false;                  \
+    } else if (bstr_eatstart0(&s, "-")) {\
+        gm->F = true;                   \
+    } else goto error;                  \
+} while(0)
+
+    if (bstrchr(s, ':') < 0) {
+        gm->wh_valid = true;
+        if (!bstr_startswith0(s, "+") && !bstr_startswith0(s, "-")) {
+            if (!bstr_startswith0(s, "x"))
+                READ_NUM(w, w_per);
+            if (bstr_eatstart0(&s, "x"))
+                READ_NUM(h, h_per);
+        }
+        if (s.len > 0) {
+            gm->xy_valid = true;
+            READ_SIGN(x_sign);
+            READ_NUM(x, x_per);
+            READ_SIGN(y_sign);
+            READ_NUM(y, y_per);
+        }
+        if (bstr_eatstart0(&s, "/")) {
+            bstr rest;
+            long long v = bstrtoll(s, &rest, 10);
+            if (s.len == rest.len || v < 1 || v > INT_MAX)
+                goto error;
+            s = rest;
+            gm->ws = v;
+        }
+    } else {
+        gm->xy_valid = true;
+        READ_NUM(x, x_per);
+        if (!bstr_eatstart0(&s, ":"))
+            goto error;
+        READ_NUM(y, y_per);
+    }
+
+    return s.len == 0;
+
+error:
+    return false;
+}
+
+#undef READ_NUM
+#undef READ_SIGN
+
+#define APPEND_PER(F, F_PER) \
+    res = talloc_asprintf_append(res, "%d%s", gm->F, gm->F_PER ? "%" : "")
+
+static char *print_geometry(const m_option_t *opt, const void *val)
+{
+    const struct m_geometry *gm = val;
+    char *res = talloc_strdup(NULL, "");
+    if (gm->wh_valid || gm->xy_valid) {
+        if (gm->wh_valid) {
+            APPEND_PER(w, w_per);
+            res = talloc_asprintf_append(res, "x");
+            APPEND_PER(h, h_per);
+        }
+        if (gm->xy_valid) {
+            res = talloc_asprintf_append(res, gm->x_sign ? "-" : "+");
+            APPEND_PER(x, x_per);
+            res = talloc_asprintf_append(res, gm->y_sign ? "-" : "+");
+            APPEND_PER(y, y_per);
+        }
+        if (gm->ws > 0)
+            res = talloc_asprintf_append(res, "/%d", gm->ws);
+    }
+    return res;
+}
+
+#undef APPEND_PER
+
+// xpos,ypos: position of the left upper corner
+// widw,widh: width and height of the window
+// scrw,scrh: width and height of the current screen
+// The input parameters should be set to a centered window (default fallbacks).
+void m_geometry_apply(int *xpos, int *ypos, int *widw, int *widh,
+                      int scrw, int scrh, struct m_geometry *gm)
+{
+    if (gm->wh_valid) {
+        int prew = *widw, preh = *widh;
+        if (gm->w > 0)
+            *widw = gm->w_per ? scrw * (gm->w / 100.0) : gm->w;
+        if (gm->h > 0)
+            *widh = gm->h_per ? scrh * (gm->h / 100.0) : gm->h;
+        // keep aspect if the other value is not set
+        double asp = (double)prew / preh;
+        if (gm->w > 0 && !(gm->h > 0)) {
+            *widh = *widw / asp;
+        } else if (!(gm->w > 0) && gm->h > 0) {
+            *widw = *widh * asp;
+        }
+        // Center window after resize. If valid x:y values are passed to
+        // geometry, then those values will be overridden.
+        *xpos += prew / 2 - *widw / 2;
+        *ypos += preh / 2 - *widh / 2;
+    }
+
+    if (gm->xy_valid) {
+        if (gm->x != INT_MIN) {
+            *xpos = gm->x;
+            if (gm->x_per)
+                *xpos = (scrw - *widw) * (*xpos / 100.0);
+            if (gm->x_sign)
+                *xpos = scrw - *widw - *xpos;
+        }
+        if (gm->y != INT_MIN) {
+            *ypos = gm->y;
+            if (gm->y_per)
+                *ypos = (scrh - *widh) * (*ypos / 100.0);
+            if (gm->y_sign)
+                *ypos = scrh - *widh - *ypos;
+        }
+    }
+}
+
+static int parse_geometry(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    bool is_help = bstr_equals0(param, "help");
+    if (is_help)
+        goto exit;
+
+    struct m_geometry gm;
+    if (!parse_geometry_str(&gm, param))
+        goto exit;
+
+    if (dst)
+        *((struct m_geometry *)dst) = gm;
+
+    return 1;
+
+exit:
+    if (!is_help) {
+        mp_err(log, "Option %.*s: invalid geometry: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+    }
+    mp_info(log,
+         "Valid format: [W[%%][xH[%%]]][{+-}X[%%]{+-}Y[%%]] | [X[%%]:Y[%%]]\n");
+    return is_help ? M_OPT_EXIT : M_OPT_INVALID;
+}
+
+static bool geometry_equal(const m_option_t *opt, void *a, void *b)
+{
+    struct m_geometry *ga = a;
+    struct m_geometry *gb = b;
+    return ga->x == gb->x && ga->y == gb->y && ga->w == gb->w && ga->h == gb->h &&
+           ga->xy_valid == gb->xy_valid && ga->wh_valid == gb->wh_valid &&
+           ga->w_per == gb->w_per && ga->h_per == gb->h_per &&
+           ga->x_per == gb->x_per && ga->y_per == gb->y_per &&
+           ga->x_sign == gb->x_sign && ga->y_sign == gb->y_sign &&
+           ga->ws == gb->ws;
+}
+
+const m_option_type_t m_option_type_geometry = {
+    .name  = "Window geometry",
+    .size  = sizeof(struct m_geometry),
+    .parse = parse_geometry,
+    .print = print_geometry,
+    .copy  = copy_opt,
+    .equal = geometry_equal,
+};
+
+static int parse_size_box(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    bool is_help = bstr_equals0(param, "help");
+    if (is_help)
+        goto exit;
+
+    struct m_geometry gm;
+    if (!parse_geometry_str(&gm, param))
+        goto exit;
+
+    if (gm.xy_valid)
+        goto exit;
+
+    if (dst)
+        *((struct m_geometry *)dst) = gm;
+
+    return 1;
+
+exit:
+    if (!is_help) {
+        mp_err(log, "Option %.*s: invalid size: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+    }
+    mp_info(log, "Valid format: W[%%][xH[%%]] or empty string\n");
+    return is_help ? M_OPT_EXIT : M_OPT_INVALID;
+}
+
+const m_option_type_t m_option_type_size_box = {
+    .name  = "Window size",
+    .size  = sizeof(struct m_geometry),
+    .parse = parse_size_box,
+    .print = print_geometry,
+    .copy  = copy_opt,
+    .equal = geometry_equal,
+};
+
+void m_rect_apply(struct mp_rect *rc, int w, int h, struct m_geometry *gm)
+{
+    *rc = (struct mp_rect){0, 0, w, h};
+    if (!w || !h)
+        return;
+    m_geometry_apply(&rc->x0, &rc->y0, &rc->x1, &rc->y1, w, h, gm);
+    if (!gm->xy_valid && gm->wh_valid && rc->x1 == 0 && rc->y1 == 0)
+        return;
+    if (!gm->wh_valid || rc->x1 == 0 || rc->x1 == INT_MIN)
+        rc->x1 = w - rc->x0;
+    if (!gm->wh_valid || rc->y1 == 0 || rc->y1 == INT_MIN)
+        rc->y1 = h - rc->y0;
+    if (gm->wh_valid && (gm->w || gm->h))
+        rc->x1 += rc->x0;
+    if (gm->wh_valid && (gm->w || gm->h))
+        rc->y1 += rc->y0;
+}
+
+static int parse_rect(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    bool is_help = bstr_equals0(param, "help");
+    if (is_help)
+        goto exit;
+
+    struct m_geometry gm;
+    if (!parse_geometry_str(&gm, param))
+        goto exit;
+
+    bool invalid = gm.x_sign || gm.y_sign || gm.ws;
+    invalid |= gm.wh_valid && (gm.w < 0 || gm.h < 0);
+    invalid |= gm.wh_valid && !gm.xy_valid && gm.w <= 0 && gm.h <= 0;
+
+    if (invalid)
+        goto exit;
+
+    if (dst)
+        *((struct m_geometry *)dst) = gm;
+
+    return 1;
+
+exit:
+    if (!is_help) {
+        mp_err(log, "Option %.*s: invalid rect: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+    }
+    mp_info(log, "Valid format: W[%%][xH[%%]][+x+y]\n");
+    return is_help ? M_OPT_EXIT : M_OPT_INVALID;
+}
+
+const m_option_type_t m_option_type_rect = {
+    .name  = "Video rect",
+    .size  = sizeof(struct m_geometry),
+    .parse = parse_rect,
+    .print = print_geometry,
+    .copy  = copy_opt,
+    .equal = geometry_equal,
+};
+
+#include "video/img_format.h"
+
+static int parse_imgfmt(struct mp_log *log, const m_option_t *opt,
+                        struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    if (!bstrcmp0(param, "help")) {
+        mp_info(log, "Available formats:");
+        char **list = mp_imgfmt_name_list();
+        for (int i = 0; list[i]; i++)
+            mp_info(log, " %s", list[i]);
+        mp_info(log, " no");
+        mp_info(log, "\n");
+        talloc_free(list);
+        return M_OPT_EXIT;
+    }
+
+    unsigned int fmt = mp_imgfmt_from_name(param);
+    if (!fmt && !bstr_equals0(param, "no")) {
+        mp_err(log, "Option %.*s: unknown format name: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_INVALID;
+    }
+
+    if (dst)
+        *((int *)dst) = fmt;
+
+    return 1;
+}
+
+static char *print_imgfmt(const m_option_t *opt, const void *val)
+{
+    int fmt = *(int *)val;
+    return talloc_strdup(NULL, fmt ? mp_imgfmt_to_name(fmt) : "no");
+}
+
+const m_option_type_t m_option_type_imgfmt = {
+    .name  = "Image format",
+    .size  = sizeof(int),
+    .parse = parse_imgfmt,
+    .print = print_imgfmt,
+    .copy  = copy_opt,
+    .equal = int_equal,
+};
+
+static int parse_fourcc(struct mp_log *log, const m_option_t *opt,
+                        struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    unsigned int value;
+
+    if (param.len == 4) {
+        uint8_t *s = param.start;
+        value = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
+    } else {
+        bstr rest;
+        value = bstrtoll(param, &rest, 16);
+        if (rest.len != 0) {
+            mp_err(log, "Option %.*s: invalid FourCC: '%.*s'\n",
+                   BSTR_P(name), BSTR_P(param));
+            return M_OPT_INVALID;
+        }
+    }
+
+    if (dst)
+        *((unsigned int *)dst) = value;
+
+    return 1;
+}
+
+static char *print_fourcc(const m_option_t *opt, const void *val)
+{
+    unsigned int fourcc = *(unsigned int *)val;
+    return talloc_asprintf(NULL, "%08x", fourcc);
+}
+
+const m_option_type_t m_option_type_fourcc = {
+    .name  = "FourCC",
+    .size  = sizeof(unsigned int),
+    .parse = parse_fourcc,
+    .print = print_fourcc,
+    .copy  = copy_opt,
+    .equal = int_equal,
+};
+
+#include "audio/format.h"
+
+static int parse_afmt(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    if (!bstrcmp0(param, "help")) {
+        mp_info(log, "Available formats:");
+        for (int i = 1; i < AF_FORMAT_COUNT; i++)
+            mp_info(log, " %s", af_fmt_to_str(i));
+        mp_info(log, "\n");
+        return M_OPT_EXIT;
+    }
+
+    int fmt = 0;
+    for (int i = 1; i < AF_FORMAT_COUNT; i++) {
+        if (bstr_equals0(param, af_fmt_to_str(i)))
+            fmt = i;
+    }
+    if (!fmt) {
+        mp_err(log, "Option %.*s: unknown format name: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_INVALID;
+    }
+
+    if (dst)
+        *((int *)dst) = fmt;
+
+    return 1;
+}
+
+static char *print_afmt(const m_option_t *opt, const void *val)
+{
+    int fmt = *(int *)val;
+    return talloc_strdup(NULL, fmt ? af_fmt_to_str(fmt) : "no");
+}
+
+const m_option_type_t m_option_type_afmt = {
+    .name  = "Audio format",
+    .size  = sizeof(int),
+    .parse = parse_afmt,
+    .print = print_afmt,
+    .copy  = copy_opt,
+    .equal = int_equal,
+};
+
+#include "audio/chmap.h"
+
+static int parse_channels(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    bool limited = opt->flags & M_OPT_CHANNELS_LIMITED;
+
+    struct m_channels res = {0};
+
+    if (bstr_equals0(param, "help")) {
+        mp_chmap_print_help(log);
+        if (!limited) {
+            mp_info(log, "\nOther values:\n"
+                         "    auto-safe\n");
+        }
+        return M_OPT_EXIT;
+    }
+
+    bool auto_safe = bstr_equals0(param, "auto-safe");
+    if (bstr_equals0(param, "auto") || bstr_equals0(param, "empty") || auto_safe) {
+        if (limited) {
+            mp_err(log, "Disallowed parameter.\n");
+            return M_OPT_INVALID;
+        }
+        param.len = 0;
+        res.set = true;
+        res.auto_safe = auto_safe;
+    }
+
+    while (param.len) {
+        bstr item;
+        if (limited) {
+            item = param;
+            param.len = 0;
+        } else {
+            bstr_split_tok(param, ",", &item, &param);
+        }
+
+        struct mp_chmap map = {0};
+        if (!mp_chmap_from_str(&map, item) || !mp_chmap_is_valid(&map)) {
+            mp_err(log, "Invalid channel layout: %.*s\n", BSTR_P(item));
+            talloc_free(res.chmaps);
+            return M_OPT_INVALID;
+        }
+
+        MP_TARRAY_APPEND(NULL, res.chmaps, res.num_chmaps, map);
+        res.set = true;
+    }
+
+    if (dst) {
+        *(struct m_channels *)dst = res;
+    } else {
+        talloc_free(res.chmaps);
+    }
+
+    return 1;
+}
+
+static char *print_channels(const m_option_t *opt, const void *val)
+{
+    const struct m_channels *ch = val;
+    if (!ch->set)
+        return talloc_strdup(NULL, "");
+    if (ch->auto_safe)
+        return talloc_strdup(NULL, "auto-safe");
+    if (ch->num_chmaps > 0) {
+        char *res = talloc_strdup(NULL, "");
+        for (int n = 0; n < ch->num_chmaps; n++) {
+            if (n > 0)
+                res = talloc_strdup_append(res, ",");
+            res = talloc_strdup_append(res, mp_chmap_to_str(&ch->chmaps[n]));
+        }
+        return res;
+    }
+    return talloc_strdup(NULL, "auto");
+}
+
+static void free_channels(void *src)
+{
+    if (!src)
+        return;
+
+    struct m_channels *ch = src;
+    talloc_free(ch->chmaps);
+    *ch = (struct m_channels){0};
+}
+
+static void copy_channels(const m_option_t *opt, void *dst, const void *src)
+{
+    if (!(dst && src))
+        return;
+
+    struct m_channels *ch = dst;
+    free_channels(dst);
+    *ch = *(struct m_channels *)src;
+    ch->chmaps =
+        talloc_memdup(NULL, ch->chmaps, sizeof(ch->chmaps[0]) * ch->num_chmaps);
+}
+
+static bool channels_equal(const m_option_t *opt, void *a, void *b)
+{
+    struct m_channels *ca = a;
+    struct m_channels *cb = b;
+
+    if (ca->set         != cb->set ||
+        ca->auto_safe   != cb->auto_safe ||
+        ca->num_chmaps  != cb->num_chmaps)
+        return false;
+
+    for (int n = 0; n < ca->num_chmaps; n++) {
+        if (!mp_chmap_equals(&ca->chmaps[n], &cb->chmaps[n]))
+            return false;
+    }
+
+    return true;
+}
+
+const m_option_type_t m_option_type_channels = {
+    .name  = "Audio channels or channel map",
+    .size  = sizeof(struct m_channels),
+    .parse = parse_channels,
+    .print = print_channels,
+    .copy  = copy_channels,
+    .free  = free_channels,
+    .equal = channels_equal,
+};
+
+static int parse_timestring(struct bstr str, double *time, char endchar)
+{
+    int h, m, len;
+    double s;
+    *time = 0; /* ensure initialization for error cases */
+    bool neg = bstr_eatstart0(&str, "-");
+    if (!neg)
+        bstr_eatstart0(&str, "+");
+    if (bstrchr(str, '-') >= 0 || bstrchr(str, '+') >= 0)
+        return 0; /* the timestamp shouldn't contain anymore +/- after this point */
+    if (bstr_sscanf(str, "%d:%d:%lf%n", &h, &m, &s, &len) >= 3) {
+        if (m >= 60 || s >= 60)
+            return 0; /* minutes or seconds are out of range */
+        *time = 3600 * h + 60 * m + s;
+    } else if (bstr_sscanf(str, "%d:%lf%n", &m, &s, &len) >= 2) {
+        if (s >= 60)
+            return 0; /* seconds are out of range */
+        *time = 60 * m + s;
+    } else if (bstr_sscanf(str, "%lf%n", &s, &len) >= 1) {
+        *time = s;
+    } else {
+        return 0;  /* unsupported time format */
+    }
+    if (len < str.len && str.start[len] != endchar)
+        return 0;  /* invalid extra characters at the end */
+    if (!isfinite(*time))
+        return 0;
+    if (neg)
+        *time = -*time;
+    return len;
+}
+
+#define HAS_NOPTS(opt) ((opt)->flags & M_OPT_ALLOW_NO)
+
+static int parse_time(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    double time = MP_NOPTS_VALUE;
+    if (HAS_NOPTS(opt) && bstr_equals0(param, "no")) {
+        // nothing
+    } else if (!parse_timestring(param, &time, 0)) {
+        mp_err(log, "Option %.*s: invalid time: '%.*s'\n",
+               BSTR_P(name), BSTR_P(param));
+        return M_OPT_INVALID;
+    }
+
+    if (dst)
+        *(double *)dst = time;
+    return 1;
+}
+
+static char *print_time(const m_option_t *opt, const void *val)
+{
+    double pts = *(double *)val;
+    if (pts == MP_NOPTS_VALUE && HAS_NOPTS(opt))
+        return talloc_strdup(NULL, "no"); // symmetry with parsing
+    return talloc_asprintf(NULL, "%f", pts);
+}
+
+static char *pretty_print_time(const m_option_t *opt, const void *val)
+{
+    double pts = *(double *)val;
+    if (pts == MP_NOPTS_VALUE && HAS_NOPTS(opt))
+        return talloc_strdup(NULL, "no"); // symmetry with parsing
+    return mp_format_time(pts, false);
+}
+
+static int time_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    if (HAS_NOPTS(opt) && src->format == MPV_FORMAT_STRING) {
+        if (strcmp(src->u.string, "no") == 0) {
+            *(double *)dst = MP_NOPTS_VALUE;
+            return 1;
+        }
+    }
+    return double_set(opt, dst, src);
+}
+
+static int time_get(const m_option_t *opt, void *ta_parent,
+                      struct mpv_node *dst, void *src)
+{
+    if (HAS_NOPTS(opt) && *(double *)src == MP_NOPTS_VALUE) {
+        dst->format = MPV_FORMAT_STRING;
+        dst->u.string = talloc_strdup(ta_parent, "no");
+        return 1;
+    }
+    return double_get(opt, ta_parent, dst, src);
+}
+
+const m_option_type_t m_option_type_time = {
+    .name  = "Time",
+    .size  = sizeof(double),
+    .parse = parse_time,
+    .print = print_time,
+    .pretty_print = pretty_print_time,
+    .copy  = copy_opt,
+    .add   = add_double,
+    .set   = time_set,
+    .get   = time_get,
+    .equal = double_equal,
+};
+
+
+// Relative time
+
+static int parse_rel_time(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param, void *dst)
+{
+    struct m_rel_time t = {0};
+
+    if (param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    if (bstr_equals0(param, "none")) {
+        t.type = REL_TIME_NONE;
+        goto out;
+    }
+
+    // Percent pos
+    if (bstr_endswith0(param, "%")) {
+        double percent = bstrtod(bstr_splice(param, 0, -1), &param);
+        if (param.len == 0 && percent >= 0 && percent <= 100) {
+            t.type = REL_TIME_PERCENT;
+            t.pos = percent;
+            goto out;
+        }
+    }
+
+    // Chapter pos
+    if (bstr_startswith0(param, "#")) {
+        int chapter = bstrtoll(bstr_cut(param, 1), &param, 10);
+        if (param.len == 0 && chapter >= 1) {
+            t.type = REL_TIME_CHAPTER;
+            t.pos = chapter - 1;
+            goto out;
+        }
+    }
+
+    double time;
+    if (parse_timestring(param, &time, 0)) {
+        if (bstr_startswith0(param, "+") || bstr_startswith0(param, "-")) {
+            t.type = REL_TIME_RELATIVE;
+        } else {
+            t.type = REL_TIME_ABSOLUTE;
+        }
+        t.pos = time;
+        goto out;
+    }
+
+    mp_err(log, "Option %.*s: invalid time or position: '%.*s'\n",
+           BSTR_P(name), BSTR_P(param));
+    return M_OPT_INVALID;
+
+out:
+    if (dst)
+        *(struct m_rel_time *)dst = t;
+    return 1;
+}
+
+static char *print_rel_time(const m_option_t *opt, const void *val)
+{
+    const struct m_rel_time *t = val;
+    switch(t->type) {
+    case REL_TIME_ABSOLUTE:
+        return talloc_asprintf(NULL, "%g", t->pos);
+    case REL_TIME_RELATIVE:
+        return talloc_asprintf(NULL, "%s%g",
+            (t->pos >= 0) ? "+" : "-", fabs(t->pos));
+    case REL_TIME_CHAPTER:
+        return talloc_asprintf(NULL, "#%g", t->pos);
+    case REL_TIME_PERCENT:
+        return talloc_asprintf(NULL, "%g%%", t->pos);
+    }
+    return talloc_strdup(NULL, "none");
+}
+
+static bool rel_time_equal(const m_option_t *opt, void *a, void *b)
+{
+    struct m_rel_time *ta = a;
+    struct m_rel_time *tb = b;
+    return ta->type == tb->type && ta->pos == tb->pos;
+}
+
+const m_option_type_t m_option_type_rel_time = {
+    .name  = "Relative time or percent position",
+    .size  = sizeof(struct m_rel_time),
+    .parse = parse_rel_time,
+    .print = print_rel_time,
+    .copy  = copy_opt,
+    .equal = rel_time_equal,
+};
+
+
+//// Objects (i.e. filters, etc) settings
+
+#undef VAL
+#define VAL(x) (*(m_obj_settings_t **)(x))
+
+bool m_obj_list_find(struct m_obj_desc *dst, const struct m_obj_list *l,
+                     bstr name)
+{
+    for (int i = 0; ; i++) {
+        if (!l->get_desc(dst, i))
+            break;
+        if (bstr_equals0(name, dst->name))
+            return true;
+    }
+    for (int i = 0; l->aliases[i][0]; i++) {
+        const char *aname = l->aliases[i][0];
+        const char *alias = l->aliases[i][1];
+        if (bstr_equals0(name, aname) && m_obj_list_find(dst, l, bstr0(alias)))
+        {
+            dst->replaced_name = aname;
+            return true;
+        }
+    }
+    return false;
+}
+
+static void obj_setting_free(m_obj_settings_t *item)
+{
+    talloc_free(item->name);
+    talloc_free(item->label);
+    free_str_list(&(item->attribs));
+}
+
+// If at least one item has a label, compare labels only - otherwise ignore them.
+static bool obj_setting_match(m_obj_settings_t *a, m_obj_settings_t *b)
+{
+    bstr la = bstr0(a->label), lb = bstr0(b->label);
+    if (la.len || lb.len)
+        return bstr_equals(la, lb);
+
+    return m_obj_settings_equal(a, b);
+}
+
+static int obj_settings_list_num_items(m_obj_settings_t *obj_list)
+{
+    int num = 0;
+    while (obj_list && obj_list[num].name)
+        num++;
+    return num;
+}
+
+static void obj_settings_list_del_at(m_obj_settings_t **p_obj_list, int idx)
+{
+    m_obj_settings_t *obj_list = *p_obj_list;
+    int num = obj_settings_list_num_items(obj_list);
+
+    assert(idx >= 0 && idx < num);
+
+    obj_setting_free(&obj_list[idx]);
+
+    // Note: the NULL-terminating element is moved down as part of this
+    memmove(&obj_list[idx], &obj_list[idx + 1],
+            sizeof(m_obj_settings_t) * (num - idx));
+
+    *p_obj_list = talloc_realloc(NULL, obj_list, struct m_obj_settings, num);
+}
+
+// Insert such that *p_obj_list[idx] is set to item.
+// If idx < 0, set idx = count + idx + 1 (i.e. -1 inserts it as last element).
+// Memory referenced by *item is not copied.
+static void obj_settings_list_insert_at(m_obj_settings_t **p_obj_list, int idx,
+                                        m_obj_settings_t *item)
+{
+    int num = obj_settings_list_num_items(*p_obj_list);
+    if (idx < 0)
+        idx = num + idx + 1;
+    assert(idx >= 0 && idx <= num);
+    *p_obj_list = talloc_realloc(NULL, *p_obj_list, struct m_obj_settings,
+                                 num + 2);
+    memmove(*p_obj_list + idx + 1, *p_obj_list + idx,
+            (num - idx) * sizeof(m_obj_settings_t));
+    (*p_obj_list)[idx] = *item;
+    (*p_obj_list)[num + 1] = (m_obj_settings_t){0};
+}
+
+static int obj_settings_list_find_by_label(m_obj_settings_t *obj_list,
+                                           bstr label)
+{
+    for (int n = 0; obj_list && obj_list[n].name; n++) {
+        if (label.len && bstr_equals0(label, obj_list[n].label))
+            return n;
+    }
+    return -1;
+}
+
+static int obj_settings_list_find_by_label0(m_obj_settings_t *obj_list,
+                                            const char *label)
+{
+    return obj_settings_list_find_by_label(obj_list, bstr0(label));
+}
+
+static int obj_settings_find_by_content(m_obj_settings_t *obj_list,
+                                        m_obj_settings_t *item)
+{
+    for (int n = 0; obj_list && obj_list[n].name; n++) {
+        if (obj_setting_match(&obj_list[n], item))
+            return n;
+    }
+    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++)
+        obj_setting_free(&d[n]);
+    talloc_free(d);
+    VAL(dst) = NULL;
+}
+
+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].label = talloc_strdup(NULL, s[n].label);
+        d[n].enabled = s[n].enabled;
+        d[n].attribs = NULL;
+        copy_str_list(NULL, &(d[n].attribs), &(s[n].attribs));
+    }
+    d[n].name = NULL;
+    d[n].label = NULL;
+    d[n].attribs = NULL;
+    VAL(dst) = d;
+}
+
+// Consider -vf a=b=c:d=e. This verifies "b"="c" and "d"="e" and that the
+// option names/values are correct. Try to determine whether an option
+// without '=' sets a flag, or whether it's a positional argument.
+static int get_obj_param(struct mp_log *log, bstr opt_name, bstr obj_name,
+                         struct m_config *config, bstr name, bstr val,
+                         int flags, bool nopos,
+                         int *nold, bstr *out_name, bstr *out_val,
+                         char *tmp, size_t tmp_size)
+{
+    int r;
+
+    if (!config) {
+        // Duplicates the logic below, but with unknown parameter types/names.
+        if (val.start || nopos) {
+            *out_name = name;
+            *out_val = val;
+        } else {
+            val = name;
+            // positional fields
+            if (val.len == 0) { // Empty field, count it and go on
+                (*nold)++;
+                return 0;
+            }
+            // Positional naming convention for/followed by mp_set_avopts().
+            snprintf(tmp, tmp_size, "@%d", *nold);
+            *out_name = bstr0(tmp);
+            *out_val = val;
+            (*nold)++;
+        }
+        return 1;
+    }
+
+    // val.start != NULL => of the form name=val (not positional)
+    // If it's just "name", and the associated option exists and is a flag,
+    // don't accept it as positional argument.
+    if (val.start || m_config_option_requires_param(config, name) == 0 || nopos) {
+        r = m_config_set_option_cli(config, name, val, flags);
+        if (r < 0) {
+            if (r == M_OPT_UNKNOWN) {
+                mp_err(log, "Option %.*s: %.*s doesn't have a %.*s parameter.\n",
+                       BSTR_P(opt_name), BSTR_P(obj_name), BSTR_P(name));
+                return M_OPT_UNKNOWN;
+            }
+            if (r != M_OPT_EXIT)
+                mp_err(log, "Option %.*s: "
+                       "Error while parsing %.*s parameter %.*s (%.*s)\n",
+                       BSTR_P(opt_name), BSTR_P(obj_name), BSTR_P(name),
+                       BSTR_P(val));
+            return r;
+        }
+        *out_name = name;
+        *out_val = val;
+        return 1;
+    } else {
+        val = name;
+        // positional fields
+        if (val.len == 0) { // Empty field, count it and go on
+            (*nold)++;
+            return 0;
+        }
+        const char *opt = m_config_get_positional_option(config, *nold);
+        if (!opt) {
+            mp_err(log, "Option %.*s: %.*s has only %d "
+                   "params, so you can't give more than %d unnamed params.\n",
+                   BSTR_P(opt_name), BSTR_P(obj_name), *nold, *nold);
+            return M_OPT_OUT_OF_RANGE;
+        }
+        r = m_config_set_option_cli(config, bstr0(opt), val, flags);
+        if (r < 0) {
+            if (r != M_OPT_EXIT)
+                mp_err(log, "Option %.*s: "
+                       "Error while parsing %.*s parameter %s (%.*s)\n",
+                       BSTR_P(opt_name), BSTR_P(obj_name), opt, BSTR_P(val));
+            return r;
+        }
+        *out_name = bstr0(opt);
+        *out_val = val;
+        (*nold)++;
+        return 1;
+    }
+}
+
+// Consider -vf a=b:c:d. This parses "b:c:d" into name/value pairs, stored as
+// linear array in *_ret. In particular, config contains what options a the
+// object takes, and verifies the option values as well.
+// If config is NULL, all parameters are accepted without checking.
+// _ret set to NULL can be used for checking-only.
+// flags can contain any M_SETOPT_* flag.
+// desc is optional.
+static int m_obj_parse_sub_config(struct mp_log *log, struct bstr opt_name,
+                                  struct bstr name, struct bstr *pstr,
+                                  struct m_config *config, int flags, bool nopos,
+                                  struct m_obj_desc *desc,
+                                  const struct m_obj_list *list, char ***ret)
+{
+    int nold = 0;
+    char **args = NULL;
+    int num_args = 0;
+    int r = 1;
+    char tmp[80];
+
+    if (ret) {
+        args = *ret;
+        while (args && args[num_args])
+            num_args++;
+    }
+
+    while (pstr->len > 0) {
+        bstr fname, fval;
+        r = split_subconf(log, opt_name, pstr, &fname, &fval);
+        if (r < 0)
+            goto exit;
+
+        if (list->use_global_options) {
+            mp_err(log, "Option %.*s: this option does not accept sub-options.\n",
+                   BSTR_P(opt_name));
+            mp_err(log, "Sub-options for --vo and --ao were removed from mpv in "
+                   "release 0.23.0.\nSee https://0x0.st/uM for details.\n");
+            r = M_OPT_INVALID;
+            goto exit;
+        }
+
+        if (bstr_equals0(fname, "help"))
+            goto print_help;
+        r = get_obj_param(log, opt_name, name, config, fname, fval, flags,
+                          nopos, &nold, &fname, &fval, tmp, sizeof(tmp));
+        if (r < 0)
+            goto exit;
+
+        if (r > 0 && ret) {
+            MP_TARRAY_APPEND(NULL, args, num_args, bstrto0(NULL, fname));
+            MP_TARRAY_APPEND(NULL, args, num_args, bstrto0(NULL, fval));
+            MP_TARRAY_APPEND(NULL, args, num_args, NULL);
+            MP_TARRAY_APPEND(NULL, args, num_args, NULL);
+            num_args -= 2;
+        }
+
+        if (!bstr_eatstart0(pstr, ":"))
+            break;
+    }
+
+    if (ret) {
+        if (num_args > 0) {
+            *ret = args;
+            args = NULL;
+        } else {
+            *ret = NULL;
+        }
+    }
+
+    goto exit;
+
+print_help: ;
+    if (config) {
+        if (desc->print_help)
+            desc->print_help(log);
+        m_config_print_option_list(config, "*");
+    } else if (list->print_unknown_entry_help) {
+        list->print_unknown_entry_help(log, mp_tprintf(80, "%.*s", BSTR_P(name)));
+    } else {
+        mp_warn(log, "Option %.*s: item %.*s doesn't exist.\n",
+               BSTR_P(opt_name), BSTR_P(name));
+    }
+    r = M_OPT_EXIT;
+
+exit:
+    free_str_list(&args);
+    return r;
+}
+
+// Characters which may appear in a filter name
+#define NAMECH "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-"
+
+// Parse one item, e.g. -vf a=b:c:d,e=f:g => parse a=b:c:d into "a" and "b:c:d"
+static int parse_obj_settings(struct mp_log *log, struct bstr opt, int op,
+                              struct bstr *pstr, const struct m_obj_list *list,
+                              m_obj_settings_t **_ret)
+{
+    int r;
+    char **plist = NULL;
+    struct m_obj_desc desc;
+    bstr str = {0};
+    bstr label = {0};
+    bool nopos = list->disallow_positional_parameters;
+    bool enabled = true;
+
+    if (bstr_eatstart0(pstr, "@")) {
+        bstr rest;
+        if (!bstr_split_tok(*pstr, ":", &label, &rest)) {
+            // "@labelname" is the special enable/disable toggle syntax
+            if (op == OP_TOGGLE) {
+                int idx = bstrspn(*pstr, NAMECH);
+                label = bstr_splice(*pstr, 0, idx);
+                if (label.len) {
+                    *pstr = bstr_cut(*pstr, idx);
+                    goto done;
+                }
+            }
+            mp_err(log, "Option %.*s: ':' expected after label.\n", BSTR_P(opt));
+            return M_OPT_INVALID;
+        }
+        *pstr = rest;
+        if (label.len == 0) {
+            mp_err(log, "Option %.*s: label name expected.\n", BSTR_P(opt));
+            return M_OPT_INVALID;
+        }
+    }
+
+    if (list->allow_disable_entries && bstr_eatstart0(pstr, "!"))
+        enabled = false;
+
+    bool has_param = false;
+    int idx = bstrspn(*pstr, NAMECH);
+    str = bstr_splice(*pstr, 0, idx);
+    if (!str.len) {
+        mp_err(log, "Option %.*s: filter name expected.\n", BSTR_P(opt));
+        return M_OPT_INVALID;
+    }
+    *pstr = bstr_cut(*pstr, idx);
+    // video filters use "=", VOs use ":"
+    if (bstr_eatstart0(pstr, "=") || bstr_eatstart0(pstr, ":"))
+        has_param = true;
+
+    bool skip = false;
+    if (m_obj_list_find(&desc, list, str)) {
+        if (desc.replaced_name)
+            mp_warn(log, "Driver '%s' has been replaced with '%s'!\n",
+                   desc.replaced_name, desc.name);
+    } else {
+        char name[80];
+        snprintf(name, sizeof(name), "%.*s", BSTR_P(str));
+        if (list->check_unknown_entry && !list->check_unknown_entry(name)) {
+            mp_err(log, "Option %.*s: %.*s doesn't exist.\n",
+                   BSTR_P(opt), BSTR_P(str));
+            return M_OPT_INVALID;
+        }
+        desc = (struct m_obj_desc){0};
+        skip = true;
+    }
+
+    if (has_param) {
+        struct m_config *config = NULL;
+        if (!skip)
+            config = m_config_from_obj_desc_noalloc(NULL, log, &desc);
+        r = m_obj_parse_sub_config(log, opt, str, pstr, config,
+                                   M_SETOPT_CHECK_ONLY, nopos, &desc, list,
+                                   _ret ? &plist : NULL);
+        talloc_free(config);
+        if (r < 0)
+            return r;
+    }
+    if (!_ret)
+        return 1;
+
+done: ;
+    m_obj_settings_t item = {
+        .name = bstrto0(NULL, str),
+        .label = bstrdup0(NULL, label),
+        .enabled = enabled,
+        .attribs = plist,
+    };
+    obj_settings_list_insert_at(_ret, -1, &item);
+    return 1;
+}
+
+// Parse a single entry for -vf-remove (return 0 if not applicable)
+// mark_del is bounded by the number of items in dst
+static int parse_obj_settings_del(struct mp_log *log, struct bstr opt_name,
+                                  struct bstr *param, void *dst, bool *mark_del)
+{
+    bstr s = *param;
+    if (bstr_eatstart0(&s, "@")) {
+        // '@name:' -> parse as normal filter entry
+        // '@name,' or '@name<end>' -> parse here
+        int idx = bstrspn(s, NAMECH);
+        bstr label = bstr_splice(s, 0, idx);
+        s = bstr_cut(s, idx);
+        if (bstr_startswith0(s, ":"))
+            return 0;
+        if (dst) {
+            int label_index = 0;
+            label_index = obj_settings_list_find_by_label(VAL(dst), label);
+            if (label_index >= 0) {
+                mark_del[label_index] = true;
+            } else {
+                mp_warn(log, "Option %.*s: item label @%.*s not found.\n",
+                        BSTR_P(opt_name), BSTR_P(label));
+            }
+        }
+        *param = s;
+        return 1;
+    }
+    return 0;
+}
+
+static int parse_obj_settings_list(struct mp_log *log, const m_option_t *opt,
+                                   struct bstr name, struct bstr param, void *dst)
+{
+    m_obj_settings_t *res = NULL;
+    int op = OP_NONE;
+    bool *mark_del = NULL;
+    int num_items = obj_settings_list_num_items(dst ? VAL(dst) : 0);
+    const struct m_obj_list *ol = opt->priv;
+
+    assert(opt->priv);
+
+    if (bstr_endswith0(name, "-add")) {
+        op = OP_ADD;
+    } else if (bstr_endswith0(name, "-append")) {
+        op = OP_APPEND;
+    } else if (bstr_endswith0(name, "-set")) {
+        op = OP_NONE;
+    } else if (bstr_endswith0(name, "-pre")) {
+        op = OP_PRE;
+    } else if (bstr_endswith0(name, "-remove")) {
+        op = OP_REMOVE;
+    } else if (bstr_endswith0(name, "-clr")) {
+        op = OP_CLR;
+    } else if (bstr_endswith0(name, "-toggle")) {
+        op = OP_TOGGLE;
+    } else if (bstr_endswith0(name, "-help")) {
+        mp_err(log, "Option %s:\n"
+                "Supported operations are:\n"
+                "  %s-set\n"
+                " Overwrite the old list with the given list\n\n"
+                "  %s-append\n"
+                " Append the given filter to the current list\n\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-remove\n"
+                " Remove the given filter from the current list\n\n"
+                "  %s-toggle\n"
+                " Add the filter to the list, or remove it if it's already added.\n\n"
+                "  %s-clr\n"
+                " Clear the current list.\n\n",
+                opt->name, opt->name, opt->name, opt->name, opt->name,
+                opt->name, opt->name, opt->name);
+
+        return M_OPT_EXIT;
+    }
+
+    if (!bstrcmp0(param, "help")) {
+        mp_info(log, "Available %s:\n", ol->description);
+        for (int n = 0; ; n++) {
+            struct m_obj_desc desc;
+            if (!ol->get_desc(&desc, n))
+                break;
+            if (!desc.hidden) {
+                mp_info(log, "  %-16s %s\n",
+                       desc.name, desc.description);
+            }
+        }
+        mp_info(log, "\n");
+        if (ol->print_help_list)
+            ol->print_help_list(log);
+        if (!ol->use_global_options) {
+            mp_info(log, "Get help on individual entries via: --%s=entry=help\n",
+                    opt->name);
+        }
+        return M_OPT_EXIT;
+    }
+
+    if (op == OP_CLR) {
+        if (param.len) {
+            mp_err(log, "Option %.*s: -clr does not take an argument.\n",
+                   BSTR_P(name));
+            return M_OPT_INVALID;
+        }
+        if (dst)
+            free_obj_settings_list(dst);
+        return 0;
+    } else if (op == OP_REMOVE) {
+        mark_del = talloc_zero_array(NULL, bool, num_items + 1);
+    }
+
+    if (op != OP_NONE && param.len == 0)
+        return M_OPT_MISSING_PARAM;
+
+    while (param.len > 0) {
+        int r = 0;
+        if (op == OP_REMOVE)
+            r = parse_obj_settings_del(log, name, &param, dst, mark_del);
+        if (r == 0) {
+            r = parse_obj_settings(log, name, op, &param, ol, dst ? &res : NULL);
+        }
+        if (r < 0)
+            return r;
+        if (param.len > 0) {
+            const char sep[2] = {OPTION_LIST_SEPARATOR, 0};
+            if (!bstr_eatstart0(&param, sep))
+                return M_OPT_INVALID;
+            if (param.len == 0) {
+                if (!ol->allow_trailer)
+                    return M_OPT_INVALID;
+                if (dst) {
+                    m_obj_settings_t item = {
+                        .name = talloc_strdup(NULL, ""),
+                    };
+                    obj_settings_list_insert_at(&res, -1, &item);
+                }
+            }
+        }
+    }
+
+    if (op != OP_NONE && res && res[0].name && res[1].name) {
+        if (op == OP_APPEND) {
+            mp_err(log, "Option %.*s: -append takes only 1 filter (no ',').\n",
+                   BSTR_P(name));
+            return M_OPT_INVALID;
+        }
+        mp_warn(log, "Passing more than 1 argument to %.*s is deprecated!\n",
+                BSTR_P(name));
+    }
+
+    if (dst) {
+        m_obj_settings_t *list = VAL(dst);
+        if (op == OP_PRE) {
+            int prepend_counter = 0;
+            for (int n = 0; res && res[n].name; n++) {
+                int label = obj_settings_list_find_by_label0(list, res[n].label);
+                if (label < 0) {
+                    obj_settings_list_insert_at(&list, prepend_counter, &res[n]);
+                    prepend_counter++;
+                } else {
+                    // Prefer replacement semantics, instead of actually
+                    // prepending.
+                    obj_setting_free(&list[label]);
+                    list[label] = res[n];
+                }
+            }
+            talloc_free(res);
+        } else if (op == OP_ADD || op == OP_APPEND) {
+            for (int n = 0; res && res[n].name; n++) {
+                int label = obj_settings_list_find_by_label0(list, res[n].label);
+                if (label < 0) {
+                    obj_settings_list_insert_at(&list, -1, &res[n]);
+                } else {
+                    // Prefer replacement semantics, instead of actually
+                    // appending.
+                    obj_setting_free(&list[label]);
+                    list[label] = res[n];
+                }
+            }
+            talloc_free(res);
+        } else if (op == OP_TOGGLE) {
+            for (int n = 0; res && res[n].name; n++) {
+                if (res[n].label && !res[n].name[0]) {
+                    // Toggle enable/disable special case.
+                    int found =
+                        obj_settings_list_find_by_label0(list, res[n].label);
+                    if (found < 0) {
+                        mp_warn(log, "Option %.*s: Label %s not found\n",
+                                BSTR_P(name), res[n].label);
+                    } else {
+                        list[found].enabled = !list[found].enabled;
+                    }
+                    obj_setting_free(&res[n]);
+                } else {
+                    int found = obj_settings_find_by_content(list, &res[n]);
+                    if (found < 0) {
+                        obj_settings_list_insert_at(&list, -1, &res[n]);
+                    } else {
+                        obj_settings_list_del_at(&list, found);
+                        obj_setting_free(&res[n]);
+                    }
+                }
+            }
+            talloc_free(res);
+        } else if (op == OP_REMOVE) {
+            for (int n = num_items - 1; n >= 0; n--) {
+                if (mark_del[n])
+                    obj_settings_list_del_at(&list, n);
+            }
+            for (int n = 0; res && res[n].name; n++) {
+                int found = obj_settings_find_by_content(list, &res[n]);
+                if (found >= 0)
+                    obj_settings_list_del_at(&list, found);
+            }
+            free_obj_settings_list(&res);
+        } else {
+            assert(op == OP_NONE);
+            free_obj_settings_list(&list);
+            list = res;
+        }
+        VAL(dst) = list;
+    }
+
+    talloc_free(mark_del);
+    return 1;
+}
+
+static void append_param(char **res, char *param)
+{
+    if (strspn(param, NAMECH) == strlen(param)) {
+        *res = talloc_strdup_append(*res, param);
+    } else {
+        // Simple escaping: %BYTECOUNT%STRING
+        *res = talloc_asprintf_append(*res, "%%%zd%%%s", strlen(param), param);
+    }
+}
+
+static char *print_obj_settings_list(const m_option_t *opt, const void *val)
+{
+    m_obj_settings_t *list = VAL(val);
+    char *res = talloc_strdup(NULL, "");
+    for (int n = 0; list && list[n].name; n++) {
+        m_obj_settings_t *entry = &list[n];
+        if (n > 0)
+            res = talloc_strdup_append(res, ",");
+        // Assume labels and names don't need escaping
+        if (entry->label && entry->label[0])
+            res = talloc_asprintf_append(res, "@%s:", entry->label);
+        if (!entry->enabled)
+            res = talloc_strdup_append(res, "!");
+        res = talloc_strdup_append(res, entry->name);
+        if (entry->attribs && entry->attribs[0]) {
+            res = talloc_strdup_append(res, "=");
+            for (int i = 0; entry->attribs[i * 2 + 0]; i++) {
+                if (i > 0)
+                    res = talloc_strdup_append(res, ":");
+                append_param(&res, entry->attribs[i * 2 + 0]);
+                res = talloc_strdup_append(res, "=");
+                append_param(&res, entry->attribs[i * 2 + 1]);
+            }
+        }
+    }
+    return res;
+}
+
+static int set_obj_settings_list(const m_option_t *opt, void *dst,
+                                 struct mpv_node *src)
+{
+    if (src->format != MPV_FORMAT_NODE_ARRAY)
+        return M_OPT_INVALID;
+    m_obj_settings_t *entries =
+        talloc_zero_array(NULL, m_obj_settings_t, src->u.list->num + 1);
+    for (int n = 0; n < src->u.list->num; n++) {
+        m_obj_settings_t *entry = &entries[n];
+        entry->enabled = true;
+        if (src->u.list->values[n].format != MPV_FORMAT_NODE_MAP)
+            goto error;
+        struct mpv_node_list *src_entry = src->u.list->values[n].u.list;
+        for (int i = 0; i < src_entry->num; i++) {
+            const char *key = src_entry->keys[i];
+            struct mpv_node *val = &src_entry->values[i];
+            if (strcmp(key, "name") == 0) {
+                if (val->format != MPV_FORMAT_STRING)
+                    goto error;
+                entry->name = talloc_strdup(NULL, val->u.string);
+            } else if (strcmp(key, "label") == 0) {
+                if (val->format != MPV_FORMAT_STRING)
+                    goto error;
+                entry->label = talloc_strdup(NULL, val->u.string);
+            } else if (strcmp(key, "enabled") == 0) {
+                if (val->format != MPV_FORMAT_FLAG)
+                    goto error;
+                entry->enabled = val->u.flag;
+            } else if (strcmp(key, "params") == 0) {
+                if (val->format != MPV_FORMAT_NODE_MAP)
+                    goto error;
+                struct mpv_node_list *src_params = val->u.list;
+                entry->attribs =
+                    talloc_zero_array(NULL, char*, (src_params->num + 1) * 2);
+                for (int x = 0; x < src_params->num; x++) {
+                    if (src_params->values[x].format != MPV_FORMAT_STRING)
+                        goto error;
+                    entry->attribs[x * 2 + 0] =
+                        talloc_strdup(NULL, src_params->keys[x]);
+                    entry->attribs[x * 2 + 1] =
+                        talloc_strdup(NULL, src_params->values[x].u.string);
+                }
+            }
+        }
+    }
+    free_obj_settings_list(dst);
+    VAL(dst) = entries;
+    return 0;
+error:
+    free_obj_settings_list(&entries);
+    return M_OPT_INVALID;
+}
+
+static struct mpv_node *add_array_entry(struct mpv_node *dst)
+{
+    struct mpv_node_list *list = dst->u.list;
+    assert(dst->format == MPV_FORMAT_NODE_ARRAY&& dst->u.list);
+    MP_TARRAY_GROW(list, list->values, list->num);
+    return &list->values[list->num++];
+}
+
+static struct mpv_node *add_map_entry(struct mpv_node *dst, const char *key)
+{
+    struct mpv_node_list *list = dst->u.list;
+    assert(dst->format == MPV_FORMAT_NODE_MAP && dst->u.list);
+    MP_TARRAY_GROW(list, list->values, list->num);
+    MP_TARRAY_GROW(list, list->keys, list->num);
+    list->keys[list->num] = talloc_strdup(list, key);
+    return &list->values[list->num++];
+}
+
+static void add_map_string(struct mpv_node *dst, const char *key, const char *val)
+{
+    struct mpv_node *entry = add_map_entry(dst, key);
+    entry->format = MPV_FORMAT_STRING;
+    entry->u.string = talloc_strdup(dst->u.list, val);
+}
+
+static int get_obj_settings_list(const m_option_t *opt, void *ta_parent,
+                                 struct mpv_node *dst, void *val)
+{
+    m_obj_settings_t *list = VAL(val);
+    dst->format = MPV_FORMAT_NODE_ARRAY;
+    dst->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+    ta_parent = dst->u.list;
+    for (int n = 0; list && list[n].name; n++) {
+        m_obj_settings_t *entry = &list[n];
+        struct mpv_node *nentry = add_array_entry(dst);
+        nentry->format = MPV_FORMAT_NODE_MAP;
+        nentry->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+        add_map_string(nentry, "name", entry->name);
+        if (entry->label && entry->label[0])
+            add_map_string(nentry, "label", entry->label);
+        struct mpv_node *enabled = add_map_entry(nentry, "enabled");
+        enabled->format = MPV_FORMAT_FLAG;
+        enabled->u.flag = entry->enabled;
+        struct mpv_node *params = add_map_entry(nentry, "params");
+        params->format = MPV_FORMAT_NODE_MAP;
+        params->u.list = talloc_zero(ta_parent, struct mpv_node_list);
+        for (int i = 0; entry->attribs && entry->attribs[i * 2 + 0]; i++) {
+            add_map_string(params, entry->attribs[i * 2 + 0],
+                                   entry->attribs[i * 2 + 1]);
+        }
+    }
+    return 1;
+}
+
+static bool obj_settings_list_equal(const m_option_t *opt, void *pa, void *pb)
+{
+    struct m_obj_settings *a = VAL(pa);
+    struct m_obj_settings *b = VAL(pb);
+
+    if (a == b || !a || !b)
+        return a == b || (!a && !b[0].name) || (!b && !a[0].name);
+
+    for (int n = 0; a[n].name || b[n].name; n++) {
+        if (!a[n].name || !b[n].name)
+            return false;
+        if (!m_obj_settings_equal(&a[n], &b[n]))
+            return false;
+    }
+
+    return true;
+}
+
+bool m_obj_settings_equal(struct m_obj_settings *a, struct m_obj_settings *b)
+{
+    if (!str_equal(NULL, &a->name, &b->name))
+        return false;
+
+    if (!str_equal(NULL, &a->label, &b->label))
+        return false;
+
+    if (a->enabled != b->enabled)
+        return false;
+
+    return str_list_equal(NULL, &a->attribs, &b->attribs);
+}
+
+const m_option_type_t m_option_type_obj_settings_list = {
+    .name  = "Object settings list",
+    .size  = sizeof(m_obj_settings_t *),
+    .parse = parse_obj_settings_list,
+    .print = print_obj_settings_list,
+    .copy  = copy_obj_settings_list,
+    .free  = free_obj_settings_list,
+    .set   = set_obj_settings_list,
+    .get   = get_obj_settings_list,
+    .equal = obj_settings_list_equal,
+    .actions = (const struct m_option_action[]){
+        {"add"},
+        {"append"},
+        {"clr",     M_OPT_TYPE_OPTIONAL_PARAM},
+        {"help",    M_OPT_TYPE_OPTIONAL_PARAM},
+        {"pre"},
+        {"set"},
+        {"toggle"},
+        {"remove"},
+        {0}
+    },
+};
+
+#undef VAL
+#define VAL(x) (*(struct mpv_node *)(x))
+
+static int parse_node(struct mp_log *log, const m_option_t *opt,
+                      struct bstr name, struct bstr param, void *dst)
+{
+    // Maybe use JSON?
+    mp_err(log, "option type doesn't accept strings");
+    return M_OPT_INVALID;
+}
+
+static char *print_node(const m_option_t *opt, const void *val)
+{
+    char *t = talloc_strdup(NULL, "");
+    if (json_write(&t, &VAL(val)) < 0) {
+        talloc_free(t);
+        t = NULL;
+    }
+    return t;
+}
+
+static char *pretty_print_node(const m_option_t *opt, const void *val)
+{
+    char *t = talloc_strdup(NULL, "");
+    if (json_write_pretty(&t, &VAL(val)) < 0) {
+        talloc_free(t);
+        t = NULL;
+    }
+    return t;
+}
+
+static void dup_node(void *ta_parent, struct mpv_node *node)
+{
+    switch (node->format) {
+    case MPV_FORMAT_STRING:
+        node->u.string = talloc_strdup(ta_parent, node->u.string);
+        break;
+    case MPV_FORMAT_NODE_ARRAY:
+    case MPV_FORMAT_NODE_MAP: {
+        struct mpv_node_list *oldlist = node->u.list;
+        struct mpv_node_list *new = talloc_zero(ta_parent, struct mpv_node_list);
+        node->u.list = new;
+        if (oldlist->num > 0) {
+            *new = *oldlist;
+            new->values = talloc_array(new, struct mpv_node, new->num);
+            for (int n = 0; n < new->num; n++) {
+                new->values[n] = oldlist->values[n];
+                dup_node(new, &new->values[n]);
+            }
+            if (node->format == MPV_FORMAT_NODE_MAP) {
+                new->keys = talloc_array(new, char*, new->num);
+                for (int n = 0; n < new->num; n++)
+                    new->keys[n] = talloc_strdup(new, oldlist->keys[n]);
+            }
+        }
+        break;
+    }
+    case MPV_FORMAT_BYTE_ARRAY: {
+        struct mpv_byte_array *old = node->u.ba;
+        struct mpv_byte_array *new = talloc_zero(ta_parent, struct mpv_byte_array);
+        node->u.ba = new;
+        if (old->size > 0) {
+            *new = *old;
+            new->data = talloc_memdup(new, old->data, old->size);
+        }
+        break;
+    }
+    case MPV_FORMAT_NONE:
+    case MPV_FORMAT_FLAG:
+    case MPV_FORMAT_INT64:
+    case MPV_FORMAT_DOUBLE:
+        break;
+    default:
+        // unknown entry - mark as invalid
+        node->format = (mpv_format)-1;
+    }
+}
+
+static void copy_node(const m_option_t *opt, void *dst, const void *src)
+{
+    assert(sizeof(struct mpv_node) <= sizeof(union m_option_value));
+
+    if (!(dst && src))
+        return;
+
+    opt->type->free(dst);
+    VAL(dst) = VAL(src);
+    dup_node(NULL, &VAL(dst));
+}
+
+void *node_get_alloc(struct mpv_node *node)
+{
+    // Assume it was allocated with copy_node(), which allocates all
+    // sub-nodes with the parent node as talloc parent.
+    switch (node->format) {
+    case MPV_FORMAT_STRING:
+        return node->u.string;
+    case MPV_FORMAT_NODE_ARRAY:
+    case MPV_FORMAT_NODE_MAP:
+        return node->u.list;
+    default:
+        return NULL;
+    }
+}
+
+static void free_node(void *src)
+{
+    if (src) {
+        struct mpv_node *node = &VAL(src);
+        talloc_free(node_get_alloc(node));
+        *node = (struct mpv_node){{0}};
+    }
+}
+
+// idempotent functions for convenience
+static int node_set(const m_option_t *opt, void *dst, struct mpv_node *src)
+{
+    copy_node(opt, dst, src);
+    return 1;
+}
+
+static int node_get(const m_option_t *opt, void *ta_parent,
+                    struct mpv_node *dst, void *src)
+{
+    *dst = VAL(src);
+    dup_node(ta_parent, dst);
+    return 1;
+}
+
+static bool node_equal(const m_option_t *opt, void *a, void *b)
+{
+    return equal_mpv_node(&VAL(a), &VAL(b));
+}
+
+const m_option_type_t m_option_type_node = {
+    .name  = "Complex",
+    .size  = sizeof(struct mpv_node),
+    .parse = parse_node,
+    .print = print_node,
+    .pretty_print = pretty_print_node,
+    .copy  = copy_node,
+    .free  = free_node,
+    .set   = node_set,
+    .get   = node_get,
+    .equal = node_equal,
+};
+
+// Special-cased by m_config.c.
+const m_option_type_t m_option_type_alias = {
+    .name  = "alias",
+};
+const m_option_type_t m_option_type_cli_alias = {
+    .name  = "alias",
+};
+const m_option_type_t m_option_type_removed = {
+    .name  = "removed",
+};
+const m_option_type_t m_option_type_subconfig = {
+    .name = "Subconfig",
+};
diff --git a/options/m_option.h b/options/m_option.h
new file mode 100644
index 0000000..e62fa0f
--- /dev/null
+++ b/options/m_option.h
@@ -0,0 +1,764 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_M_OPTION_H
+#define MPLAYER_M_OPTION_H
+
+#include <float.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "misc/bstr.h"
+#include "audio/chmap.h"
+#include "common/common.h"
+
+// m_option allows to parse, print and copy data of various types.
+
+typedef struct m_option_type m_option_type_t;
+typedef struct m_option m_option_t;
+struct m_config;
+struct mp_log;
+struct mpv_node;
+struct mpv_global;
+
+///////////////////////////// Options types declarations ////////////////////
+
+// Simple types
+extern const m_option_type_t m_option_type_bool;
+extern const m_option_type_t m_option_type_flag;
+extern const m_option_type_t m_option_type_dummy_flag;
+extern const m_option_type_t m_option_type_int;
+extern const m_option_type_t m_option_type_int64;
+extern const m_option_type_t m_option_type_byte_size;
+extern const m_option_type_t m_option_type_float;
+extern const m_option_type_t m_option_type_double;
+extern const m_option_type_t m_option_type_string;
+extern const m_option_type_t m_option_type_string_list;
+extern const m_option_type_t m_option_type_string_append_list;
+extern const m_option_type_t m_option_type_keyvalue_list;
+extern const m_option_type_t m_option_type_time;
+extern const m_option_type_t m_option_type_rel_time;
+extern const m_option_type_t m_option_type_choice;
+extern const m_option_type_t m_option_type_flags;
+extern const m_option_type_t m_option_type_msglevels;
+extern const m_option_type_t m_option_type_print_fn;
+extern const m_option_type_t m_option_type_imgfmt;
+extern const m_option_type_t m_option_type_fourcc;
+extern const m_option_type_t m_option_type_afmt;
+extern const m_option_type_t m_option_type_color;
+extern const m_option_type_t m_option_type_geometry;
+extern const m_option_type_t m_option_type_size_box;
+extern const m_option_type_t m_option_type_channels;
+extern const m_option_type_t m_option_type_aspect;
+extern const m_option_type_t m_option_type_obj_settings_list;
+extern const m_option_type_t m_option_type_node;
+extern const m_option_type_t m_option_type_rect;
+
+// Used internally by m_config.c
+extern const m_option_type_t m_option_type_alias;
+extern const m_option_type_t m_option_type_cli_alias;
+extern const m_option_type_t m_option_type_removed;
+extern const m_option_type_t m_option_type_subconfig;
+
+// Callback used by m_option_type_print_fn options.
+typedef void (*m_opt_print_fn)(struct mp_log *log);
+
+enum m_rel_time_type {
+    REL_TIME_NONE,
+    REL_TIME_ABSOLUTE,
+    REL_TIME_RELATIVE,
+    REL_TIME_PERCENT,
+    REL_TIME_CHAPTER,
+};
+
+struct m_rel_time {
+    double pos;
+    enum m_rel_time_type type;
+};
+
+struct m_color {
+    uint8_t r, g, b, a;
+};
+
+struct m_geometry {
+    int x, y, w, h;
+    bool xy_valid : 1, wh_valid : 1;
+    bool w_per : 1, h_per : 1;
+    bool x_sign : 1, y_sign : 1, x_per : 1, y_per : 1;
+    int ws; // workspace; valid if !=0
+};
+
+void m_geometry_apply(int *xpos, int *ypos, int *widw, int *widh,
+                      int scrw, int scrh, struct m_geometry *gm);
+void m_rect_apply(struct mp_rect *rc, int w, int h, struct m_geometry *gm);
+
+struct m_channels {
+    bool set : 1;
+    bool auto_safe : 1;
+    struct mp_chmap *chmaps;
+    int num_chmaps;
+};
+
+struct m_obj_desc {
+    // Name which will be used in the option string
+    const char *name;
+    // Will be printed when "help" is passed
+    const char *description;
+    // Size of the private struct
+    int priv_size;
+    // If not NULL, default values for private struct
+    const void *priv_defaults;
+    // Options which refer to members in the private struct
+    const struct m_option *options;
+    // Prefix for each of the above options (none if NULL).
+    const char *options_prefix;
+    // For free use by the implementer of m_obj_list.get_desc
+    const void *p;
+    // Don't list entry with "help"
+    bool hidden;
+    // Callback to print custom help if "vf=entry=help" is passed
+    void (*print_help)(struct mp_log *log);
+    // Set by m_obj_list_find(). If the requested name is an old alias, this
+    // is set to the old name (while the name field uses the new name).
+    const char *replaced_name;
+    // For convenience: these are added as global command-line options.
+    const struct m_sub_options *global_opts;
+};
+
+// Extra definition needed for \ref m_option_type_obj_settings_list options.
+struct m_obj_list {
+    bool (*get_desc)(struct m_obj_desc *dst, int index);
+    const char *description;
+    // Can be set to a NULL terminated array of aliases
+    const char *aliases[5][2];
+    // Allow a trailing ",", which adds an entry with name=""
+    bool allow_trailer;
+    // Callback to test whether an unknown entry should be allowed. (This can
+    // be useful if adding them as explicit entries is too much work.)
+    bool (*check_unknown_entry)(const char *name);
+    // Allow syntax for disabling entries.
+    bool allow_disable_entries;
+    // This helps with confusing error messages if unknown flag options are used.
+    bool disallow_positional_parameters;
+    // Each sub-item is backed by global options (for AOs and VOs).
+    bool use_global_options;
+    // Callback to print additional custom help if "vf=help" is passed
+    void (*print_help_list)(struct mp_log *log);
+    // Callback to print help for _unknown_ entries with "vf=entry=help"
+    void (*print_unknown_entry_help)(struct mp_log *log, const char *name);
+};
+
+// Find entry by name
+bool m_obj_list_find(struct m_obj_desc *dst, const struct m_obj_list *list,
+                     bstr name);
+
+// The data type used by \ref m_option_type_obj_settings_list.
+typedef struct m_obj_settings {
+    // Type of the object.
+    char *name;
+    // Optional user-defined name.
+    char *label;
+    // User enable flag.
+    bool enabled;
+    // NULL terminated array of parameter/value pairs.
+    char **attribs;
+} m_obj_settings_t;
+
+bool m_obj_settings_equal(struct m_obj_settings *a, struct m_obj_settings *b);
+
+struct m_opt_choice_alternatives {
+    char *name;
+    int value;
+};
+
+const char *m_opt_choice_str(const struct m_opt_choice_alternatives *choices,
+                             int value);
+
+// Validator function signatures. Required to properly type the param value.
+typedef int (*m_opt_generic_validate_fn)(struct mp_log *log, const m_option_t *opt,
+                                         struct bstr name, void *value);
+
+typedef int (*m_opt_string_validate_fn)(struct mp_log *log, const m_option_t *opt,
+                                        struct bstr name, const char **value);
+typedef int (*m_opt_int_validate_fn)(struct mp_log *log, const m_option_t *opt,
+                                     struct bstr name, const int *value);
+
+
+// m_option.priv points to this if OPT_SUBSTRUCT is used
+struct m_sub_options {
+    const char *prefix;
+    const struct m_option *opts;
+    size_t size;
+    const void *defaults;
+    // Change flags passed to mp_option_change_callback() if any option that is
+    // directly or indirectly part of this group is changed.
+    int change_flags;
+    // Return further sub-options, for example for optional components. If set,
+    // this is called with increasing index (starting from 0), as long as true
+    // is returned. If true is returned and *sub is set in any of these calls,
+    // they are added as options.
+    bool (*get_sub_options)(int index, const struct m_sub_options **sub);
+};
+
+#define CONF_TYPE_BOOL          (&m_option_type_bool)
+#define CONF_TYPE_FLAG          (&m_option_type_flag)
+#define CONF_TYPE_INT           (&m_option_type_int)
+#define CONF_TYPE_INT64         (&m_option_type_int64)
+#define CONF_TYPE_FLOAT         (&m_option_type_float)
+#define CONF_TYPE_DOUBLE        (&m_option_type_double)
+#define CONF_TYPE_STRING        (&m_option_type_string)
+#define CONF_TYPE_STRING_LIST   (&m_option_type_string_list)
+#define CONF_TYPE_IMGFMT        (&m_option_type_imgfmt)
+#define CONF_TYPE_FOURCC        (&m_option_type_fourcc)
+#define CONF_TYPE_AFMT          (&m_option_type_afmt)
+#define CONF_TYPE_OBJ_SETTINGS_LIST (&m_option_type_obj_settings_list)
+#define CONF_TYPE_TIME          (&m_option_type_time)
+#define CONF_TYPE_CHOICE        (&m_option_type_choice)
+#define CONF_TYPE_NODE          (&m_option_type_node)
+
+// Possible option values. Code is allowed to access option data without going
+// through this union. It serves for self-documentation and to get minimal
+// size/alignment requirements for option values in general.
+union m_option_value {
+    bool bool_;
+    int flag; // not the C type "bool"!
+    int int_;
+    int64_t int64;
+    float float_;
+    double double_;
+    char *string;
+    char **string_list;
+    char **keyvalue_list;
+    int imgfmt;
+    unsigned int fourcc;
+    int afmt;
+    m_obj_settings_t *obj_settings_list;
+    double time;
+    struct m_rel_time rel_time;
+    struct m_color color;
+    struct m_geometry geometry;
+    struct m_geometry size_box;
+    struct m_channels channels;
+};
+
+// Keep fully zeroed instance of m_option_value to use as a default value, before
+// any specific union member is used. C standard says that `= {0}` activates and
+// initializes only the first member of the union, leaving padding bits undefined.
+static const union m_option_value m_option_value_default;
+
+////////////////////////////////////////////////////////////////////////////
+
+struct m_option_action {
+    // The name of the suffix, e.g. "add" for a list. If the option is named
+    // "foo", this will be available as "--foo-add". Note that no suffix (i.e.
+    // "--foo" is implicitly always available.
+    const char *name;
+    // One of M_OPT_TYPE*.
+    unsigned int flags;
+};
+
+// Option type description
+struct m_option_type {
+    const char *name;
+    // Size needed for the data.
+    unsigned int size;
+    // One of M_OPT_TYPE*.
+    unsigned int flags;
+
+    // Parse the data from a string.
+    /** It is the only required function, all others can be NULL.
+     *  Generally should not be called directly outside of the options module,
+     *  but instead through \ref m_option_parse which calls additional option
+     *  specific callbacks during the process.
+     *
+     *  \param log for outputting parser error or help messages
+     *  \param opt The option that is parsed.
+     *  \param name The full option name.
+     *  \param param The parameter to parse.
+     *         may not be an argument meant for this option
+     *  \param dst Pointer to the memory where the data should be written.
+     *             If NULL the parameter validity should still be checked.
+     *  \return On error a negative value is returned, on success the number
+     *          of arguments consumed. For details see \ref OptionParserReturn.
+     */
+    int (*parse)(struct mp_log *log, const m_option_t *opt,
+                 struct bstr name, struct bstr param, void *dst);
+
+    // Print back a value in string form.
+    /** \param opt The option to print.
+     *  \param val Pointer to the memory holding the data to be printed.
+     *  \return An allocated string containing the text value or (void*)-1
+     *          on error.
+     */
+    char *(*print)(const m_option_t *opt, const void *val);
+
+    // Print the value in a human readable form. Unlike print(), it doesn't
+    // necessarily return the exact value, and is generally not parseable with
+    // parse().
+    char *(*pretty_print)(const m_option_t *opt, const void *val);
+
+    // Copy data between two locations. Deep copy if the data has pointers.
+    // The implementation must free *dst if memory allocation is involved.
+    /** \param opt The option to copy.
+     *  \param dst Pointer to the destination memory.
+     *  \param src Pointer to the source memory.
+     */
+    void (*copy)(const m_option_t *opt, void *dst, const void *src);
+
+    // Free the data allocated for a save slot.
+    /** This is only needed for dynamic types like strings.
+     *  \param dst Pointer to the data, usually a pointer that should be freed and
+     *             set to NULL.
+     */
+    void (*free)(void *dst);
+
+    // Add the value add to the value in val. For types that are not numeric,
+    // add gives merely the direction. The wrap parameter determines whether
+    // the value is clipped, or wraps around to the opposite max/min.
+    void (*add)(const m_option_t *opt, void *val, double add, bool wrap);
+
+    // Multiply the value with the factor f. The callback must clip the result
+    // to the valid value range of the option.
+    void (*multiply)(const m_option_t *opt, void *val, double f);
+
+    // Set the option value in dst to the contents of src.
+    // (If the option is dynamic, the old value in *dst has to be freed.)
+    // Return values:
+    //  M_OPT_UNKNOWN:      src is in an unknown format
+    //  M_OPT_INVALID:      src is incorrectly formatted
+    //  >= 0:               success
+    //  other error code:   some other error, essentially M_OPT_INVALID refined
+    int (*set)(const m_option_t *opt, void *dst, struct mpv_node *src);
+
+    // Copy the option value in src to dst. Use ta_parent for any dynamic
+    // memory allocations. It's explicitly allowed to have mpv_node reference
+    // static strings (and even mpv_node_list.keys), though.
+    int (*get)(const m_option_t *opt, void *ta_parent, struct mpv_node *dst,
+               void *src);
+
+    // Return whether the values are the same. (There are no "unordered"
+    // results; for example, two floats with the value NaN compare equal. Other
+    // ambiguous floats, such as +0 and -0 compare equal. Some option types may
+    // incorrectly report unequal for values that are equal, such as sets (if
+    // the element order is different, which incorrectly matters), but values
+    // duplicated with m_option_copy() always return as equal. Empty strings
+    // and NULL strings are equal. Ambiguous unicode representations compare
+    // unequal.)
+    // If not set, values are always considered equal (=> not really optional).
+    bool (*equal)(const m_option_t *opt, void *a, void *b);
+
+    // Optional: list of suffixes, terminated with a {0} entry. An empty list
+    // behaves like the list being NULL.
+    const struct m_option_action *actions;
+};
+
+// Option description
+struct m_option {
+    // Option name.
+    // Option declarations can use this as positional field.
+    const char *name;
+
+    // Option type.
+    const m_option_type_t *type;
+
+    // See \ref OptionFlags.
+    unsigned int flags;
+
+    int offset;
+
+    // Most numeric types restrict the range to [min, max] if min<max (this
+    // implies that if min/max are not set, the full range is used). In all
+    // cases, the actual range is clamped to the type's native range.
+    // Float types use [DBL_MIN, DBL_MAX], though by setting min or max to
+    // -/+INFINITY, the range can be extended to INFINITY. (This part is buggy
+    // for "float".)
+    // Preferably use M_RANGE() to set these fields.
+    double min, max;
+
+    // Type dependent data (for all kinds of extended settings).
+    void *priv;
+
+    // Initialize variable to given default before parsing options
+    const void *defval;
+
+    // Print a warning when this option is used (for options with no direct
+    // replacement.)
+    const char *deprecation_message;
+
+    // Optional function that validates a param value for this option.
+    m_opt_generic_validate_fn validate;
+
+    // Optional function that displays help. Will replace type-specific help.
+    int (*help)(struct mp_log *log, const m_option_t *opt, struct bstr name);
+};
+
+char *format_file_size(int64_t size);
+
+// The option is forbidden in config files.
+#define M_OPT_NOCFG             (1 << 2)
+
+// The option should be set during command line pre-parsing
+#define M_OPT_PRE_PARSE         (1 << 4)
+
+// The option expects a file name (or a list of file names)
+#define M_OPT_FILE              (1 << 5)
+
+// Do not add as property.
+#define M_OPT_NOPROP            (1 << 6)
+
+// Enable special semantics for some options when parsing the string "help".
+#define M_OPT_HAVE_HELP         (1 << 7)
+
+// The following are also part of the M_OPT_* flags, and are used to update
+// certain groups of options.
+#define UPDATE_OPT_FIRST        (1 << 8)
+#define UPDATE_TERM             (1 << 8)  // terminal options
+#define UPDATE_SUB_FILT         (1 << 9)  // subtitle filter options
+#define UPDATE_OSD              (1 << 10) // related to OSD rendering
+#define UPDATE_BUILTIN_SCRIPTS  (1 << 11) // osc/ytdl/stats
+#define UPDATE_IMGPAR           (1 << 12) // video image params overrides
+#define UPDATE_INPUT            (1 << 13) // mostly --input-* options
+#define UPDATE_AUDIO            (1 << 14) // --audio-channels etc.
+#define UPDATE_PRIORITY         (1 << 15) // --priority (Windows-only)
+#define UPDATE_SCREENSAVER      (1 << 16) // --stop-screensaver
+#define UPDATE_VOL              (1 << 17) // softvol related options
+#define UPDATE_LAVFI_COMPLEX    (1 << 18) // --lavfi-complex
+#define UPDATE_HWDEC            (1 << 20) // --hwdec
+#define UPDATE_DVB_PROG         (1 << 21) // some --dvbin-...
+#define UPDATE_SUB_HARD         (1 << 22) // subtitle opts. that need full reinit
+#define UPDATE_SUB_EXTS         (1 << 23) // update internal list of sub exts
+#define UPDATE_OPT_LAST         (1 << 23)
+
+// All bits between _FIRST and _LAST (inclusive)
+#define UPDATE_OPTS_MASK \
+    (((UPDATE_OPT_LAST << 1) - 1) & ~(unsigned)(UPDATE_OPT_FIRST - 1))
+
+// type_float/type_double: string "default" is parsed as NaN (and reverse)
+#define M_OPT_DEFAULT_NAN       (1 << 25)
+
+// type time: string "no" maps to MP_NOPTS_VALUE (if unset, NOPTS is rejected)
+#define M_OPT_ALLOW_NO          (1 << 26)
+
+// type channels: disallow "auto" (still accept ""), limit list to at most 1 item.
+#define M_OPT_CHANNELS_LIMITED  (1 << 27)
+
+// Like M_OPT_TYPE_OPTIONAL_PARAM.
+#define M_OPT_OPTIONAL_PARAM    (1 << 30)
+
+// These are kept for compatibility with older code.
+#define CONF_NOCFG              M_OPT_NOCFG
+#define CONF_PRE_PARSE          M_OPT_PRE_PARSE
+
+// These flags are used to describe special parser capabilities or behavior.
+
+// The parameter is optional and by default no parameter is preferred. If
+// ambiguous syntax is used ("--opt value"), the command line parser will
+// assume that the argument takes no parameter. In config files, these
+// options can be used without "=" and value.
+#define M_OPT_TYPE_OPTIONAL_PARAM       (1 << 0)
+
+// Behaves fundamentally like a choice or a superset of it (all allowed string
+// values are from a fixed set, although other types of values like numbers
+// might be allowed too). E.g. m_option_type_choice and m_option_type_flag.
+#define M_OPT_TYPE_CHOICE               (1 << 1)
+
+// When m_option.min/max are set, they denote a value range.
+#define M_OPT_TYPE_USES_RANGE           (1 << 2)
+
+///////////////////////////// Parser flags /////////////////////////////////
+
+// OptionParserReturn
+//
+// On success parsers return a number >= 0.
+//
+// To indicate that MPlayer should exit without playing anything,
+// parsers return M_OPT_EXIT.
+//
+// On error one of the following (negative) error codes is returned:
+
+// For use by higher level APIs when the option name is invalid.
+#define M_OPT_UNKNOWN           -1
+
+// Returned when a parameter is needed but wasn't provided.
+#define M_OPT_MISSING_PARAM     -2
+
+// Returned when the given parameter couldn't be parsed.
+#define M_OPT_INVALID           -3
+
+// Returned if the value is "out of range". The exact meaning may
+// vary from type to type.
+#define M_OPT_OUT_OF_RANGE      -4
+
+// The option doesn't take a parameter.
+#define M_OPT_DISALLOW_PARAM    -5
+
+// Returned when MPlayer should exit. Used by various help stuff.
+#define M_OPT_EXIT              -6
+
+char *m_option_strerror(int code);
+
+// Base function to parse options. Includes calling help and validation
+// callbacks. Only when this functionality is for some reason required to not
+// happen should the parse function pointer be utilized by itself.
+//
+// See \ref m_option_type::parse.
+int m_option_parse(struct mp_log *log, const m_option_t *opt,
+                   struct bstr name, struct bstr param, void *dst);
+
+// Helper to print options, see \ref m_option_type::print.
+static inline char *m_option_print(const m_option_t *opt, const void *val_ptr)
+{
+    if (opt->type->print)
+        return opt->type->print(opt, val_ptr);
+    else
+        return NULL;
+}
+
+static inline char *m_option_pretty_print(const m_option_t *opt,
+                                          const void *val_ptr)
+{
+    if (opt->type->pretty_print)
+        return opt->type->pretty_print(opt, val_ptr);
+    else
+        return m_option_print(opt, val_ptr);
+}
+
+// Helper around \ref m_option_type::copy.
+static inline void m_option_copy(const m_option_t *opt, void *dst,
+                                 const void *src)
+{
+    if (opt->type->copy)
+        opt->type->copy(opt, dst, src);
+}
+
+// Helper around \ref m_option_type::free.
+static inline void m_option_free(const m_option_t *opt, void *dst)
+{
+    if (opt->type->free)
+        opt->type->free(dst);
+}
+
+// see m_option_type.set
+static inline int m_option_set_node(const m_option_t *opt, void *dst,
+                                    struct mpv_node *src)
+{
+    if (opt->type->set)
+        return opt->type->set(opt, dst, src);
+    return M_OPT_UNKNOWN;
+}
+
+// Call m_option_parse for strings, m_option_set_node otherwise.
+int m_option_set_node_or_string(struct mp_log *log, const m_option_t *opt,
+                                const char *name, void *dst, struct mpv_node *src);
+
+// see m_option_type.get
+static inline int m_option_get_node(const m_option_t *opt, void *ta_parent,
+                                    struct mpv_node *dst, void *src)
+{
+    if (opt->type->get)
+        return opt->type->get(opt, ta_parent, dst, src);
+    return M_OPT_UNKNOWN;
+}
+
+static inline bool m_option_equal(const m_option_t *opt, void *a, void *b)
+{
+    // Handle trivial equivalence.
+    // If not implemented, assume this type has no actual values => always equal.
+    if (a == b || !opt->type->equal)
+        return true;
+    return opt->type->equal(opt, a, b);
+}
+
+int m_option_required_params(const m_option_t *opt);
+
+extern const char m_option_path_separator;
+
+// Cause a compilation warning if typeof(expr) != type.
+// Should be used with pointer types only.
+#define MP_EXPECT_TYPE(type, expr) (0 ? (type)0 : (expr))
+
+// This behaves like offsetof(type, member), but will cause a compilation
+// warning if typeof(member) != expected_member_type.
+// It uses some trickery to make it compile as expression.
+#define MP_CHECKED_OFFSETOF(type, member, expected_member_type)             \
+    (offsetof(type, member) + (0 && MP_EXPECT_TYPE(expected_member_type*,   \
+                                                   &((type*)0)->member)))
+
+#define OPT_TYPED_FIELD(type_, c_type, field) \
+    .type = &type_, \
+    .offset = MP_CHECKED_OFFSETOF(OPT_BASE_STRUCT, field, c_type)
+
+#define OPTION_LIST_SEPARATOR ','
+
+#define OPTDEF_STR(s)     .defval = (void *)&(char * const){s}
+#define OPTDEF_INT(i)     .defval = (void *)&(const int){i}
+#define OPTDEF_INT64(i)   .defval = (void *)&(const int64_t){i}
+#define OPTDEF_FLOAT(f)   .defval = (void *)&(const float){f}
+#define OPTDEF_DOUBLE(d)  .defval = (void *)&(const double){d}
+
+#define M_RANGE(a, b) .min = (double) (a), .max = (double) (b)
+
+#define OPT_BOOL(field) \
+    OPT_TYPED_FIELD(m_option_type_bool, bool, field)
+
+#define OPT_INT(field) \
+    OPT_TYPED_FIELD(m_option_type_int, int, field)
+
+#define OPT_INT64(field) \
+    OPT_TYPED_FIELD(m_option_type_int64, int64_t, field)
+
+#define OPT_FLOAT(field) \
+    OPT_TYPED_FIELD(m_option_type_float, float, field)
+
+#define OPT_DOUBLE(field) \
+    OPT_TYPED_FIELD(m_option_type_double, double, field)
+
+#define OPT_STRING(field) \
+    OPT_TYPED_FIELD(m_option_type_string, char*, field)
+
+#define OPT_STRINGLIST(field) \
+    OPT_TYPED_FIELD(m_option_type_string_list, char**, field)
+
+#define OPT_KEYVALUELIST(field) \
+    OPT_TYPED_FIELD(m_option_type_keyvalue_list, char**, field)
+
+#define OPT_PATHLIST(field) \
+    OPT_TYPED_FIELD(m_option_type_string_list, char**, field), \
+    .priv = (void *)&m_option_path_separator
+
+#define OPT_TIME(field) \
+    OPT_TYPED_FIELD(m_option_type_time, double, field)
+
+#define OPT_REL_TIME(field) \
+    OPT_TYPED_FIELD(m_option_type_rel_time, struct m_rel_time, field)
+
+#define OPT_COLOR(field) \
+    OPT_TYPED_FIELD(m_option_type_color, struct m_color, field)
+
+#define OPT_BYTE_SIZE(field) \
+    OPT_TYPED_FIELD(m_option_type_byte_size, int64_t, field)
+
+// (Approximation of x<=SIZE_MAX/2 for m_option.max, which is double.)
+#define M_MAX_MEM_BYTES MPMIN((1ULL << 62), (size_t)-1 / 2)
+
+#define OPT_GEOMETRY(field) \
+    OPT_TYPED_FIELD(m_option_type_geometry, struct m_geometry, field)
+
+#define OPT_SIZE_BOX(field) \
+    OPT_TYPED_FIELD(m_option_type_size_box, struct m_geometry, field)
+
+#define OPT_RECT(field) \
+    OPT_TYPED_FIELD(m_option_type_rect, struct m_geometry, field)
+
+#define OPT_TRACKCHOICE(field) \
+    OPT_CHOICE(field, {"no", -2}, {"auto", -1}), \
+    M_RANGE(0, 8190)
+
+#define OPT_MSGLEVELS(field) \
+    OPT_TYPED_FIELD(m_option_type_msglevels, char **, field)
+
+#define OPT_ASPECT(field) \
+    OPT_TYPED_FIELD(m_option_type_aspect, double, field)
+
+#define OPT_IMAGEFORMAT(field) \
+    OPT_TYPED_FIELD(m_option_type_imgfmt, int, field)
+
+#define OPT_AUDIOFORMAT(field) \
+    OPT_TYPED_FIELD(m_option_type_afmt, int, field)
+
+#define OPT_CHANNELS(field) \
+    OPT_TYPED_FIELD(m_option_type_channels, struct m_channels, field)
+
+#define OPT_INT_VALIDATE(field, validate_fn) \
+    OPT_TYPED_FIELD(m_option_type_int, int, field), \
+    .validate = (m_opt_generic_validate_fn) \
+        MP_EXPECT_TYPE(m_opt_int_validate_fn, validate_fn)
+
+#define OPT_STRING_VALIDATE(field, validate_fn) \
+    OPT_TYPED_FIELD(m_option_type_string, char*, field), \
+    .validate = (m_opt_generic_validate_fn) \
+        MP_EXPECT_TYPE(m_opt_string_validate_fn, validate_fn)
+
+#define M_CHOICES(...) \
+    .priv = (void *)&(const struct m_opt_choice_alternatives[]){ __VA_ARGS__, {0}}
+
+// Variant which takes a pointer to struct m_opt_choice_alternatives directly
+#define OPT_CHOICE_C(field, choices) \
+    OPT_TYPED_FIELD(m_option_type_choice, int, field), \
+    .priv = (void *)MP_EXPECT_TYPE(const struct m_opt_choice_alternatives*, choices)
+
+// Variant where you pass a struct m_opt_choice_alternatives initializer
+#define OPT_CHOICE(field, ...) \
+    OPT_TYPED_FIELD(m_option_type_choice, int, field), \
+    M_CHOICES(__VA_ARGS__)
+
+#define OPT_FLAGS(field, ...) \
+    OPT_TYPED_FIELD(m_option_type_flags, int, field), \
+    M_CHOICES(__VA_ARGS__)
+
+#define OPT_SETTINGSLIST(field, objlist) \
+    OPT_TYPED_FIELD(m_option_type_obj_settings_list, m_obj_settings_t*, field), \
+    .priv = (void*)MP_EXPECT_TYPE(const struct m_obj_list*, objlist)
+
+#define OPT_FOURCC(field) \
+    OPT_TYPED_FIELD(m_option_type_fourcc, int, field)
+
+#define OPT_CYCLEDIR(field) \
+    OPT_TYPED_FIELD(m_option_type_cycle_dir, double, field)
+
+// subconf must have the type struct m_sub_options.
+// All sub-options are prefixed with "name-" and are added to the current
+// (containing) option list.
+// If name is "", add the sub-options directly instead.
+// "field" refers to the field, that must be a pointer to a field described by
+// the subconf struct.
+#define OPT_SUBSTRUCT(field, subconf) \
+    .offset = offsetof(OPT_BASE_STRUCT, field), \
+    .type = &m_option_type_subconfig, .priv = (void*)&subconf
+
+// Non-fields
+
+#define OPT_ALIAS(newname) \
+    .type = &m_option_type_alias, .priv = newname, .offset = -1
+
+// If "--optname" was removed, but "--newname" has the same semantics.
+// It will be redirected, and a warning will be printed on first use.
+#define OPT_REPLACED_MSG(newname, msg) \
+    .type = &m_option_type_alias, .priv = newname, \
+    .deprecation_message = (msg), .offset = -1
+
+// Same, with a generic deprecation message.
+#define OPT_REPLACED(newname) OPT_REPLACED_MSG(newname, "")
+
+// Alias, resolved on the CLI/config file/profile parser level only.
+#define OPT_CLI_ALIAS(newname) \
+    .type = &m_option_type_cli_alias, .priv = newname, \
+    .flags = M_OPT_NOPROP, .offset = -1
+
+// "--optname" doesn't exist, but inform the user about a replacement with msg.
+#define OPT_REMOVED(msg) \
+    .type = &m_option_type_removed, .priv = msg, \
+    .deprecation_message = "", .flags = M_OPT_NOPROP, .offset = -1
+
+#define OPT_PRINT(fn) \
+    .flags = M_OPT_NOCFG | M_OPT_PRE_PARSE | M_OPT_NOPROP, \
+    .type = &m_option_type_print_fn, \
+    .priv = MP_EXPECT_TYPE(m_opt_print_fn, fn), \
+    .offset = -1
+
+#endif /* MPLAYER_M_OPTION_H */
diff --git a/options/m_property.c b/options/m_property.c
new file mode 100644
index 0000000..1b76f05
--- /dev/null
+++ b/options/m_property.c
@@ -0,0 +1,630 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/// \file
+/// \ingroup Properties
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <assert.h>
+
+#include <libavutil/common.h>
+
+#include "libmpv/client.h"
+
+#include "mpv_talloc.h"
+#include "m_option.h"
+#include "m_property.h"
+#include "common/msg.h"
+#include "common/common.h"
+
+static int m_property_multiply(struct mp_log *log,
+                               const struct m_property *prop_list,
+                               const char *property, double f, void *ctx)
+{
+    union m_option_value val = m_option_value_default;
+    struct m_option opt = {0};
+    int r;
+
+    r = m_property_do(log, prop_list, property, M_PROPERTY_GET_CONSTRICTED_TYPE,
+                      &opt, ctx);
+    if (r != M_PROPERTY_OK)
+        return r;
+    assert(opt.type);
+
+    if (!opt.type->multiply)
+        return M_PROPERTY_NOT_IMPLEMENTED;
+
+    r = m_property_do(log, prop_list, property, M_PROPERTY_GET, &val, ctx);
+    if (r != M_PROPERTY_OK)
+        return r;
+    opt.type->multiply(&opt, &val, f);
+    r = m_property_do(log, prop_list, property, M_PROPERTY_SET, &val, ctx);
+    m_option_free(&opt, &val);
+    return r;
+}
+
+struct m_property *m_property_list_find(const struct m_property *list,
+                                        const char *name)
+{
+    for (int n = 0; list && list[n].name; n++) {
+        if (strcmp(list[n].name, name) == 0)
+            return (struct m_property *)&list[n];
+    }
+    return NULL;
+}
+
+static int do_action(const struct m_property *prop_list, const char *name,
+                     int action, void *arg, void *ctx)
+{
+    struct m_property *prop;
+    struct m_property_action_arg ka;
+    const char *sep = strchr(name, '/');
+    if (sep && sep[1]) {
+        char base[128];
+        snprintf(base, sizeof(base), "%.*s", (int)(sep - name), name);
+        prop = m_property_list_find(prop_list, base);
+        ka = (struct m_property_action_arg) {
+            .key = sep + 1,
+            .action = action,
+            .arg = arg,
+        };
+        action = M_PROPERTY_KEY_ACTION;
+        arg = &ka;
+    } else
+        prop = m_property_list_find(prop_list, name);
+    if (!prop)
+        return M_PROPERTY_UNKNOWN;
+    return prop->call(ctx, prop, action, arg);
+}
+
+// (as a hack, log can be NULL on read-only paths)
+int m_property_do(struct mp_log *log, const struct m_property *prop_list,
+                  const char *name, int action, void *arg, void *ctx)
+{
+    union m_option_value val = m_option_value_default;
+    int r;
+
+    struct m_option opt = {0};
+    r = do_action(prop_list, name, M_PROPERTY_GET_TYPE, &opt, ctx);
+    if (r <= 0)
+        return r;
+    assert(opt.type);
+
+    switch (action) {
+    case M_PROPERTY_PRINT: {
+        if ((r = do_action(prop_list, name, M_PROPERTY_PRINT, arg, ctx)) >= 0)
+            return r;
+        // Fallback to m_option
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET, &val, ctx)) <= 0)
+            return r;
+        char *str = m_option_pretty_print(&opt, &val);
+        m_option_free(&opt, &val);
+        *(char **)arg = str;
+        return str != NULL;
+    }
+    case M_PROPERTY_GET_STRING: {
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET, &val, ctx)) <= 0)
+            return r;
+        char *str = m_option_print(&opt, &val);
+        m_option_free(&opt, &val);
+        *(char **)arg = str;
+        return str != NULL;
+    }
+    case M_PROPERTY_SET_STRING: {
+        struct mpv_node node = { .format = MPV_FORMAT_STRING, .u.string = arg };
+        return m_property_do(log, prop_list, name, M_PROPERTY_SET_NODE, &node, ctx);
+    }
+    case M_PROPERTY_MULTIPLY: {
+        return m_property_multiply(log, prop_list, name, *(double *)arg, ctx);
+    }
+    case M_PROPERTY_SWITCH: {
+        if (!log)
+            return M_PROPERTY_ERROR;
+        struct m_property_switch_arg *sarg = arg;
+        if ((r = do_action(prop_list, name, M_PROPERTY_SWITCH, arg, ctx)) !=
+            M_PROPERTY_NOT_IMPLEMENTED)
+            return r;
+        // Fallback to m_option
+        r = m_property_do(log, prop_list, name, M_PROPERTY_GET_CONSTRICTED_TYPE,
+                          &opt, ctx);
+        if (r <= 0)
+            return r;
+        assert(opt.type);
+        if (!opt.type->add)
+            return M_PROPERTY_NOT_IMPLEMENTED;
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET, &val, ctx)) <= 0)
+            return r;
+        opt.type->add(&opt, &val, sarg->inc, sarg->wrap);
+        r = do_action(prop_list, name, M_PROPERTY_SET, &val, ctx);
+        m_option_free(&opt, &val);
+        return r;
+    }
+    case M_PROPERTY_GET_CONSTRICTED_TYPE: {
+        r = do_action(prop_list, name, action, arg, ctx);
+        if (r >= 0 || r == M_PROPERTY_UNAVAILABLE)
+            return r;
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET_TYPE, arg, ctx)) >= 0)
+            return r;
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+    case M_PROPERTY_SET: {
+        return do_action(prop_list, name, M_PROPERTY_SET, arg, ctx);
+    }
+    case M_PROPERTY_GET_NODE: {
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET_NODE, arg, ctx)) !=
+            M_PROPERTY_NOT_IMPLEMENTED)
+            return r;
+        if ((r = do_action(prop_list, name, M_PROPERTY_GET, &val, ctx)) <= 0)
+            return r;
+        struct mpv_node *node = arg;
+        int err = m_option_get_node(&opt, NULL, node, &val);
+        if (err == M_OPT_UNKNOWN) {
+            r = M_PROPERTY_NOT_IMPLEMENTED;
+        } else if (err < 0) {
+            r = M_PROPERTY_INVALID_FORMAT;
+        } else {
+            r = M_PROPERTY_OK;
+        }
+        m_option_free(&opt, &val);
+        return r;
+    }
+    case M_PROPERTY_SET_NODE: {
+        if (!log)
+            return M_PROPERTY_ERROR;
+        if ((r = do_action(prop_list, name, M_PROPERTY_SET_NODE, arg, ctx)) !=
+            M_PROPERTY_NOT_IMPLEMENTED)
+            return r;
+        int err = m_option_set_node_or_string(log, &opt, name, &val, arg);
+        if (err == M_OPT_UNKNOWN) {
+            r = M_PROPERTY_NOT_IMPLEMENTED;
+        } else if (err < 0) {
+            r = M_PROPERTY_INVALID_FORMAT;
+        } else {
+            r = do_action(prop_list, name, M_PROPERTY_SET, &val, ctx);
+        }
+        m_option_free(&opt, &val);
+        return r;
+    }
+    default:
+        return do_action(prop_list, name, action, arg, ctx);
+    }
+}
+
+bool m_property_split_path(const char *path, bstr *prefix, char **rem)
+{
+    char *next = strchr(path, '/');
+    if (next) {
+        *prefix = bstr_splice(bstr0(path), 0, next - path);
+        *rem = next + 1;
+        return true;
+    } else {
+        *prefix = bstr0(path);
+        *rem = "";
+        return false;
+    }
+}
+
+// If *action is M_PROPERTY_KEY_ACTION, but the associated path is "", then
+// make this into a top-level action.
+static void m_property_unkey(int *action, void **arg)
+{
+    if (*action == M_PROPERTY_KEY_ACTION) {
+        struct m_property_action_arg *ka = *arg;
+        if (!ka->key[0]) {
+            *action = ka->action;
+            *arg = ka->arg;
+        }
+    }
+}
+
+static int m_property_do_bstr(const struct m_property *prop_list, bstr name,
+                              int action, void *arg, void *ctx)
+{
+    char *name0 = bstrdup0(NULL, name);
+    int ret = m_property_do(NULL, prop_list, name0, action, arg, ctx);
+    talloc_free(name0);
+    return ret;
+}
+
+static void append_str(char **s, int *len, bstr append)
+{
+    MP_TARRAY_GROW(NULL, *s, *len + append.len);
+    if (append.len)
+        memcpy(*s + *len, append.start, append.len);
+    *len = *len + append.len;
+}
+
+static int expand_property(const struct m_property *prop_list, char **ret,
+                           int *ret_len, bstr prop, bool silent_error, void *ctx)
+{
+    bool cond_yes = bstr_eatstart0(&prop, "?");
+    bool cond_no = !cond_yes && bstr_eatstart0(&prop, "!");
+    bool test = cond_yes || cond_no;
+    bool raw = bstr_eatstart0(&prop, "=");
+    bstr comp_with = {0};
+    bool comp = test && bstr_split_tok(prop, "==", &prop, &comp_with);
+    if (test && !comp)
+        raw = true;
+    int method = raw ? M_PROPERTY_GET_STRING : M_PROPERTY_PRINT;
+
+    char *s = NULL;
+    int r = m_property_do_bstr(prop_list, prop, method, &s, ctx);
+    bool skip;
+    if (comp) {
+        skip = ((s && bstr_equals0(comp_with, s)) != cond_yes);
+    } else if (test) {
+        skip = (!!s != cond_yes);
+    } else {
+        skip = !!s;
+        char *append = s;
+        if (!s && !silent_error && !raw)
+            append = (r == M_PROPERTY_UNAVAILABLE) ? "(unavailable)" : "(error)";
+        append_str(ret, ret_len, bstr0(append));
+    }
+    talloc_free(s);
+    return skip;
+}
+
+char *m_properties_expand_string(const struct m_property *prop_list,
+                                 const char *str0, void *ctx)
+{
+    char *ret = NULL;
+    int ret_len = 0;
+    bool skip = false;
+    int level = 0, skip_level = 0;
+    bstr str = bstr0(str0);
+
+    while (str.len) {
+        if (level > 0 && bstr_eatstart0(&str, "}")) {
+            if (skip && level <= skip_level)
+                skip = false;
+            level--;
+        } else if (bstr_startswith0(str, "${") && bstr_find0(str, "}") >= 0) {
+            str = bstr_cut(str, 2);
+            level++;
+
+            // Assume ":" and "}" can't be part of the property name
+            // => if ":" comes before "}", it must be for the fallback
+            int term_pos = bstrcspn(str, ":}");
+            bstr name = bstr_splice(str, 0, term_pos < 0 ? str.len : term_pos);
+            str = bstr_cut(str, term_pos);
+            bool have_fallback = bstr_eatstart0(&str, ":");
+
+            if (!skip) {
+                skip = expand_property(prop_list, &ret, &ret_len, name,
+                                       have_fallback, ctx);
+                if (skip)
+                    skip_level = level;
+            }
+        } else if (level == 0 && bstr_eatstart0(&str, "$>")) {
+            append_str(&ret, &ret_len, str);
+            break;
+        } else {
+            char c;
+
+            // Other combinations, e.g. "$x", are added verbatim
+            if (bstr_eatstart0(&str, "$$")) {
+                c = '$';
+            } else if (bstr_eatstart0(&str, "$}")) {
+                c = '}';
+            } else {
+                c = str.start[0];
+                str = bstr_cut(str, 1);
+            }
+
+            if (!skip)
+                MP_TARRAY_APPEND(NULL, ret, ret_len, c);
+        }
+    }
+
+    MP_TARRAY_APPEND(NULL, ret, ret_len, '\0');
+    return ret;
+}
+
+void m_properties_print_help_list(struct mp_log *log,
+                                  const struct m_property *list)
+{
+    int count = 0;
+
+    mp_info(log, "Name\n\n");
+    for (int i = 0; list[i].name; i++) {
+        const struct m_property *p = &list[i];
+        mp_info(log, " %s\n", p->name);
+        count++;
+    }
+    mp_info(log, "\nTotal: %d properties\n", count);
+}
+
+int m_property_bool_ro(int action, void* arg, bool var)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(bool *)arg = !!var;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_BOOL};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_int_ro(int action, void *arg, int var)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(int *)arg = var;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_INT};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_int64_ro(int action, void* arg, int64_t var)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(int64_t *)arg = var;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_INT64};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_float_ro(int action, void *arg, float var)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(float *)arg = var;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_FLOAT};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_double_ro(int action, void *arg, double var)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(double *)arg = var;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_DOUBLE};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_strdup_ro(int action, void* arg, const char *var)
+{
+    if (!var)
+        return M_PROPERTY_UNAVAILABLE;
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(char **)arg = talloc_strdup(NULL, var);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+int m_property_read_sub_validate(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    m_property_unkey(&action, &arg);
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET:
+    case M_PROPERTY_PRINT:
+    case M_PROPERTY_KEY_ACTION:
+        return M_PROPERTY_VALID;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    };
+}
+
+// This allows you to make a list of values (like from a struct) available
+// as a number of sub-properties. The property list is set up with the current
+// property values on the stack before calling this function.
+// This does not support write access.
+int m_property_read_sub(const struct m_sub_property *props, int action, void *arg)
+{
+    m_property_unkey(&action, &arg);
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET: {
+        struct mpv_node node;
+        node.format = MPV_FORMAT_NODE_MAP;
+        node.u.list = talloc_zero(NULL, mpv_node_list);
+        mpv_node_list *list = node.u.list;
+        for (int n = 0; props && props[n].name; n++) {
+            const struct m_sub_property *prop = &props[n];
+            if (prop->unavailable)
+                continue;
+            MP_TARRAY_GROW(list, list->values, list->num);
+            MP_TARRAY_GROW(list, list->keys, list->num);
+            mpv_node *val = &list->values[list->num];
+            if (m_option_get_node(&prop->type, list, val, (void*)&prop->value) < 0)
+            {
+                char *s = m_option_print(&prop->type, &prop->value);
+                val->format = MPV_FORMAT_STRING;
+                val->u.string = talloc_steal(list, s);
+            }
+            list->keys[list->num] = (char *)prop->name;
+            list->num++;
+        }
+        *(struct mpv_node *)arg = node;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_PRINT: {
+        // Output "something" - what it really should return is not yet decided.
+        // It should probably be something that is easy to consume by slave
+        // mode clients. (M_PROPERTY_PRINT on the other hand can return this
+        // as human readable version just fine).
+        char *res = NULL;
+        for (int n = 0; props && props[n].name; n++) {
+            const struct m_sub_property *prop = &props[n];
+            if (prop->unavailable)
+                continue;
+            char *s = m_option_print(&prop->type, &prop->value);
+            ta_xasprintf_append(&res, "%s=%s\n", prop->name, s);
+            talloc_free(s);
+        }
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *ka = arg;
+        const struct m_sub_property *prop = NULL;
+        for (int n = 0; props && props[n].name; n++) {
+            if (strcmp(props[n].name, ka->key) == 0) {
+                prop = &props[n];
+                break;
+            }
+        }
+        if (!prop)
+            return M_PROPERTY_UNKNOWN;
+        if (prop->unavailable)
+            return M_PROPERTY_UNAVAILABLE;
+        switch (ka->action) {
+        case M_PROPERTY_GET: {
+            memset(ka->arg, 0, prop->type.type->size);
+            m_option_copy(&prop->type, ka->arg, &prop->value);
+            return M_PROPERTY_OK;
+        }
+        case M_PROPERTY_GET_TYPE:
+            *(struct m_option *)ka->arg = prop->type;
+            return M_PROPERTY_OK;
+        }
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+
+// Make a list of items available as indexed sub-properties. E.g. you can access
+// item 0 as "property/0", item 1 as "property/1", etc., where each of these
+// properties is redirected to the get_item(0, ...), get_item(1, ...), callback.
+// Additionally, the number of entries is made available as "property/count".
+// action, arg: property access.
+// count: number of items.
+// get_item: callback to access a single item.
+// ctx: userdata passed to get_item.
+int m_property_read_list(int action, void *arg, int count,
+                         m_get_item_cb get_item, void *ctx)
+{
+    m_property_unkey(&action, &arg);
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET: {
+        struct mpv_node node;
+        node.format = MPV_FORMAT_NODE_ARRAY;
+        node.u.list = talloc_zero(NULL, mpv_node_list);
+        node.u.list->num = count;
+        node.u.list->values = talloc_array(node.u.list, mpv_node, count);
+        for (int n = 0; n < count; n++) {
+            struct mpv_node *sub = &node.u.list->values[n];
+            sub->format = MPV_FORMAT_NONE;
+            int r;
+            r = get_item(n, M_PROPERTY_GET_NODE, sub, ctx);
+            if (r == M_PROPERTY_NOT_IMPLEMENTED) {
+                struct m_option opt = {0};
+                r = get_item(n, M_PROPERTY_GET_TYPE, &opt, ctx);
+                if (r != M_PROPERTY_OK)
+                    goto err;
+                union m_option_value val = m_option_value_default;
+                r = get_item(n, M_PROPERTY_GET, &val, ctx);
+                if (r != M_PROPERTY_OK)
+                    goto err;
+                m_option_get_node(&opt, node.u.list, sub, &val);
+                m_option_free(&opt, &val);
+            err: ;
+            }
+        }
+        *(struct mpv_node *)arg = node;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_PRINT: {
+        // See m_property_read_sub() remarks.
+        char *res = NULL;
+        for (int n = 0; n < count; n++) {
+            char *s = NULL;
+            int r = get_item(n, M_PROPERTY_PRINT, &s, ctx);
+            if (r != M_PROPERTY_OK) {
+                talloc_free(res);
+                return r;
+            }
+            ta_xasprintf_append(&res, "%d: %s\n", n, s);
+            talloc_free(s);
+        }
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *ka = arg;
+        if (strcmp(ka->key, "count") == 0) {
+            switch (ka->action) {
+            case M_PROPERTY_GET_TYPE: {
+                struct m_option opt = {.type = CONF_TYPE_INT};
+                *(struct m_option *)ka->arg = opt;
+                return M_PROPERTY_OK;
+            }
+            case M_PROPERTY_GET:
+                *(int *)ka->arg = MPMAX(0, count);
+                return M_PROPERTY_OK;
+            }
+            return M_PROPERTY_NOT_IMPLEMENTED;
+        }
+        // This is expected of the form "123" or "123/rest"
+        char *next = strchr(ka->key, '/');
+        char *end = NULL;
+        const char *key_end = ka->key + strlen(ka->key);
+        long int item = strtol(ka->key, &end, 10);
+        // not a number, trailing characters, etc.
+        if ((end != key_end || ka->key == key_end) && end != next)
+            return M_PROPERTY_UNKNOWN;
+        if (item < 0 || item >= count)
+            return M_PROPERTY_UNKNOWN;
+        if (next) {
+            // Sub-path
+            struct m_property_action_arg n_ka = *ka;
+            n_ka.key = next + 1;
+            return get_item(item, M_PROPERTY_KEY_ACTION, &n_ka, ctx);
+        } else {
+            // Direct query
+            return get_item(item, ka->action, ka->arg, ctx);
+        }
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
diff --git a/options/m_property.h b/options/m_property.h
new file mode 100644
index 0000000..0dce246
--- /dev/null
+++ b/options/m_property.h
@@ -0,0 +1,234 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_M_PROPERTY_H
+#define MPLAYER_M_PROPERTY_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "m_option.h"
+
+struct mp_log;
+
+enum mp_property_action {
+    // Get the property type. This defines the fundamental data type read from
+    // or written to the property.
+    // If unimplemented, the m_option entry that defines the property is used.
+    //  arg: m_option*
+    M_PROPERTY_GET_TYPE,
+
+    // Get the current value.
+    //  arg: pointer to a variable of the type according to the property type
+    M_PROPERTY_GET,
+
+    // Set a new value. The property wrapper will make sure that only valid
+    // values are set (e.g. according to the property type's min/max range).
+    // If unimplemented, the property is read-only.
+    //  arg: pointer to a variable of the type according to the property type
+    M_PROPERTY_SET,
+
+    // Get human readable string representing the current value.
+    // If unimplemented, the property wrapper uses the property type as
+    // fallback.
+    //  arg: char**
+    M_PROPERTY_PRINT,
+
+    // Like M_PROPERTY_GET_TYPE, but get a type that is compatible to the real
+    // type, but reflect practical limits, such as runtime-available values.
+    // This is mostly used for "UI" related things.
+    // (Example: volume property.)
+    M_PROPERTY_GET_CONSTRICTED_TYPE,
+
+    // Switch the property up/down by a given value.
+    // If unimplemented, the property wrapper uses the property type as
+    // fallback.
+    //  arg: struct m_property_switch_arg*
+    M_PROPERTY_SWITCH,
+
+    // Get a string containing a parseable representation.
+    // Can't be overridden by property implementations.
+    //  arg: char**
+    M_PROPERTY_GET_STRING,
+
+    // Set a new value from a string. The property wrapper parses this using the
+    // parse function provided by the property type.
+    // Can't be overridden by property implementations.
+    //  arg: char*
+    M_PROPERTY_SET_STRING,
+
+    // Set a mpv_node value.
+    //  arg: mpv_node*
+    M_PROPERTY_GET_NODE,
+
+    // Get a mpv_node value.
+    //  arg: mpv_node*
+    M_PROPERTY_SET_NODE,
+
+    // Multiply numeric property with a factor.
+    //  arg: double*
+    M_PROPERTY_MULTIPLY,
+
+    // Pass down an action to a sub-property.
+    //  arg: struct m_property_action_arg*
+    M_PROPERTY_KEY_ACTION,
+
+    // Delete a value.
+    // Most properties do not implement this.
+    //  arg: (ignored)
+    M_PROPERTY_DELETE,
+};
+
+// Argument for M_PROPERTY_SWITCH
+struct m_property_switch_arg {
+    double inc;         // value to add to property, or cycle direction
+    bool wrap;          // whether value should wrap around on over/underflow
+};
+
+// Argument for M_PROPERTY_KEY_ACTION
+struct m_property_action_arg {
+    const char* key;
+    int action;
+    void* arg;
+};
+
+enum mp_property_return {
+    // Returned from validator if action should be executed.
+    M_PROPERTY_VALID = 2,
+
+    // Returned on success.
+    M_PROPERTY_OK = 1,
+
+    // Returned on error.
+    M_PROPERTY_ERROR = 0,
+
+    // Returned when the property can't be used, for example video related
+    // properties while playing audio only.
+    M_PROPERTY_UNAVAILABLE = -1,
+
+    // Returned if the requested action is not implemented.
+    M_PROPERTY_NOT_IMPLEMENTED = -2,
+
+    // Returned when asking for a property that doesn't exist.
+    M_PROPERTY_UNKNOWN = -3,
+
+    // When trying to set invalid or incorrectly formatted data.
+    M_PROPERTY_INVALID_FORMAT = -4,
+};
+
+struct m_property {
+    const char *name;
+    // ctx: opaque caller context, which the property might use
+    // prop: pointer to this struct
+    // action: one of enum mp_property_action
+    // arg: specific to the action
+    // returns: one of enum mp_property_return
+    int (*call)(void *ctx, struct m_property *prop, int action, void *arg);
+    void *priv;
+    // Special-case: mark options for which command.c uses the option-bridge
+    bool is_option;
+};
+
+struct m_property *m_property_list_find(const struct m_property *list,
+                                        const char *name);
+
+// Access a property.
+// action: one of m_property_action
+// ctx: opaque value passed through to property implementation
+// returns: one of mp_property_return
+int m_property_do(struct mp_log *log, const struct m_property* prop_list,
+                  const char* property_name, int action, void* arg, void *ctx);
+
+// Given a path of the form "a/b/c", this function will set *prefix to "a",
+// and rem to "b/c", and return true.
+// If there is no '/' in the path, set prefix to path, and rem to "", and
+// return false.
+bool m_property_split_path(const char *path, bstr *prefix, char **rem);
+
+// Print a list of properties.
+void m_properties_print_help_list(struct mp_log *log,
+                                  const struct m_property *list);
+
+// Expand a property string.
+// This function allows to print strings containing property values.
+//  ${NAME} is expanded to the value of property NAME.
+//  If NAME starts with '=', use the raw value of the property.
+//  ${NAME:STR} expands to the property, or STR if the property is not
+//  available.
+//  ${?NAME:STR} expands to STR if the property is available.
+//  ${!NAME:STR} expands to STR if the property is not available.
+// General syntax: "${" ["?" | "!"] ["="] NAME ":" STR "}"
+// STR is recursively expanded using the same rules.
+// "$$" can be used to escape "$", and "$}" to escape "}".
+// "$>" disables parsing of "$" for the rest of the string.
+char* m_properties_expand_string(const struct m_property *prop_list,
+                                 const char *str, void *ctx);
+
+// Trivial helpers for implementing properties.
+int m_property_bool_ro(int action, void* arg, bool var);
+int m_property_int_ro(int action, void* arg, int var);
+int m_property_int64_ro(int action, void* arg, int64_t var);
+int m_property_float_ro(int action, void* arg, float var);
+int m_property_double_ro(int action, void* arg, double var);
+int m_property_strdup_ro(int action, void* arg, const char *var);
+
+struct m_sub_property {
+    // Name of the sub-property - this will be prefixed with the parent
+    // property's name.
+    const char *name;
+    // Type of the data stored in the value member. See m_option.
+    struct m_option type;
+    // Data returned by the sub-property. m_property_read_sub() will make a
+    // copy of this if needed. It will never write or free the data.
+    union m_option_value value;
+    // This can be set to true if the property should be hidden.
+    bool unavailable;
+};
+
+// Convenience macros which can be used as part of a sub_property entry.
+#define SUB_PROP_INT(i) \
+    .type = {.type = CONF_TYPE_INT}, .value = {.int_ = (i)}
+#define SUB_PROP_INT64(i) \
+    .type = {.type = CONF_TYPE_INT64}, .value = {.int64 = (i)}
+#define SUB_PROP_STR(s) \
+    .type = {.type = CONF_TYPE_STRING}, .value = {.string = (char *)(s)}
+#define SUB_PROP_FLOAT(f) \
+    .type = {.type = CONF_TYPE_FLOAT}, .value = {.float_ = (f)}
+#define SUB_PROP_DOUBLE(f) \
+    .type = {.type = CONF_TYPE_DOUBLE}, .value = {.double_ = (f)}
+#define SUB_PROP_BOOL(f) \
+    .type = {.type = CONF_TYPE_BOOL}, .value = {.bool_ = (f)}
+#define SUB_PROP_PTS(f) \
+    .type = {.type = &m_option_type_time}, .value = {.double_ = (f)}
+
+int m_property_read_sub_validate(void *ctx, struct m_property *prop,
+                                 int action, void *arg);
+int m_property_read_sub(const struct m_sub_property *props, int action, void *arg);
+
+
+// Used with m_property_read_list().
+// Get an entry. item is the 0-based index of the item. This behaves like a
+// top-level property request (but you must implement M_PROPERTY_GET_TYPE).
+// item will be in range [0, count), for count see m_property_read_list()
+// action, arg are for property access.
+// ctx is userdata passed to m_property_read_list.
+typedef int (*m_get_item_cb)(int item, int action, void *arg, void *ctx);
+
+int m_property_read_list(int action, void *arg, int count,
+                         m_get_item_cb get_item, void *ctx);
+
+#endif /* MPLAYER_M_PROPERTY_H */
diff --git a/options/options.c b/options/options.c
new file mode 100644
index 0000000..7c6ffa5
--- /dev/null
+++ b/options/options.c
@@ -0,0 +1,1097 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_CFG_MPLAYER_H
+#define MPLAYER_CFG_MPLAYER_H
+
+/*
+ * config for cfgparser
+ */
+
+#include <float.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <limits.h>
+#include <math.h>
+
+#include "config.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#include <dwmapi.h>
+#endif
+
+#include "options.h"
+#include "m_config.h"
+#include "m_option.h"
+#include "common/common.h"
+#include "input/event.h"
+#include "stream/stream.h"
+#include "video/csputils.h"
+#include "video/hwdec.h"
+#include "video/image_writer.h"
+#include "sub/osd.h"
+#include "player/core.h"
+#include "player/command.h"
+#include "stream/stream.h"
+#include "demux/demux.h"
+
+static void print_version(struct mp_log *log)
+{
+    mp_print_version(log, true);
+}
+
+extern const struct m_sub_options tv_params_conf;
+extern const struct m_sub_options stream_bluray_conf;
+extern const struct m_sub_options stream_cdda_conf;
+extern const struct m_sub_options stream_dvb_conf;
+extern const struct m_sub_options stream_lavf_conf;
+extern const struct m_sub_options sws_conf;
+extern const struct m_sub_options zimg_conf;
+extern const struct m_sub_options drm_conf;
+extern const struct m_sub_options demux_rawaudio_conf;
+extern const struct m_sub_options demux_rawvideo_conf;
+extern const struct m_sub_options demux_playlist_conf;
+extern const struct m_sub_options demux_lavf_conf;
+extern const struct m_sub_options demux_mkv_conf;
+extern const struct m_sub_options demux_cue_conf;
+extern const struct m_sub_options vd_lavc_conf;
+extern const struct m_sub_options ad_lavc_conf;
+extern const struct m_sub_options input_config;
+extern const struct m_sub_options encode_config;
+extern const struct m_sub_options ra_ctx_conf;
+extern const struct m_sub_options gl_video_conf;
+extern const struct m_sub_options ao_alsa_conf;
+
+extern const struct m_sub_options demux_conf;
+extern const struct m_sub_options demux_cache_conf;
+
+extern const struct m_obj_list vf_obj_list;
+extern const struct m_obj_list af_obj_list;
+extern const struct m_obj_list vo_obj_list;
+
+extern const struct m_sub_options ao_conf;
+
+extern const struct m_sub_options opengl_conf;
+extern const struct m_sub_options vulkan_conf;
+extern const struct m_sub_options vulkan_display_conf;
+extern const struct m_sub_options spirv_conf;
+extern const struct m_sub_options d3d11_conf;
+extern const struct m_sub_options d3d11va_conf;
+extern const struct m_sub_options angle_conf;
+extern const struct m_sub_options macos_conf;
+extern const struct m_sub_options wayland_conf;
+extern const struct m_sub_options wingl_conf;
+extern const struct m_sub_options vaapi_conf;
+
+static const struct m_sub_options screenshot_conf = {
+    .opts = image_writer_opts,
+    .size = sizeof(struct image_writer_opts),
+    .defaults = &image_writer_opts_defaults,
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct mp_vo_opts
+
+static const m_option_t mp_vo_opt_list[] = {
+    {"vo", OPT_SETTINGSLIST(video_driver_list, &vo_obj_list)},
+    {"taskbar-progress", OPT_BOOL(taskbar_progress)},
+    {"drag-and-drop", OPT_CHOICE(drag_and_drop, {"no", -2}, {"auto", -1},
+        {"replace", DND_REPLACE}, {"append", DND_APPEND})},
+    {"snap-window", OPT_BOOL(snap_window)},
+    {"ontop", OPT_BOOL(ontop)},
+    {"ontop-level", OPT_CHOICE(ontop_level, {"window", -1}, {"system", -2},
+        {"desktop", -3}), M_RANGE(0, INT_MAX)},
+    {"border", OPT_BOOL(border)},
+    {"title-bar", OPT_BOOL(title_bar)},
+    {"on-all-workspaces", OPT_BOOL(all_workspaces)},
+    {"geometry", OPT_GEOMETRY(geometry)},
+    {"autofit", OPT_SIZE_BOX(autofit)},
+    {"autofit-larger", OPT_SIZE_BOX(autofit_larger)},
+    {"autofit-smaller", OPT_SIZE_BOX(autofit_smaller)},
+    {"auto-window-resize", OPT_BOOL(auto_window_resize)},
+    {"window-scale", OPT_DOUBLE(window_scale), M_RANGE(0.001, 100)},
+    {"window-minimized", OPT_BOOL(window_minimized)},
+    {"window-maximized", OPT_BOOL(window_maximized)},
+    {"focus-on-open", OPT_BOOL(focus_on_open)},
+    {"force-render", OPT_BOOL(force_render)},
+    {"force-window-position", OPT_BOOL(force_window_position)},
+    {"x11-name", OPT_STRING(winname)},
+    {"wayland-app-id", OPT_STRING(appid)},
+    {"monitoraspect", OPT_FLOAT(force_monitor_aspect), M_RANGE(0.0, 9.0)},
+    {"monitorpixelaspect", OPT_FLOAT(monitor_pixel_aspect),
+        M_RANGE(1.0/32.0, 32.0)},
+    {"fullscreen", OPT_BOOL(fullscreen)},
+    {"fs", OPT_ALIAS("fullscreen")},
+    {"input-cursor-passthrough", OPT_BOOL(cursor_passthrough)},
+    {"native-keyrepeat", OPT_BOOL(native_keyrepeat)},
+    {"panscan", OPT_FLOAT(panscan), M_RANGE(0.0, 1.0)},
+    {"video-zoom", OPT_FLOAT(zoom), M_RANGE(-20.0, 20.0)},
+    {"video-pan-x", OPT_FLOAT(pan_x)},
+    {"video-pan-y", OPT_FLOAT(pan_y)},
+    {"video-align-x", OPT_FLOAT(align_x), M_RANGE(-1.0, 1.0)},
+    {"video-align-y", OPT_FLOAT(align_y), M_RANGE(-1.0, 1.0)},
+    {"video-scale-x", OPT_FLOAT(scale_x), M_RANGE(0, 10000.0)},
+    {"video-scale-y", OPT_FLOAT(scale_y), M_RANGE(0, 10000.0)},
+    {"video-margin-ratio-left", OPT_FLOAT(margin_x[0]), M_RANGE(0.0, 1.0)},
+    {"video-margin-ratio-right", OPT_FLOAT(margin_x[1]), M_RANGE(0.0, 1.0)},
+    {"video-margin-ratio-top", OPT_FLOAT(margin_y[0]), M_RANGE(0.0, 1.0)},
+    {"video-margin-ratio-bottom", OPT_FLOAT(margin_y[1]), M_RANGE(0.0, 1.0)},
+    {"video-crop", OPT_RECT(video_crop), .flags = UPDATE_IMGPAR},
+    {"video-unscaled", OPT_CHOICE(unscaled,
+        {"no", 0}, {"yes", 1}, {"downscale-big", 2})},
+    {"wid", OPT_INT64(WinID)},
+    {"screen", OPT_CHOICE(screen_id, {"default", -1}), M_RANGE(0, 32)},
+    {"screen-name", OPT_STRING(screen_name)},
+    {"fs-screen", OPT_CHOICE(fsscreen_id, {"all", -2}, {"current", -1}),
+        M_RANGE(0, 32)},
+    {"fs-screen-name", OPT_STRING(fsscreen_name)},
+    {"keepaspect", OPT_BOOL(keepaspect)},
+    {"keepaspect-window", OPT_BOOL(keepaspect_window)},
+    {"hidpi-window-scale", OPT_BOOL(hidpi_window_scale)},
+    {"native-fs", OPT_BOOL(native_fs)},
+    {"display-fps-override", OPT_DOUBLE(display_fps_override),
+        M_RANGE(0, DBL_MAX)},
+    {"video-timing-offset", OPT_DOUBLE(timing_offset), M_RANGE(0.0, 1.0)},
+    {"video-sync", OPT_CHOICE(video_sync,
+        {"audio", VS_DEFAULT},
+        {"display-resample", VS_DISP_RESAMPLE},
+        {"display-resample-vdrop", VS_DISP_RESAMPLE_VDROP},
+        {"display-resample-desync", VS_DISP_RESAMPLE_NONE},
+        {"display-tempo", VS_DISP_TEMPO},
+        {"display-adrop", VS_DISP_ADROP},
+        {"display-vdrop", VS_DISP_VDROP},
+        {"display-desync", VS_DISP_NONE},
+        {"desync", VS_NONE})},
+#if HAVE_X11
+    {"x11-netwm", OPT_CHOICE(x11_netwm, {"auto", 0}, {"no", -1}, {"yes", 1})},
+    {"x11-bypass-compositor", OPT_CHOICE(x11_bypass_compositor,
+        {"no", 0}, {"yes", 1}, {"fs-only", 2}, {"never", 3})},
+    {"x11-present", OPT_CHOICE(x11_present,
+        {"no", 0}, {"auto", 1}, {"yes", 2})},
+    {"x11-wid-title", OPT_BOOL(x11_wid_title)},
+#endif
+#if HAVE_WAYLAND
+    {"wayland-content-type", OPT_CHOICE(content_type, {"auto", -1}, {"none", 0},
+        {"photo", 1}, {"video", 2}, {"game", 3})},
+#endif
+#if HAVE_WIN32_DESKTOP
+// For old MinGW-w64 compatibility
+#define DWMWCP_DEFAULT 0
+#define DWMWCP_DONOTROUND 1
+#define DWMWCP_ROUND 2
+#define DWMWCP_ROUNDSMALL 3
+
+#define DWMSBT_AUTO 0
+#define DWMSBT_NONE 1
+#define DWMSBT_MAINWINDOW 2
+#define DWMSBT_TRANSIENTWINDOW 3
+#define DWMSBT_TABBEDWINDOW 4
+
+    {"backdrop-type", OPT_CHOICE(backdrop_type, {"auto", DWMSBT_AUTO}, {"none", DWMSBT_NONE},
+        {"mica", DWMSBT_MAINWINDOW}, {"acrylic", DWMSBT_TRANSIENTWINDOW}, {"mica-alt", DWMSBT_TABBEDWINDOW})},
+    {"window-affinity", OPT_CHOICE(window_affinity, {"default", WDA_NONE},
+        {"excludefromcapture", WDA_EXCLUDEFROMCAPTURE}, {"monitor", WDA_MONITOR})},
+    {"vo-mmcss-profile", OPT_STRING(mmcss_profile)},
+    {"window-corners", OPT_CHOICE(window_corners,
+        {"default", DWMWCP_DEFAULT},
+        {"donotround", DWMWCP_DONOTROUND},
+        {"round", DWMWCP_ROUND},
+        {"roundsmall", DWMWCP_ROUNDSMALL})},
+#endif
+#if HAVE_EGL_ANDROID
+    {"android-surface-size", OPT_SIZE_BOX(android_surface_size)},
+#endif
+    {"swapchain-depth", OPT_INT(swapchain_depth), M_RANGE(1, VO_MAX_SWAPCHAIN_DEPTH)},
+    {"override-display-fps", OPT_REPLACED("display-fps-override")},
+    {0}
+};
+
+const struct m_sub_options vo_sub_opts = {
+    .opts = mp_vo_opt_list,
+    .size = sizeof(struct mp_vo_opts),
+    .defaults = &(const struct mp_vo_opts){
+        .video_driver_list = NULL,
+        .drag_and_drop = -1,
+        .monitor_pixel_aspect = 1.0,
+        .screen_id = -1,
+        .fsscreen_id = -1,
+        .panscan = 0.0f,
+        .scale_x = 1.0f,
+        .scale_y = 1.0f,
+        .auto_window_resize = true,
+        .keepaspect = true,
+        .keepaspect_window = true,
+        .hidpi_window_scale = true,
+        .native_fs = true,
+        .taskbar_progress = true,
+        .border = true,
+        .title_bar = true,
+        .appid = "mpv",
+        .content_type = -1,
+        .WinID = -1,
+        .window_scale = 1.0,
+        .x11_bypass_compositor = 2,
+        .x11_present = 1,
+        .mmcss_profile = "Playback",
+        .ontop_level = -1,
+        .timing_offset = 0.050,
+        .swapchain_depth = 3,
+        .focus_on_open = true,
+    },
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct mp_sub_filter_opts
+
+const struct m_sub_options mp_sub_filter_opts = {
+    .opts = (const struct m_option[]){
+        {"sub-filter-sdh", OPT_BOOL(sub_filter_SDH)},
+        {"sub-filter-sdh-harder", OPT_BOOL(sub_filter_SDH_harder)},
+        {"sub-filter-regex-enable", OPT_BOOL(rf_enable)},
+        {"sub-filter-regex-plain", OPT_BOOL(rf_plain)},
+        {"sub-filter-regex", OPT_STRINGLIST(rf_items)},
+        {"sub-filter-jsre", OPT_STRINGLIST(jsre_items)},
+        {"sub-filter-regex-warn", OPT_BOOL(rf_warn)},
+        {0}
+    },
+    .size = sizeof(OPT_BASE_STRUCT),
+    .defaults = &(OPT_BASE_STRUCT){
+        .rf_enable = true,
+    },
+    .change_flags = UPDATE_SUB_FILT,
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct mp_subtitle_opts
+
+const struct m_sub_options mp_subtitle_sub_opts = {
+    .opts = (const struct m_option[]){
+        {"sub-delay", OPT_FLOAT(sub_delay)},
+        {"sub-fps", OPT_FLOAT(sub_fps)},
+        {"sub-speed", OPT_FLOAT(sub_speed)},
+        {"sub-visibility", OPT_BOOL(sub_visibility)},
+        {"secondary-sub-visibility", OPT_BOOL(sec_sub_visibility)},
+        {"sub-forced-events-only", OPT_BOOL(sub_forced_events_only)},
+        {"stretch-dvd-subs", OPT_BOOL(stretch_dvd_subs)},
+        {"stretch-image-subs-to-screen", OPT_BOOL(stretch_image_subs)},
+        {"image-subs-video-resolution", OPT_BOOL(image_subs_video_res)},
+        {"sub-fix-timing", OPT_BOOL(sub_fix_timing)},
+        {"sub-stretch-durations", OPT_BOOL(sub_stretch_durations)},
+        {"sub-pos", OPT_FLOAT(sub_pos), M_RANGE(0.0, 150.0)},
+        {"sub-gauss", OPT_FLOAT(sub_gauss), M_RANGE(0.0, 3.0)},
+        {"sub-gray", OPT_BOOL(sub_gray)},
+        {"sub-ass", OPT_BOOL(ass_enabled), .flags = UPDATE_SUB_HARD},
+        {"sub-scale", OPT_FLOAT(sub_scale), M_RANGE(0, 100)},
+        {"sub-ass-line-spacing", OPT_FLOAT(ass_line_spacing),
+            M_RANGE(-1000, 1000)},
+        {"sub-use-margins", OPT_BOOL(sub_use_margins)},
+        {"sub-ass-force-margins", OPT_BOOL(ass_use_margins)},
+        {"sub-ass-vsfilter-aspect-compat", OPT_BOOL(ass_vsfilter_aspect_compat)},
+        {"sub-ass-vsfilter-color-compat", OPT_CHOICE(ass_vsfilter_color_compat,
+            {"no", 0}, {"basic", 1}, {"full", 2}, {"force-601", 3})},
+        {"sub-ass-vsfilter-blur-compat", OPT_BOOL(ass_vsfilter_blur_compat)},
+        {"embeddedfonts", OPT_BOOL(use_embedded_fonts), .flags = UPDATE_SUB_HARD},
+        {"sub-ass-style-overrides", OPT_STRINGLIST(ass_style_override_list),
+            .flags = UPDATE_SUB_HARD},
+        {"sub-ass-styles", OPT_STRING(ass_styles_file),
+            .flags = M_OPT_FILE | UPDATE_SUB_HARD},
+        {"sub-ass-hinting", OPT_CHOICE(ass_hinting,
+            {"none", 0}, {"light", 1}, {"normal", 2}, {"native", 3})},
+        {"sub-ass-shaper", OPT_CHOICE(ass_shaper,
+            {"simple", 0}, {"complex", 1})},
+        {"sub-ass-justify", OPT_BOOL(ass_justify)},
+        {"sub-ass-override", OPT_CHOICE(ass_style_override,
+            {"no", 0}, {"yes", 1}, {"force", 3}, {"scale", 4}, {"strip", 5}),
+            .flags = UPDATE_SUB_HARD},
+        {"sub-scale-by-window", OPT_BOOL(sub_scale_by_window)},
+        {"sub-scale-with-window", OPT_BOOL(sub_scale_with_window)},
+        {"sub-ass-scale-with-window", OPT_BOOL(ass_scale_with_window)},
+        {"sub", OPT_SUBSTRUCT(sub_style, sub_style_conf)},
+        {"sub-clear-on-seek", OPT_BOOL(sub_clear_on_seek)},
+        {"teletext-page", OPT_INT(teletext_page), M_RANGE(1, 999)},
+        {"sub-past-video-end", OPT_BOOL(sub_past_video_end)},
+        {"sub-ass-force-style", OPT_REPLACED("sub-ass-style-overrides")},
+        {0}
+    },
+    .size = sizeof(OPT_BASE_STRUCT),
+    .defaults = &(OPT_BASE_STRUCT){
+        .sub_visibility = true,
+        .sec_sub_visibility = true,
+        .sub_pos = 100,
+        .sub_speed = 1.0,
+        .ass_enabled = true,
+        .sub_scale_by_window = true,
+        .sub_use_margins = true,
+        .sub_scale_with_window = true,
+        .teletext_page = 100,
+        .sub_scale = 1,
+        .ass_vsfilter_aspect_compat = true,
+        .ass_vsfilter_color_compat = 1,
+        .ass_vsfilter_blur_compat = true,
+        .ass_style_override = 1,
+        .ass_shaper = 1,
+        .use_embedded_fonts = true,
+    },
+    .change_flags = UPDATE_OSD,
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct mp_osd_render_opts
+
+const struct m_sub_options mp_osd_render_sub_opts = {
+    .opts = (const struct m_option[]){
+        {"osd-bar-align-x", OPT_FLOAT(osd_bar_align_x), M_RANGE(-1.0, +1.0)},
+        {"osd-bar-align-y", OPT_FLOAT(osd_bar_align_y), M_RANGE(-1.0, +1.0)},
+        {"osd-bar-w", OPT_FLOAT(osd_bar_w), M_RANGE(1, 100)},
+        {"osd-bar-h", OPT_FLOAT(osd_bar_h), M_RANGE(0.1, 50)},
+        {"osd", OPT_SUBSTRUCT(osd_style, osd_style_conf)},
+        {"osd-scale", OPT_FLOAT(osd_scale), M_RANGE(0, 100)},
+        {"osd-scale-by-window", OPT_BOOL(osd_scale_by_window)},
+        {"force-rgba-osd-rendering", OPT_BOOL(force_rgba_osd)},
+        {0}
+    },
+    .size = sizeof(OPT_BASE_STRUCT),
+    .defaults = &(OPT_BASE_STRUCT){
+        .osd_bar_align_y = 0.5,
+        .osd_bar_w = 75.0,
+        .osd_bar_h = 3.125,
+        .osd_scale = 1,
+        .osd_scale_by_window = true,
+    },
+    .change_flags = UPDATE_OSD,
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct cuda_opts
+
+const struct m_sub_options cuda_conf = {
+    .opts = (const struct m_option[]){
+        {"decode-device", OPT_CHOICE(cuda_device, {"auto", -1}),
+            M_RANGE(0, INT_MAX)},
+        {0}
+    },
+    .size = sizeof(struct cuda_opts),
+    .defaults = &(const struct cuda_opts){
+        .cuda_device = -1,
+    },
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct dvd_opts
+
+const struct m_sub_options dvd_conf = {
+    .opts = (const struct m_option[]){
+        {"dvd-device", OPT_STRING(device), .flags = M_OPT_FILE},
+        {"dvd-speed", OPT_INT(speed)},
+        {"dvd-angle", OPT_INT(angle), M_RANGE(1, 99)},
+        {0}
+    },
+    .size = sizeof(struct dvd_opts),
+    .defaults = &(const struct dvd_opts){
+        .angle = 1,
+    },
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct filter_opts
+
+const struct m_sub_options filter_conf = {
+    .opts = (const struct m_option[]){
+        {"deinterlace", OPT_BOOL(deinterlace)},
+        {0}
+    },
+    .size = sizeof(OPT_BASE_STRUCT),
+    .change_flags = UPDATE_IMGPAR,
+};
+
+#undef OPT_BASE_STRUCT
+#define OPT_BASE_STRUCT struct MPOpts
+
+static const m_option_t mp_opts[] = {
+    // handled in command line pre-parser (parse_commandline.c)
+    {"v", &m_option_type_dummy_flag, CONF_NOCFG | M_OPT_NOPROP,
+     .offset = -1},
+    {"playlist", CONF_TYPE_STRING, CONF_NOCFG | M_OPT_FILE, .offset = -1},
+    {"{", &m_option_type_dummy_flag, CONF_NOCFG | M_OPT_NOPROP,
+     .offset = -1},
+    {"}", &m_option_type_dummy_flag, CONF_NOCFG | M_OPT_NOPROP,
+     .offset = -1},
+
+    // handled in m_config.c
+    { "include", CONF_TYPE_STRING, M_OPT_FILE, .offset = -1},
+    { "profile", CONF_TYPE_STRING_LIST, 0, .offset = -1},
+    { "show-profile", CONF_TYPE_STRING, CONF_NOCFG | M_OPT_NOPROP |
+        M_OPT_OPTIONAL_PARAM,  .offset = -1},
+    { "list-options", &m_option_type_dummy_flag, CONF_NOCFG | M_OPT_NOPROP,
+        .offset = -1},
+    {"list-properties", OPT_BOOL(property_print_help),
+     .flags = CONF_NOCFG | M_OPT_NOPROP},
+    { "help", CONF_TYPE_STRING, CONF_NOCFG | M_OPT_NOPROP | M_OPT_OPTIONAL_PARAM,
+        .offset = -1},
+    { "h", CONF_TYPE_STRING, CONF_NOCFG | M_OPT_NOPROP | M_OPT_OPTIONAL_PARAM,
+        .offset = -1},
+
+    {"list-protocols", OPT_PRINT(stream_print_proto_list)},
+    {"version", OPT_PRINT(print_version)},
+    {"V", OPT_PRINT(print_version)},
+
+    {"player-operation-mode", OPT_CHOICE(operation_mode,
+        {"cplayer", 0}, {"pseudo-gui", 1}),
+        .flags = M_OPT_PRE_PARSE | M_OPT_NOPROP},
+
+    {"shuffle", OPT_BOOL(shuffle)},
+
+// ------------------------- common options --------------------
+    {"quiet", OPT_BOOL(quiet)},
+    {"really-quiet", OPT_BOOL(msg_really_quiet),
+        .flags = CONF_PRE_PARSE | UPDATE_TERM},
+    {"terminal", OPT_BOOL(use_terminal), .flags = CONF_PRE_PARSE | UPDATE_TERM},
+    {"msg-level", OPT_MSGLEVELS(msg_levels),
+        .flags = CONF_PRE_PARSE | UPDATE_TERM},
+    {"dump-stats", OPT_STRING(dump_stats),
+        .flags = UPDATE_TERM | CONF_PRE_PARSE | M_OPT_FILE},
+    {"msg-color", OPT_BOOL(msg_color), .flags = CONF_PRE_PARSE | UPDATE_TERM},
+    {"log-file", OPT_STRING(log_file),
+        .flags = CONF_PRE_PARSE | M_OPT_FILE | UPDATE_TERM},
+    {"msg-module", OPT_BOOL(msg_module), .flags = UPDATE_TERM},
+    {"msg-time", OPT_BOOL(msg_time), .flags = UPDATE_TERM},
+#if HAVE_WIN32_DESKTOP
+    {"priority", OPT_CHOICE(w32_priority,
+        {"no",          0},
+        {"realtime",    REALTIME_PRIORITY_CLASS},
+        {"high",        HIGH_PRIORITY_CLASS},
+        {"abovenormal", ABOVE_NORMAL_PRIORITY_CLASS},
+        {"normal",      NORMAL_PRIORITY_CLASS},
+        {"belownormal", BELOW_NORMAL_PRIORITY_CLASS},
+        {"idle",        IDLE_PRIORITY_CLASS}),
+        .flags = UPDATE_PRIORITY},
+#endif
+    {"config", OPT_BOOL(load_config), .flags = CONF_PRE_PARSE},
+    {"config-dir", OPT_STRING(force_configdir),
+        .flags = CONF_NOCFG | CONF_PRE_PARSE | M_OPT_FILE},
+    {"reset-on-next-file", OPT_STRINGLIST(reset_options)},
+
+#if HAVE_LUA || HAVE_JAVASCRIPT || HAVE_CPLUGINS
+    {"scripts", OPT_PATHLIST(script_files), .flags = M_OPT_FILE},
+    {"script", OPT_CLI_ALIAS("scripts-append")},
+    {"script-opts", OPT_KEYVALUELIST(script_opts)},
+    {"load-scripts", OPT_BOOL(auto_load_scripts)},
+#endif
+#if HAVE_JAVASCRIPT
+    {"js-memory-report", OPT_BOOL(js_memory_report)},
+#endif
+#if HAVE_LUA
+    {"osc", OPT_BOOL(lua_load_osc), .flags = UPDATE_BUILTIN_SCRIPTS},
+    {"ytdl", OPT_BOOL(lua_load_ytdl), .flags = UPDATE_BUILTIN_SCRIPTS},
+    {"ytdl-format", OPT_STRING(lua_ytdl_format)},
+    {"ytdl-raw-options", OPT_KEYVALUELIST(lua_ytdl_raw_options)},
+    {"load-stats-overlay", OPT_BOOL(lua_load_stats),
+        .flags = UPDATE_BUILTIN_SCRIPTS},
+    {"load-osd-console", OPT_BOOL(lua_load_console),
+        .flags = UPDATE_BUILTIN_SCRIPTS},
+    {"load-auto-profiles",
+        OPT_CHOICE(lua_load_auto_profiles, {"no", 0}, {"yes", 1}, {"auto", -1}),
+        .flags = UPDATE_BUILTIN_SCRIPTS},
+#endif
+
+// ------------------------- stream options --------------------
+
+#if HAVE_DVDNAV
+    {"", OPT_SUBSTRUCT(dvd_opts, dvd_conf)},
+#endif
+    {"edition", OPT_CHOICE(edition_id, {"auto", -1}), M_RANGE(0, 8190)},
+#if HAVE_LIBBLURAY
+    {"bluray", OPT_SUBSTRUCT(stream_bluray_opts, stream_bluray_conf)},
+#endif /* HAVE_LIBBLURAY */
+
+// ------------------------- demuxer options --------------------
+
+    {"frames", OPT_CHOICE(play_frames, {"all", -1}), M_RANGE(0, INT_MAX)},
+
+    {"start", OPT_REL_TIME(play_start)},
+    {"end", OPT_REL_TIME(play_end)},
+    {"length", OPT_REL_TIME(play_length)},
+
+    {"play-direction", OPT_CHOICE(play_dir,
+        {"forward", 1}, {"+", 1}, {"backward", -1}, {"-", -1})},
+
+    {"rebase-start-time", OPT_BOOL(rebase_start_time)},
+
+    {"ab-loop-a", OPT_TIME(ab_loop[0]), .flags = M_OPT_ALLOW_NO},
+    {"ab-loop-b", OPT_TIME(ab_loop[1]), .flags = M_OPT_ALLOW_NO},
+    {"ab-loop-count", OPT_CHOICE(ab_loop_count, {"inf", -1}),
+        M_RANGE(0, INT_MAX)},
+
+    {"playlist-start", OPT_CHOICE(playlist_pos, {"auto", -1}, {"no", -1}),
+        M_RANGE(0, INT_MAX)},
+
+    {"pause", OPT_BOOL(pause)},
+    {"keep-open", OPT_CHOICE(keep_open,
+        {"no", 0},
+        {"yes", 1},
+        {"always", 2})},
+    {"keep-open-pause", OPT_BOOL(keep_open_pause)},
+    {"image-display-duration", OPT_DOUBLE(image_display_duration),
+        M_RANGE(0, INFINITY)},
+
+    // select audio/video/subtitle stream
+    // keep in sync with num_ptracks[] and MAX_PTRACKS
+    {"aid", OPT_TRACKCHOICE(stream_id[0][STREAM_AUDIO])},
+    {"vid", OPT_TRACKCHOICE(stream_id[0][STREAM_VIDEO])},
+    {"sid", OPT_TRACKCHOICE(stream_id[0][STREAM_SUB])},
+    {"secondary-sid", OPT_TRACKCHOICE(stream_id[1][STREAM_SUB])},
+    {"sub", OPT_ALIAS("sid")},
+    {"video", OPT_ALIAS("vid")},
+    {"audio", OPT_ALIAS("aid")},
+    {"alang", OPT_STRINGLIST(stream_lang[STREAM_AUDIO])},
+    {"slang", OPT_STRINGLIST(stream_lang[STREAM_SUB])},
+    {"vlang", OPT_STRINGLIST(stream_lang[STREAM_VIDEO])},
+    {"track-auto-selection", OPT_BOOL(stream_auto_sel)},
+    {"subs-with-matching-audio", OPT_BOOL(subs_with_matching_audio)},
+    {"subs-match-os-language", OPT_BOOL(subs_match_os_language)},
+    {"subs-fallback", OPT_CHOICE(subs_fallback, {"no", 0}, {"default", 1}, {"yes", 2})},
+    {"subs-fallback-forced", OPT_CHOICE(subs_fallback_forced, {"no", 0},
+        {"yes", 1}, {"always", 2})},
+
+    {"lavfi-complex", OPT_STRING(lavfi_complex), .flags = UPDATE_LAVFI_COMPLEX},
+
+    {"audio-display", OPT_CHOICE(audio_display, {"no", 0},
+        {"embedded-first", 1}, {"external-first", 2})},
+
+    {"hls-bitrate", OPT_CHOICE(hls_bitrate,
+        {"no", -1}, {"min", 0}, {"max", INT_MAX}), M_RANGE(0, INT_MAX)},
+
+    {"display-tags", OPT_STRINGLIST(display_tags)},
+
+#if HAVE_CDDA
+    {"cdda", OPT_SUBSTRUCT(stream_cdda_opts, stream_cdda_conf)},
+    {"cdrom-device", OPT_REPLACED("cdda-device")},
+#endif
+
+    // demuxer.c - select audio/sub file/demuxer
+    {"demuxer", OPT_STRING(demuxer_name), .help = demuxer_help},
+    {"audio-demuxer", OPT_STRING(audio_demuxer_name), .help = demuxer_help},
+    {"sub-demuxer", OPT_STRING(sub_demuxer_name), .help = demuxer_help},
+    {"demuxer-thread", OPT_BOOL(demuxer_thread)},
+    {"demuxer-termination-timeout", OPT_DOUBLE(demux_termination_timeout)},
+    {"demuxer-cache-wait", OPT_BOOL(demuxer_cache_wait)},
+    {"prefetch-playlist", OPT_BOOL(prefetch_open)},
+    {"cache-pause", OPT_BOOL(cache_pause)},
+    {"cache-pause-initial", OPT_BOOL(cache_pause_initial)},
+    {"cache-pause-wait", OPT_FLOAT(cache_pause_wait), M_RANGE(0, DBL_MAX)},
+
+#if HAVE_DVBIN
+    {"dvbin", OPT_SUBSTRUCT(stream_dvb_opts, stream_dvb_conf)},
+#endif
+    {"", OPT_SUBSTRUCT(stream_lavf_opts, stream_lavf_conf)},
+
+// ------------------------- a-v sync options --------------------
+
+    // set A-V sync correction speed (0=disables it):
+    {"mc", OPT_FLOAT(default_max_pts_correction), M_RANGE(0, 100)},
+
+    {"audio-samplerate", OPT_INT(force_srate), .flags = UPDATE_AUDIO,
+        M_RANGE(0, 16*48000)},
+    {"audio-channels", OPT_CHANNELS(audio_output_channels), .flags = UPDATE_AUDIO},
+    {"audio-format", OPT_AUDIOFORMAT(audio_output_format), .flags = UPDATE_AUDIO},
+    {"speed", OPT_DOUBLE(playback_speed), M_RANGE(0.01, 100.0)},
+
+    {"audio-pitch-correction", OPT_BOOL(pitch_correction)},
+
+    // set a-v distance
+    {"audio-delay", OPT_FLOAT(audio_delay)},
+
+// ------------------------- codec/vfilter options --------------------
+
+    {"af", OPT_SETTINGSLIST(af_settings, &af_obj_list)},
+    {"vf", OPT_SETTINGSLIST(vf_settings, &vf_obj_list)},
+
+    {"", OPT_SUBSTRUCT(filter_opts, filter_conf)},
+
+    {"", OPT_SUBSTRUCT(dec_wrapper, dec_wrapper_conf)},
+    {"", OPT_SUBSTRUCT(vd_lavc_params, vd_lavc_conf)},
+    {"ad-lavc", OPT_SUBSTRUCT(ad_lavc_params, ad_lavc_conf)},
+
+    {"", OPT_SUBSTRUCT(demux_lavf, demux_lavf_conf)},
+    {"demuxer-rawaudio", OPT_SUBSTRUCT(demux_rawaudio, demux_rawaudio_conf)},
+    {"demuxer-rawvideo", OPT_SUBSTRUCT(demux_rawvideo, demux_rawvideo_conf)},
+    {"", OPT_SUBSTRUCT(demux_playlist, demux_playlist_conf)},
+    {"demuxer-mkv", OPT_SUBSTRUCT(demux_mkv, demux_mkv_conf)},
+    {"demuxer-cue", OPT_SUBSTRUCT(demux_cue, demux_cue_conf)},
+
+// ------------------------- subtitles options --------------------
+
+    {"sub-files", OPT_PATHLIST(sub_name), .flags = M_OPT_FILE},
+    {"sub-file", OPT_CLI_ALIAS("sub-files-append")},
+    {"audio-files", OPT_PATHLIST(audio_files), .flags = M_OPT_FILE},
+    {"audio-file", OPT_CLI_ALIAS("audio-files-append")},
+    {"cover-art-files", OPT_PATHLIST(coverart_files), .flags = M_OPT_FILE},
+    {"cover-art-file", OPT_CLI_ALIAS("cover-art-files-append")},
+
+    {"sub-file-paths", OPT_PATHLIST(sub_paths), .flags = M_OPT_FILE},
+    {"audio-file-paths", OPT_PATHLIST(audiofile_paths), .flags = M_OPT_FILE},
+
+    {"external-files", OPT_PATHLIST(external_files), .flags = M_OPT_FILE},
+    {"external-file", OPT_CLI_ALIAS("external-files-append")},
+    {"autoload-files", OPT_BOOL(autoload_files)},
+
+    {"sub-auto", OPT_CHOICE(sub_auto,
+        {"no", -1}, {"exact", 0}, {"fuzzy", 1}, {"all", 2})},
+    {"sub-auto-exts", OPT_STRINGLIST(sub_auto_exts), .flags = UPDATE_SUB_EXTS},
+    {"audio-file-auto", OPT_CHOICE(audiofile_auto,
+        {"no", -1}, {"exact", 0}, {"fuzzy", 1}, {"all", 2})},
+    {"audio-file-auto-exts", OPT_STRINGLIST(audiofile_auto_exts)},
+    {"cover-art-auto", OPT_CHOICE(coverart_auto,
+        {"no", -1}, {"exact", 0}, {"fuzzy", 1}, {"all", 2})},
+    {"cover-art-auto-exts", OPT_STRINGLIST(coverart_auto_exts)},
+    {"cover-art-whitelist", OPT_BOOL(coverart_whitelist)},
+
+    {"", OPT_SUBSTRUCT(subs_rend, mp_subtitle_sub_opts)},
+    {"", OPT_SUBSTRUCT(subs_filt, mp_sub_filter_opts)},
+    {"", OPT_SUBSTRUCT(osd_rend, mp_osd_render_sub_opts)},
+
+    {"osd-bar", OPT_BOOL(osd_bar_visible), .flags = UPDATE_OSD},
+
+//---------------------- libao/libvo options ------------------------
+    {"", OPT_SUBSTRUCT(ao_opts, ao_conf)},
+    {"audio-exclusive", OPT_BOOL(audio_exclusive), .flags = UPDATE_AUDIO},
+    {"audio-fallback-to-null", OPT_BOOL(ao_null_fallback)},
+    {"audio-stream-silence", OPT_BOOL(audio_stream_silence)},
+    {"audio-wait-open", OPT_FLOAT(audio_wait_open), M_RANGE(0, 60)},
+    {"force-window", OPT_CHOICE(force_vo,
+        {"no", 0}, {"yes", 1}, {"immediate", 2})},
+
+    {"volume-max", OPT_FLOAT(softvol_max), M_RANGE(100, 1000)},
+    // values <0 for volume and mute are legacy and ignored
+    {"volume", OPT_FLOAT(softvol_volume), .flags = UPDATE_VOL,
+        M_RANGE(-1, 1000)},
+    {"mute", OPT_CHOICE(softvol_mute,
+        {"no", 0},
+        {"auto", 0},
+        {"yes", 1}),
+        .flags = UPDATE_VOL},
+    {"replaygain", OPT_CHOICE(rgain_mode,
+        {"no", 0},
+        {"track", 1},
+        {"album", 2}),
+        .flags = UPDATE_VOL},
+    {"replaygain-preamp", OPT_FLOAT(rgain_preamp), .flags = UPDATE_VOL,
+        M_RANGE(-150, 150)},
+    {"replaygain-clip", OPT_BOOL(rgain_clip), .flags = UPDATE_VOL},
+    {"replaygain-fallback", OPT_FLOAT(rgain_fallback), .flags = UPDATE_VOL,
+        M_RANGE(-200, 60)},
+    {"gapless-audio", OPT_CHOICE(gapless_audio,
+        {"no", 0},
+        {"yes", 1},
+        {"weak", -1})},
+
+    {"title", OPT_STRING(wintitle)},
+    {"force-media-title", OPT_STRING(media_title)},
+
+    {"cursor-autohide", OPT_CHOICE(cursor_autohide_delay,
+        {"no", -1}, {"always", -2}), M_RANGE(0, 30000)},
+    {"cursor-autohide-fs-only", OPT_BOOL(cursor_autohide_fs)},
+    {"stop-screensaver", OPT_CHOICE(stop_screensaver,
+        {"no", 0},
+        {"yes", 1},
+        {"always", 2}),
+        .flags = UPDATE_SCREENSAVER},
+
+    {"", OPT_SUBSTRUCT(video_equalizer, mp_csp_equalizer_conf)},
+
+    {"use-filedir-conf", OPT_BOOL(use_filedir_conf)},
+    {"osd-level", OPT_CHOICE(osd_level,
+        {"0", 0}, {"1", 1}, {"2", 2}, {"3", 3})},
+    {"osd-on-seek", OPT_CHOICE(osd_on_seek,
+        {"no", 0},
+        {"bar", 1},
+        {"msg", 2},
+        {"msg-bar", 3})},
+    {"osd-duration", OPT_INT(osd_duration), M_RANGE(0, 3600000)},
+    {"osd-fractions", OPT_BOOL(osd_fractions)},
+
+    {"sstep", OPT_DOUBLE(step_sec), M_RANGE(0, DBL_MAX)},
+
+    {"framedrop", OPT_CHOICE(frame_dropping,
+        {"no", 0},
+        {"vo", 1},
+        {"decoder", 2},
+        {"decoder+vo", 3})},
+    {"video-latency-hacks", OPT_BOOL(video_latency_hacks)},
+
+    {"untimed", OPT_BOOL(untimed)},
+
+    {"stream-dump", OPT_STRING(stream_dump), .flags = M_OPT_FILE},
+
+    {"stop-playback-on-init-failure", OPT_BOOL(stop_playback_on_init_failure)},
+
+    {"loop-playlist", OPT_CHOICE(loop_times,
+        {"no", 1},
+        {"inf", -1}, {"yes", -1},
+        {"force", -2}),
+        M_RANGE(1, 10000)},
+    {"loop-file", OPT_CHOICE(loop_file,
+        {"no", 0},
+        {"inf", -1},
+        {"yes", -1}),
+        M_RANGE(0, 10000)},
+    {"loop", OPT_ALIAS("loop-file")},
+
+    {"resume-playback", OPT_BOOL(position_resume)},
+    {"resume-playback-check-mtime", OPT_BOOL(position_check_mtime)},
+    {"save-position-on-quit", OPT_BOOL(position_save_on_quit)},
+    {"write-filename-in-watch-later-config",
+        OPT_BOOL(write_filename_in_watch_later_config)},
+    {"ignore-path-in-watch-later-config",
+        OPT_BOOL(ignore_path_in_watch_later_config)},
+    {"watch-later-dir", OPT_STRING(watch_later_dir),
+        .flags = M_OPT_FILE},
+    {"watch-later-directory", OPT_ALIAS("watch-later-dir")},
+    {"watch-later-options", OPT_STRINGLIST(watch_later_options)},
+
+    {"ordered-chapters", OPT_BOOL(ordered_chapters)},
+    {"ordered-chapters-files", OPT_STRING(ordered_chapters_files),
+        .flags = M_OPT_FILE},
+    {"chapter-merge-threshold", OPT_INT(chapter_merge_threshold),
+        M_RANGE(0, 10000)},
+
+    {"chapter-seek-threshold", OPT_DOUBLE(chapter_seek_threshold)},
+
+    {"chapters-file", OPT_STRING(chapter_file), .flags = M_OPT_FILE},
+
+    {"merge-files", OPT_BOOL(merge_files)},
+
+    // a-v sync stuff:
+    {"initial-audio-sync", OPT_BOOL(initial_audio_sync)},
+    {"video-sync-max-video-change", OPT_DOUBLE(sync_max_video_change),
+        M_RANGE(0, DBL_MAX)},
+    {"video-sync-max-audio-change", OPT_DOUBLE(sync_max_audio_change),
+        M_RANGE(0, 1)},
+    {"video-sync-max-factor", OPT_INT(sync_max_factor), M_RANGE(1, 10)},
+    {"hr-seek", OPT_CHOICE(hr_seek,
+        {"no", -1}, {"absolute", 0}, {"yes", 1}, {"always", 1}, {"default", 2})},
+    {"hr-seek-demuxer-offset", OPT_FLOAT(hr_seek_demuxer_offset)},
+    {"hr-seek-framedrop", OPT_BOOL(hr_seek_framedrop)},
+    {"autosync", OPT_CHOICE(autosync, {"no", -1}), M_RANGE(0, 10000)},
+
+    {"term-osd", OPT_CHOICE(term_osd,
+        {"force", 1}, {"auto", 2}, {"no", 0}), .flags = UPDATE_OSD},
+
+    {"term-osd-bar", OPT_BOOL(term_osd_bar), .flags = UPDATE_OSD},
+    {"term-osd-bar-chars", OPT_STRING(term_osd_bar_chars), .flags = UPDATE_OSD},
+    {"term-remaining-playtime", OPT_BOOL(term_remaining_playtime), .flags = UPDATE_OSD},
+    {"term-title", OPT_STRING(term_title), .flags = UPDATE_OSD},
+
+    {"term-playing-msg", OPT_STRING(playing_msg)},
+    {"osd-playing-msg", OPT_STRING(osd_playing_msg)},
+    {"osd-playing-msg-duration", OPT_INT(osd_playing_msg_duration),
+        M_RANGE(0, 3600000)},
+    {"term-status-msg", OPT_STRING(status_msg), .flags = UPDATE_OSD},
+    {"osd-status-msg", OPT_STRING(osd_status_msg), .flags = UPDATE_OSD},
+    {"osd-msg1", OPT_STRING(osd_msg[0]), .flags = UPDATE_OSD},
+    {"osd-msg2", OPT_STRING(osd_msg[1]), .flags = UPDATE_OSD},
+    {"osd-msg3", OPT_STRING(osd_msg[2]), .flags = UPDATE_OSD},
+
+    {"video-osd", OPT_BOOL(video_osd), .flags = UPDATE_OSD},
+
+    {"idle", OPT_CHOICE(player_idle_mode,
+        {"no",   0}, {"once", 1}, {"yes",  2})},
+
+    {"input-terminal", OPT_BOOL(consolecontrols), .flags = UPDATE_TERM},
+
+    {"input-ipc-server", OPT_STRING(ipc_path), .flags = M_OPT_FILE},
+#if HAVE_POSIX
+    {"input-ipc-client", OPT_STRING(ipc_client)},
+#endif
+
+    {"screenshot", OPT_SUBSTRUCT(screenshot_image_opts, screenshot_conf)},
+    {"screenshot-template", OPT_STRING(screenshot_template)},
+    {"screenshot-dir", OPT_STRING(screenshot_dir),
+        .flags = M_OPT_FILE},
+    {"screenshot-directory", OPT_ALIAS("screenshot-dir")},
+    {"screenshot-sw", OPT_BOOL(screenshot_sw)},
+
+    {"", OPT_SUBSTRUCT(resample_opts, resample_conf)},
+
+    {"", OPT_SUBSTRUCT(input_opts, input_config)},
+
+    {"", OPT_SUBSTRUCT(vo, vo_sub_opts)},
+    {"", OPT_SUBSTRUCT(demux_opts, demux_conf)},
+    {"", OPT_SUBSTRUCT(demux_cache_opts, demux_cache_conf)},
+    {"", OPT_SUBSTRUCT(stream_opts, stream_conf)},
+
+    {"", OPT_SUBSTRUCT(ra_ctx_opts, ra_ctx_conf)},
+    {"", OPT_SUBSTRUCT(gl_video_opts, gl_video_conf)},
+    {"", OPT_SUBSTRUCT(spirv_opts, spirv_conf)},
+
+#if HAVE_GL
+    {"", OPT_SUBSTRUCT(opengl_opts, opengl_conf)},
+#endif
+
+#if HAVE_VULKAN
+    {"", OPT_SUBSTRUCT(vulkan_opts, vulkan_conf)},
+#if HAVE_VK_KHR_DISPLAY
+    {"", OPT_SUBSTRUCT(vulkan_display_opts, vulkan_display_conf)},
+#endif
+#endif
+
+#if HAVE_D3D11
+    {"", OPT_SUBSTRUCT(d3d11_opts, d3d11_conf)},
+#if HAVE_D3D_HWACCEL
+    {"", OPT_SUBSTRUCT(d3d11va_opts, d3d11va_conf)},
+#endif
+#endif
+
+#if HAVE_EGL_ANGLE_WIN32
+    {"", OPT_SUBSTRUCT(angle_opts, angle_conf)},
+#endif
+
+#if HAVE_COCOA
+    {"", OPT_SUBSTRUCT(macos_opts, macos_conf)},
+#endif
+
+#if HAVE_DRM
+    {"", OPT_SUBSTRUCT(drm_opts, drm_conf)},
+#endif
+
+#if HAVE_WAYLAND
+    {"", OPT_SUBSTRUCT(wayland_opts, wayland_conf)},
+#endif
+
+#if HAVE_GL_WIN32
+    {"", OPT_SUBSTRUCT(wingl_opts, wingl_conf)},
+#endif
+
+#if HAVE_CUDA_HWACCEL
+    {"cuda", OPT_SUBSTRUCT(cuda_opts, cuda_conf)},
+#endif
+
+#if HAVE_VAAPI
+    {"vaapi", OPT_SUBSTRUCT(vaapi_opts, vaapi_conf)},
+#endif
+
+    {"sws", OPT_SUBSTRUCT(sws_opts, sws_conf)},
+
+#if HAVE_ZIMG
+    {"zimg", OPT_SUBSTRUCT(zimg_opts, zimg_conf)},
+#endif
+
+    {"", OPT_SUBSTRUCT(encode_opts, encode_config)},
+
+    {"play-dir", OPT_REPLACED("play-direction")},
+    {"sub-forced-only", OPT_REPLACED("sub-forced-events-only")},
+    {0}
+};
+
+static const struct MPOpts mp_default_opts = {
+    .use_terminal = true,
+    .msg_color = true,
+    .softvol_max = 130,
+    .softvol_volume = 100,
+    .gapless_audio = -1,
+    .wintitle = "${?media-title:${media-title}}${!media-title:No file} - mpv",
+    .stop_screensaver = 1,
+    .cursor_autohide_delay = 1000,
+    .video_osd = true,
+    .osd_level = 1,
+    .osd_on_seek = 1,
+    .osd_duration = 1000,
+#if HAVE_LUA
+    .lua_load_osc = true,
+    .lua_load_ytdl = true,
+    .lua_ytdl_format = NULL,
+    .lua_ytdl_raw_options = NULL,
+    .lua_load_stats = true,
+    .lua_load_console = true,
+    .lua_load_auto_profiles = -1,
+#endif
+    .auto_load_scripts = true,
+    .loop_times = 1,
+    .ordered_chapters = true,
+    .chapter_merge_threshold = 100,
+    .chapter_seek_threshold = 5.0,
+    .hr_seek = 2,
+    .hr_seek_framedrop = true,
+    .sync_max_video_change = 1,
+    .sync_max_audio_change = 0.125,
+    .sync_max_factor = 5,
+    .load_config = true,
+    .position_resume = true,
+    .autoload_files = true,
+    .demuxer_thread = true,
+    .demux_termination_timeout = 0.1,
+    .hls_bitrate = INT_MAX,
+    .cache_pause = true,
+    .cache_pause_wait = 1.0,
+    .ab_loop = {MP_NOPTS_VALUE, MP_NOPTS_VALUE},
+    .ab_loop_count = -1,
+    .edition_id = -1,
+    .default_max_pts_correction = -1,
+    .initial_audio_sync = true,
+    .frame_dropping = 1,
+    .term_osd = 2,
+    .term_osd_bar_chars = "[-+-]",
+    .term_remaining_playtime = true,
+    .consolecontrols = true,
+    .playlist_pos = -1,
+    .play_frames = -1,
+    .rebase_start_time = true,
+    .keep_open_pause = true,
+    .image_display_duration = 1.0,
+    .stream_id = { { [STREAM_AUDIO] = -1,
+                     [STREAM_VIDEO] = -1,
+                     [STREAM_SUB] = -1, },
+                   { [STREAM_AUDIO] = -2,
+                     [STREAM_VIDEO] = -2,
+                     [STREAM_SUB] = -2, }, },
+    .stream_auto_sel = true,
+    .subs_with_matching_audio = true,
+    .subs_match_os_language = true,
+    .subs_fallback = 1,
+    .subs_fallback_forced = 1,
+    .audio_display = 1,
+    .audio_output_format = 0,  // AF_FORMAT_UNKNOWN
+    .playback_speed = 1.,
+    .pitch_correction = true,
+    .audiofile_auto = -1,
+    .coverart_whitelist = true,
+    .osd_bar_visible = true,
+    .screenshot_template = "mpv-shot%n",
+    .play_dir = 1,
+
+    .audiofile_auto_exts = (char *[]){
+        "aac",
+        "ac3",
+        "dts",
+        "eac3",
+        "flac",
+        "m4a",
+        "mka",
+        "mp3",
+        "ogg",
+        "opus",
+        "thd",
+        "wav",
+        "wv",
+        NULL
+    },
+
+    .coverart_auto_exts = (char *[]){
+        "avif",
+        "bmp",
+        "gif",
+        "jpeg",
+        "jpg",
+        "jxl",
+        "png",
+        "tif",
+        "tiff",
+        "webp",
+        NULL
+    },
+
+    .sub_auto_exts = (char *[]){
+        "ass",
+        "idx",
+        "lrc",
+        "mks",
+        "pgs",
+        "rt",
+        "sbv",
+        "scc",
+        "smi",
+        "srt",
+        "ssa",
+        "sub",
+        "sup",
+        "utf",
+        "utf-8",
+        "utf8",
+        "vtt",
+        NULL
+    },
+
+    .audio_output_channels = {
+        .set = 1,
+        .auto_safe = 1,
+    },
+
+    .display_tags = (char *[]){
+        "Artist", "Album", "Album_Artist", "Comment", "Composer",
+        "Date", "Description", "Genre", "Performer", "Rating",
+        "Series", "Title", "Track", "icy-title", "service_name",
+        "Uploader", "Channel_URL",
+        NULL
+    },
+
+    .cuda_device = -1,
+
+    .watch_later_options = (char *[]){
+        "start",
+        "speed",
+        "edition",
+        "volume",
+        "mute",
+        "audio-delay",
+        "gamma",
+        "brightness",
+        "contrast",
+        "saturation",
+        "hue",
+        "deinterlace",
+        "vf",
+        "af",
+        "panscan",
+        "aid",
+        "vid",
+        "sid",
+        "sub-delay",
+        "sub-speed",
+        "sub-pos",
+        "sub-visibility",
+        "sub-scale",
+        "sub-use-margins",
+        "sub-ass-force-margins",
+        "sub-ass-vsfilter-aspect-compat",
+        "sub-ass-override",
+        "secondary-sub-visibility",
+        "ab-loop-a",
+        "ab-loop-b",
+        "video-aspect-override",
+        "video-aspect-method",
+        "video-unscaled",
+        "video-pan-x",
+        "video-pan-y",
+        "video-rotate",
+        "video-crop",
+        "video-zoom",
+        "video-scale-x",
+        "video-scale-y",
+        "video-align-x",
+        "video-align-y",
+        NULL
+    },
+};
+
+const struct m_sub_options mp_opt_root = {
+    .opts = mp_opts,
+    .size = sizeof(struct MPOpts),
+    .defaults = &mp_default_opts,
+};
+
+#endif /* MPLAYER_CFG_MPLAYER_H */
diff --git a/options/options.h b/options/options.h
new file mode 100644
index 0000000..aa071b2
--- /dev/null
+++ b/options/options.h
@@ -0,0 +1,406 @@
+#ifndef MPLAYER_OPTIONS_H
+#define MPLAYER_OPTIONS_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "m_option.h"
+#include "common/common.h"
+
+typedef struct mp_vo_opts {
+    struct m_obj_settings *video_driver_list;
+
+    bool taskbar_progress;
+    bool snap_window;
+    int drag_and_drop;
+    bool ontop;
+    int ontop_level;
+    bool fullscreen;
+    bool border;
+    bool title_bar;
+    bool all_workspaces;
+    bool window_minimized;
+    bool window_maximized;
+    bool focus_on_open;
+
+    int screen_id;
+    char *screen_name;
+    int fsscreen_id;
+    char *fsscreen_name;
+    char *winname;
+    char *appid;
+    int content_type;
+    int x11_netwm;
+    int x11_bypass_compositor;
+    int x11_present;
+    bool x11_wid_title;
+    bool cursor_passthrough;
+    bool native_keyrepeat;
+
+    float panscan;
+    float zoom;
+    float pan_x, pan_y;
+    float align_x, align_y;
+    float scale_x, scale_y;
+    float margin_x[2];
+    float margin_y[2];
+    int unscaled;
+
+    struct m_geometry geometry;
+    struct m_geometry autofit;
+    struct m_geometry autofit_larger;
+    struct m_geometry autofit_smaller;
+    double window_scale;
+
+    bool auto_window_resize;
+    bool keepaspect;
+    bool keepaspect_window;
+    bool hidpi_window_scale;
+    bool native_fs;
+
+    int64_t WinID;
+
+    float force_monitor_aspect;
+    float monitor_pixel_aspect;
+    bool force_render;
+    bool force_window_position;
+
+    int backdrop_type;
+    int window_affinity;
+    char *mmcss_profile;
+    int window_corners;
+
+    double display_fps_override;
+    double timing_offset;
+    int video_sync;
+
+    struct m_geometry android_surface_size;
+
+    int swapchain_depth;  // max number of images to render ahead
+
+    struct m_geometry video_crop;
+} mp_vo_opts;
+
+// Subtitle options needed by the subtitle decoders/renderers.
+struct mp_subtitle_opts {
+    bool sub_visibility;
+    bool sec_sub_visibility;
+    float sub_pos;
+    float sub_delay;
+    float sub_fps;
+    float sub_speed;
+    bool sub_forced_events_only;
+    bool stretch_dvd_subs;
+    bool stretch_image_subs;
+    bool image_subs_video_res;
+    bool sub_fix_timing;
+    bool sub_stretch_durations;
+    bool sub_scale_by_window;
+    bool sub_scale_with_window;
+    bool ass_scale_with_window;
+    struct osd_style_opts *sub_style;
+    float sub_scale;
+    float sub_gauss;
+    bool sub_gray;
+    bool ass_enabled;
+    float ass_line_spacing;
+    bool ass_use_margins;
+    bool sub_use_margins;
+    bool ass_vsfilter_aspect_compat;
+    int ass_vsfilter_color_compat;
+    bool ass_vsfilter_blur_compat;
+    bool use_embedded_fonts;
+    char **ass_style_override_list;
+    char *ass_styles_file;
+    int ass_style_override;
+    int ass_hinting;
+    int ass_shaper;
+    bool ass_justify;
+    bool sub_clear_on_seek;
+    int teletext_page;
+    bool sub_past_video_end;
+};
+
+struct mp_sub_filter_opts {
+    bool sub_filter_SDH;
+    bool sub_filter_SDH_harder;
+    bool rf_enable;
+    bool rf_plain;
+    char **rf_items;
+    char **jsre_items;
+    bool rf_warn;
+};
+
+struct mp_osd_render_opts {
+    float osd_bar_align_x;
+    float osd_bar_align_y;
+    float osd_bar_w;
+    float osd_bar_h;
+    float osd_scale;
+    bool osd_scale_by_window;
+    struct osd_style_opts *osd_style;
+    bool force_rgba_osd;
+};
+
+typedef struct MPOpts {
+    bool property_print_help;
+    bool use_terminal;
+    char *dump_stats;
+    int verbose;
+    bool msg_really_quiet;
+    char **msg_levels;
+    bool msg_color;
+    bool msg_module;
+    bool msg_time;
+    char *log_file;
+
+    int operation_mode;
+
+    char **reset_options;
+    char **script_files;
+    char **script_opts;
+    bool js_memory_report;
+    bool lua_load_osc;
+    bool lua_load_ytdl;
+    char *lua_ytdl_format;
+    char **lua_ytdl_raw_options;
+    bool lua_load_stats;
+    bool lua_load_console;
+    int lua_load_auto_profiles;
+
+    bool auto_load_scripts;
+
+    bool audio_exclusive;
+    bool ao_null_fallback;
+    bool audio_stream_silence;
+    float audio_wait_open;
+    int force_vo;
+    float softvol_volume;
+    int rgain_mode;
+    float rgain_preamp;         // Set replaygain pre-amplification
+    bool rgain_clip;             // Enable/disable clipping prevention
+    float rgain_fallback;
+    int softvol_mute;
+    float softvol_max;
+    int gapless_audio;
+
+    mp_vo_opts *vo;
+    struct ao_opts *ao_opts;
+
+    char *wintitle;
+    char *media_title;
+
+    struct mp_csp_equalizer_opts *video_equalizer;
+
+    int stop_screensaver;
+    int cursor_autohide_delay;
+    bool cursor_autohide_fs;
+
+    struct mp_subtitle_opts *subs_rend;
+    struct mp_sub_filter_opts *subs_filt;
+    struct mp_osd_render_opts *osd_rend;
+
+    int osd_level;
+    int osd_duration;
+    bool osd_fractions;
+    int osd_on_seek;
+    bool video_osd;
+
+    bool untimed;
+    char *stream_dump;
+    bool stop_playback_on_init_failure;
+    int loop_times;
+    int loop_file;
+    bool shuffle;
+    bool ordered_chapters;
+    char *ordered_chapters_files;
+    int chapter_merge_threshold;
+    double chapter_seek_threshold;
+    char *chapter_file;
+    bool merge_files;
+    bool quiet;
+    bool load_config;
+    char *force_configdir;
+    bool use_filedir_conf;
+    int hls_bitrate;
+    int edition_id;
+    bool initial_audio_sync;
+    double sync_max_video_change;
+    double sync_max_audio_change;
+    int sync_max_factor;
+    int hr_seek;
+    float hr_seek_demuxer_offset;
+    bool hr_seek_framedrop;
+    float audio_delay;
+    float default_max_pts_correction;
+    int autosync;
+    int frame_dropping;
+    bool video_latency_hacks;
+    int term_osd;
+    bool term_osd_bar;
+    char *term_osd_bar_chars;
+    bool term_remaining_playtime;
+    char *term_title;
+    char *playing_msg;
+    char *osd_playing_msg;
+    int osd_playing_msg_duration;
+    char *status_msg;
+    char *osd_status_msg;
+    char *osd_msg[3];
+    int player_idle_mode;
+    bool consolecontrols;
+    int playlist_pos;
+    struct m_rel_time play_start;
+    struct m_rel_time play_end;
+    struct m_rel_time play_length;
+    int play_dir;
+    bool rebase_start_time;
+    int play_frames;
+    double ab_loop[2];
+    int ab_loop_count;
+    double step_sec;
+    bool position_resume;
+    bool position_check_mtime;
+    bool position_save_on_quit;
+    bool write_filename_in_watch_later_config;
+    bool ignore_path_in_watch_later_config;
+    char *watch_later_dir;
+    char **watch_later_options;
+    bool pause;
+    int keep_open;
+    bool keep_open_pause;
+    double image_display_duration;
+    char *lavfi_complex;
+    int stream_id[2][STREAM_TYPE_COUNT];
+    char **stream_lang[STREAM_TYPE_COUNT];
+    bool stream_auto_sel;
+    bool subs_with_matching_audio;
+    bool subs_match_os_language;
+    int subs_fallback;
+    int subs_fallback_forced;
+    int audio_display;
+    char **display_tags;
+
+    char **audio_files;
+    char *demuxer_name;
+    bool demuxer_thread;
+    double demux_termination_timeout;
+    bool demuxer_cache_wait;
+    bool prefetch_open;
+    char *audio_demuxer_name;
+    char *sub_demuxer_name;
+
+    bool cache_pause;
+    bool cache_pause_initial;
+    float cache_pause_wait;
+
+    struct image_writer_opts *screenshot_image_opts;
+    char *screenshot_template;
+    char *screenshot_dir;
+    bool screenshot_sw;
+
+    struct m_channels audio_output_channels;
+    int audio_output_format;
+    int force_srate;
+    double playback_speed;
+    bool pitch_correction;
+    struct m_obj_settings *vf_settings;
+    struct m_obj_settings *af_settings;
+    struct filter_opts *filter_opts;
+    struct dec_wrapper_opts *dec_wrapper;
+    char **sub_name;
+    char **sub_paths;
+    char **audiofile_paths;
+    char **coverart_files;
+    char **external_files;
+    bool autoload_files;
+    int sub_auto;
+    char **sub_auto_exts;
+    int audiofile_auto;
+    char **audiofile_auto_exts;
+    int coverart_auto;
+    char **coverart_auto_exts;
+    bool coverart_whitelist;
+    bool osd_bar_visible;
+
+    int w32_priority;
+
+    struct bluray_opts *stream_bluray_opts;
+    struct cdda_opts *stream_cdda_opts;
+    struct dvb_opts *stream_dvb_opts;
+    struct lavf_opts *stream_lavf_opts;
+
+    char *bluray_device;
+
+    struct demux_rawaudio_opts *demux_rawaudio;
+    struct demux_rawvideo_opts *demux_rawvideo;
+    struct demux_playlist_opts *demux_playlist;
+    struct demux_lavf_opts *demux_lavf;
+    struct demux_mkv_opts *demux_mkv;
+    struct demux_cue_opts *demux_cue;
+
+    struct demux_opts *demux_opts;
+    struct demux_cache_opts *demux_cache_opts;
+    struct stream_opts *stream_opts;
+
+    struct vd_lavc_params *vd_lavc_params;
+    struct ad_lavc_params *ad_lavc_params;
+
+    struct input_opts *input_opts;
+
+    // may be NULL if encoding is not compiled-in
+    struct encode_opts *encode_opts;
+
+    char *ipc_path;
+    char *ipc_client;
+
+    struct mp_resample_opts *resample_opts;
+
+    struct ra_ctx_opts *ra_ctx_opts;
+    struct gl_video_opts *gl_video_opts;
+    struct angle_opts *angle_opts;
+    struct opengl_opts *opengl_opts;
+    struct vulkan_opts *vulkan_opts;
+    struct vulkan_display_opts *vulkan_display_opts;
+    struct spirv_opts *spirv_opts;
+    struct d3d11_opts *d3d11_opts;
+    struct d3d11va_opts *d3d11va_opts;
+    struct macos_opts *macos_opts;
+    struct drm_opts *drm_opts;
+    struct wayland_opts *wayland_opts;
+    struct wingl_opts *wingl_opts;
+    struct cuda_opts *cuda_opts;
+    struct dvd_opts *dvd_opts;
+    struct vaapi_opts *vaapi_opts;
+    struct sws_opts *sws_opts;
+    struct zimg_opts *zimg_opts;
+
+    int cuda_device;
+} MPOpts;
+
+struct cuda_opts {
+    int cuda_device;
+};
+
+struct dvd_opts {
+    int angle;
+    int speed;
+    char *device;
+};
+
+struct filter_opts {
+    bool deinterlace;
+};
+
+extern const struct m_sub_options vo_sub_opts;
+extern const struct m_sub_options cuda_conf;
+extern const struct m_sub_options dvd_conf;
+extern const struct m_sub_options mp_subtitle_sub_opts;
+extern const struct m_sub_options mp_sub_filter_opts;
+extern const struct m_sub_options mp_osd_render_sub_opts;
+extern const struct m_sub_options filter_conf;
+extern const struct m_sub_options resample_conf;
+extern const struct m_sub_options stream_conf;
+extern const struct m_sub_options dec_wrapper_conf;
+extern const struct m_sub_options mp_opt_root;
+
+#endif
diff --git a/options/parse_commandline.c b/options/parse_commandline.c
new file mode 100644
index 0000000..93120d3
--- /dev/null
+++ b/options/parse_commandline.c
@@ -0,0 +1,261 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "osdep/io.h"
+#include "common/global.h"
+#include "common/msg.h"
+#include "common/msg_control.h"
+#include "m_option.h"
+#include "m_config_frontend.h"
+#include "options.h"
+#include "common/playlist.h"
+#include "parse_commandline.h"
+
+#define GLOBAL 0
+#define LOCAL 1
+
+struct parse_state {
+    struct m_config *config;
+    char **argv;
+    struct mp_log *log; // silent if NULL
+
+    bool no_more_opts;
+    bool error;
+
+    bool is_opt;
+    struct bstr arg;
+    struct bstr param;
+};
+
+// Returns true if more args, false if all parsed or an error occurred.
+static bool split_opt(struct parse_state *p)
+{
+    assert(!p->error);
+
+    if (!p->argv || !p->argv[0])
+        return false;
+
+    p->is_opt = false;
+    p->arg = bstr0(p->argv[0]);
+    p->param = bstr0(NULL);
+
+    p->argv++;
+
+    if (p->no_more_opts || !bstr_startswith0(p->arg, "-") || p->arg.len == 1)
+        return true;
+
+    if (bstrcmp0(p->arg, "--") == 0) {
+        p->no_more_opts = true;
+        return split_opt(p);
+    }
+
+    p->is_opt = true;
+
+    bool new_opt = bstr_eatstart0(&p->arg, "--");
+    if (!new_opt)
+        bstr_eatstart0(&p->arg, "-");
+
+    bool ambiguous = !bstr_split_tok(p->arg, "=", &p->arg, &p->param);
+
+    bool need_param = m_config_option_requires_param(p->config, p->arg) > 0;
+
+    if (ambiguous && need_param) {
+        if (!p->argv[0] || new_opt) {
+            p->error = true;
+            MP_FATAL(p, "Error parsing commandline option %.*s: %s\n",
+                     BSTR_P(p->arg), m_option_strerror(M_OPT_MISSING_PARAM));
+            MP_WARN(p, "Make sure you're using e.g. '--%.*s=value' instead "
+                    "of '--%.*s value'.\n", BSTR_P(p->arg), BSTR_P(p->arg));
+            return false;
+        }
+        p->param = bstr0(p->argv[0]);
+        p->argv++;
+    }
+
+    return true;
+}
+
+#ifdef __MINGW32__
+static void process_non_option(struct playlist *files, const char *arg)
+{
+    glob_t gg;
+
+    // Glob filenames on Windows (cmd.exe doesn't do this automatically)
+    if (glob(arg, 0, NULL, &gg)) {
+        playlist_add_file(files, arg);
+    } else {
+        for (int i = 0; i < gg.gl_pathc; i++)
+            playlist_add_file(files, gg.gl_pathv[i]);
+
+        globfree(&gg);
+    }
+}
+#else
+static void process_non_option(struct playlist *files, const char *arg)
+{
+    playlist_add_file(files, arg);
+}
+#endif
+
+// returns M_OPT_... error code
+int m_config_parse_mp_command_line(m_config_t *config, struct playlist *files,
+                                   struct mpv_global *global, char **argv)
+{
+    int ret = M_OPT_UNKNOWN;
+    int mode = 0;
+    struct playlist_entry *local_start = NULL;
+
+    int local_params_count = 0;
+    struct playlist_param *local_params = 0;
+
+    assert(config != NULL);
+
+    mode = GLOBAL;
+
+    struct parse_state p = {config, argv, config->log};
+    while (split_opt(&p)) {
+        if (p.is_opt) {
+            int flags = M_SETOPT_FROM_CMDLINE;
+            if (mode == LOCAL)
+                flags |= M_SETOPT_BACKUP | M_SETOPT_CHECK_ONLY;
+            int r = m_config_set_option_cli(config, p.arg, p.param, flags);
+            if (r == M_OPT_EXIT) {
+                ret = r;
+                goto err_out;
+            } else if (r < 0) {
+                MP_FATAL(config, "Setting commandline option --%.*s=%.*s failed.\n",
+                         BSTR_P(p.arg), BSTR_P(p.param));
+                goto err_out;
+            }
+
+            // Handle some special arguments outside option parser.
+
+            if (!bstrcmp0(p.arg, "{")) {
+                if (mode != GLOBAL) {
+                    MP_ERR(config, "'--{' can not be nested.\n");
+                    goto err_out;
+                }
+                mode = LOCAL;
+                assert(!local_start);
+                local_start = playlist_get_last(files);
+                continue;
+            }
+
+            if (!bstrcmp0(p.arg, "}")) {
+                if (mode != LOCAL) {
+                    MP_ERR(config, "Too many closing '--}'.\n");
+                    goto err_out;
+                }
+                if (local_params_count) {
+                    // The files added between '{' and '}' are the entries from
+                    // the entry _after_ local_start, until the end of the list.
+                    // If local_start is NULL, the list was empty on '{', and we
+                    // want all files in the list.
+                    struct playlist_entry *cur = local_start
+                        ? playlist_entry_get_rel(local_start, 1)
+                        : playlist_get_first(files);
+                    if (!cur)
+                        MP_WARN(config, "Ignored options!\n");
+                    while (cur) {
+                        playlist_entry_add_params(cur, local_params,
+                                                local_params_count);
+                        cur = playlist_entry_get_rel(cur, 1);
+                    }
+                }
+                local_params_count = 0;
+                mode = GLOBAL;
+                m_config_restore_backups(config);
+                local_start = NULL;
+                continue;
+            }
+
+            if (bstrcmp0(p.arg, "playlist") == 0) {
+                // append the playlist to the local args
+                char *param0 = bstrdup0(NULL, p.param);
+                struct playlist *pl = playlist_parse_file(param0, NULL, global);
+                if (!pl) {
+                    MP_FATAL(config, "Error reading playlist '%.*s'\n",
+                             BSTR_P(p.param));
+                    talloc_free(param0);
+                    goto err_out;
+                }
+                playlist_transfer_entries(files, pl);
+                playlist_populate_playlist_path(files, param0);
+                talloc_free(param0);
+                talloc_free(pl);
+                continue;
+            }
+
+            if (mode == LOCAL) {
+                MP_TARRAY_APPEND(NULL, local_params, local_params_count,
+                                 (struct playlist_param) {p.arg, p.param});
+            }
+        } else {
+            // filename
+            void *tmp = talloc_new(NULL);
+            char *file0 = bstrdup0(tmp, p.arg);
+            process_non_option(files, file0);
+            talloc_free(tmp);
+        }
+    }
+
+    if (p.error)
+        goto err_out;
+
+    if (mode != GLOBAL) {
+        MP_ERR(config, "Missing closing --} on command line.\n");
+        goto err_out;
+    }
+
+    ret = 0; // success
+
+err_out:
+    talloc_free(local_params);
+    m_config_restore_backups(config);
+    return ret;
+}
+
+/* Parse some command line options early before main parsing.
+ * --no-config prevents reading configuration files (otherwise done before
+ * command line parsing), and --really-quiet suppresses messages printed
+ * during normal options parsing.
+ */
+void m_config_preparse_command_line(m_config_t *config, struct mpv_global *global,
+                                    int *verbose, char **argv)
+{
+    struct parse_state p = {config, argv, mp_null_log};
+    while (split_opt(&p)) {
+        if (p.is_opt) {
+            // Ignore non-pre-parse options. They will be set later.
+            // Option parsing errors will be handled later as well.
+            int flags = M_SETOPT_FROM_CMDLINE | M_SETOPT_PRE_PARSE_ONLY;
+            m_config_set_option_cli(config, p.arg, p.param, flags);
+            if (bstrcmp0(p.arg, "v") == 0)
+                (*verbose)++;
+        }
+    }
+
+    for (int n = 0; n < config->num_opts; n++)
+        config->opts[n].warning_was_printed = false;
+}
diff --git a/options/parse_commandline.h b/options/parse_commandline.h
new file mode 100644
index 0000000..1509fc9
--- /dev/null
+++ b/options/parse_commandline.h
@@ -0,0 +1,32 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_PARSER_MPCMD_H
+#define MPLAYER_PARSER_MPCMD_H
+
+#include <stdbool.h>
+
+struct playlist;
+struct m_config;
+struct mpv_global;
+
+int m_config_parse_mp_command_line(m_config_t *config, struct playlist *files,
+                                   struct mpv_global *global, char **argv);
+void m_config_preparse_command_line(m_config_t *config, struct mpv_global *global,
+                                    int *verbose, char **argv);
+
+#endif /* MPLAYER_PARSER_MPCMD_H */
diff --git a/options/parse_configfile.c b/options/parse_configfile.c
new file mode 100644
index 0000000..edd6be9
--- /dev/null
+++ b/options/parse_configfile.c
@@ -0,0 +1,178 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "osdep/io.h"
+
+#include "parse_configfile.h"
+#include "common/common.h"
+#include "common/msg.h"
+#include "misc/ctype.h"
+#include "m_option.h"
+#include "m_config.h"
+#include "stream/stream.h"
+
+// Skip whitespace and comments (assuming there are no line breaks)
+static bool skip_ws(bstr *s)
+{
+    *s = bstr_lstrip(*s);
+    if (bstr_startswith0(*s, "#"))
+        s->len = 0;
+    return s->len;
+}
+
+int m_config_parse(m_config_t *config, const char *location, bstr data,
+                   char *initial_section, int flags)
+{
+    m_profile_t *profile = m_config_add_profile(config, initial_section);
+    void *tmp = talloc_new(NULL);
+    int line_no = 0;
+    int errors = 0;
+
+    bstr_eatstart0(&data, "\xEF\xBB\xBF"); // skip BOM
+
+    while (data.len) {
+        talloc_free_children(tmp);
+        bool ok = false;
+
+        line_no++;
+        char loc[512];
+        snprintf(loc, sizeof(loc), "%s:%d:", location, line_no);
+
+        bstr line = bstr_strip_linebreaks(bstr_getline(data, &data));
+        if (!skip_ws(&line))
+            continue;
+
+        // Profile declaration
+        if (bstr_eatstart0(&line, "[")) {
+            bstr profilename;
+            if (!bstr_split_tok(line, "]", &profilename, &line)) {
+                MP_ERR(config, "%s missing closing ]\n", loc);
+                goto error;
+            }
+            if (skip_ws(&line)) {
+                MP_ERR(config, "%s unparsable extra characters: '%.*s'\n",
+                       loc, BSTR_P(line));
+                goto error;
+            }
+            profile = m_config_add_profile(config, bstrto0(tmp, profilename));
+            continue;
+        }
+
+        bstr_eatstart0(&line, "--");
+
+        bstr option = line;
+        while (line.len && (mp_isalnum(line.start[0]) || line.start[0] == '_' ||
+                            line.start[0] == '-'))
+            line = bstr_cut(line, 1);
+        option.len = option.len - line.len;
+        skip_ws(&line);
+
+        bstr value = {0};
+        if (bstr_eatstart0(&line, "=")) {
+            skip_ws(&line);
+            if (line.len && (line.start[0] == '"' || line.start[0] == '\'')) {
+                // Simple quoting, like "value"
+                char term[2] = {line.start[0], 0};
+                line = bstr_cut(line, 1);
+                if (!bstr_split_tok(line, term, &value, &line)) {
+                    MP_ERR(config, "%s unterminated quote\n", loc);
+                    goto error;
+                }
+            } else if (bstr_eatstart0(&line, "%")) {
+                // Quoting with length, like %5%value
+                bstr rest;
+                long long len = bstrtoll(line, &rest, 10);
+                if (rest.len == line.len || !bstr_eatstart0(&rest, "%") ||
+                    len > rest.len)
+                {
+                    MP_ERR(config, "%s fixed-length quoting expected - put "
+                           "\"quotes\" around the option value if you did not "
+                           "intend to use this, but your option value starts "
+                           "with '%%'\n", loc);
+                    goto error;
+                }
+                value = bstr_splice(rest, 0, len);
+                line = bstr_cut(rest, len);
+            } else {
+                // No quoting; take everything until the comment or end of line
+                int end = bstrchr(line, '#');
+                value = bstr_strip(end < 0 ? line : bstr_splice(line, 0, end));
+                line.len = 0;
+            }
+        }
+        if (skip_ws(&line)) {
+            MP_ERR(config, "%s unparsable extra characters: '%.*s'\n",
+                   loc, BSTR_P(line));
+            goto error;
+        }
+
+        int res = m_config_set_profile_option(config, profile, option, value);
+        if (res < 0) {
+            MP_ERR(config, "%s setting option %.*s='%.*s' failed.\n",
+                   loc, BSTR_P(option), BSTR_P(value));
+            goto error;
+        }
+
+        ok = true;
+    error:
+        if (!ok)
+            errors++;
+        if (errors > 16) {
+            MP_ERR(config, "%s: too many errors, stopping.\n", location);
+            break;
+        }
+    }
+
+    if (config->recursion_depth == 0)
+        m_config_finish_default_profile(config, flags);
+
+    talloc_free(tmp);
+    return 1;
+}
+
+// Load options and profiles from a config file.
+//  conffile: path to the config file
+//  initial_section: default section where to add normal options
+//  flags: M_SETOPT_* bits
+//  returns: 1 on success, -1 on error, 0 if file not accessible.
+int m_config_parse_config_file(m_config_t *config, struct mpv_global *global,
+                               const char *conffile, char *initial_section,
+                               int flags)
+{
+    flags = flags | M_SETOPT_FROM_CONFIG_FILE;
+
+    MP_VERBOSE(config, "Reading config file %s\n", conffile);
+
+    struct stream *s = stream_create(conffile, STREAM_READ | STREAM_ORIGIN_DIRECT,
+                                     NULL, global);
+    if (!s)
+        return 0;
+    bstr data = stream_read_complete(s, s, 1000000000);
+    if (!data.start)
+        return 0;
+
+    int r = m_config_parse(config, conffile, data, initial_section, flags);
+    talloc_free(data.start);
+    free_stream(s);
+    return r;
+}
diff --git a/options/parse_configfile.h b/options/parse_configfile.h
new file mode 100644
index 0000000..3622fc8
--- /dev/null
+++ b/options/parse_configfile.h
@@ -0,0 +1,30 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_PARSER_CFG_H
+#define MPLAYER_PARSER_CFG_H
+
+#include "m_config_frontend.h"
+
+int m_config_parse_config_file(m_config_t* config, struct mpv_global *global,
+                               const char *conffile, char *initial_section,
+                               int flags);
+
+int m_config_parse(m_config_t *config, const char *location, bstr data,
+                   char *initial_section, int flags);
+
+#endif /* MPLAYER_PARSER_CFG_H */
diff --git a/options/path.c b/options/path.c
new file mode 100644
index 0000000..52dc113
--- /dev/null
+++ b/options/path.c
@@ -0,0 +1,410 @@
+/*
+ * This file is part of mpv.
+ *
+ * Get path to config dir/file.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "config.h"
+
+#include "common/common.h"
+#include "common/global.h"
+#include "common/msg.h"
+#include "options/options.h"
+#include "options/path.h"
+#include "mpv_talloc.h"
+#include "osdep/io.h"
+#include "osdep/path.h"
+#include "misc/ctype.h"
+
+// In order of decreasing priority: the first has highest priority.
+static const mp_get_platform_path_cb path_resolvers[] = {
+#if HAVE_COCOA
+    mp_get_platform_path_osx,
+#endif
+#if HAVE_DARWIN
+    mp_get_platform_path_darwin,
+#elif !defined(_WIN32) || defined(__CYGWIN__)
+    mp_get_platform_path_unix,
+#endif
+#if HAVE_UWP
+    mp_get_platform_path_uwp,
+#elif defined(_WIN32)
+    mp_get_platform_path_win,
+#endif
+};
+
+// from highest (most preferred) to lowest priority
+static const char *const config_dirs[] = {
+    "home",
+    "old_home",
+    "osxbundle",
+    "exe_dir",
+    "global",
+};
+
+// Return a platform specific path using a path type as defined in osdep/path.h.
+// Keep in mind that the only way to free the return value is freeing talloc_ctx
+// (or its children), as this function can return a statically allocated string.
+static const char *mp_get_platform_path(void *talloc_ctx,
+                                        struct mpv_global *global,
+                                        const char *type)
+{
+    assert(talloc_ctx);
+
+    if (global->configdir) {
+        // force all others to NULL, only first returns the path
+        for (int n = 0; n < MP_ARRAY_SIZE(config_dirs); n++) {
+            if (strcmp(config_dirs[n], type) == 0)
+                return (n == 0 && global->configdir[0]) ? global->configdir : NULL;
+        }
+    }
+
+    // Return the native config path if the platform doesn't support the
+    // type we are trying to fetch.
+    const char *fallback_type = NULL;
+    if (!strcmp(type, "cache") || !strcmp(type, "state"))
+        fallback_type = "home";
+
+    for (int n = 0; n < MP_ARRAY_SIZE(path_resolvers); n++) {
+        const char *path = path_resolvers[n](talloc_ctx, type);
+        if (path && path[0])
+            return path;
+    }
+
+    if (fallback_type) {
+        assert(strcmp(fallback_type, type) != 0);
+        return mp_get_platform_path(talloc_ctx, global, fallback_type);
+    }
+    return NULL;
+}
+
+void mp_init_paths(struct mpv_global *global, struct MPOpts *opts)
+{
+    TA_FREEP(&global->configdir);
+
+    const char *force_configdir = getenv("MPV_HOME");
+    if (opts->force_configdir && opts->force_configdir[0])
+        force_configdir = opts->force_configdir;
+    if (!opts->load_config)
+        force_configdir = "";
+
+    global->configdir = talloc_strdup(global, force_configdir);
+}
+
+char *mp_find_user_file(void *talloc_ctx, struct mpv_global *global,
+                        const char *type, const char *filename)
+{
+    void *tmp = talloc_new(NULL);
+    char *res = (char *)mp_get_platform_path(tmp, global, type);
+    if (res)
+        res = mp_path_join(talloc_ctx, res, filename);
+    talloc_free(tmp);
+    MP_DBG(global, "%s path: '%s' -> '%s'\n", type, filename, res ? res : "-");
+    return res;
+}
+
+static char **mp_find_all_config_files_limited(void *talloc_ctx,
+                                               struct mpv_global *global,
+                                               int max_files,
+                                               const char *filename)
+{
+    char **ret = talloc_array(talloc_ctx, char*, 2); // 2 preallocated
+    int num_ret = 0;
+
+    for (int i = 0; i < MP_ARRAY_SIZE(config_dirs); i++) {
+        const char *dir = mp_get_platform_path(ret, global, config_dirs[i]);
+        bstr s = bstr0(filename);
+        while (dir && num_ret < max_files && s.len) {
+            bstr fn;
+            bstr_split_tok(s, "|", &fn, &s);
+
+            char *file = mp_path_join_bstr(ret, bstr0(dir), fn);
+            if (mp_path_exists(file)) {
+                MP_DBG(global, "config path: '%.*s' -> '%s'\n",
+                        BSTR_P(fn), file);
+                MP_TARRAY_APPEND(NULL, ret, num_ret, file);
+            } else {
+                MP_DBG(global, "config path: '%.*s' -/-> '%s'\n",
+                        BSTR_P(fn), file);
+            }
+        }
+    }
+
+    MP_TARRAY_GROW(NULL, ret, num_ret);
+    ret[num_ret] = NULL;
+
+    for (int n = 0; n < num_ret / 2; n++)
+        MPSWAP(char*, ret[n], ret[num_ret - n - 1]);
+    return ret;
+}
+
+char **mp_find_all_config_files(void *talloc_ctx, struct mpv_global *global,
+                                const char *filename)
+{
+    return mp_find_all_config_files_limited(talloc_ctx, global, 64, filename);
+}
+
+char *mp_find_config_file(void *talloc_ctx, struct mpv_global *global,
+                          const char *filename)
+{
+    char **l = mp_find_all_config_files_limited(talloc_ctx, global, 1, filename);
+    char *r = l && l[0] ? talloc_steal(talloc_ctx, l[0]) : NULL;
+    talloc_free(l);
+    return r;
+}
+
+char *mp_get_user_path(void *talloc_ctx, struct mpv_global *global,
+                       const char *path)
+{
+    if (!path)
+        return NULL;
+    char *res = NULL;
+    bstr bpath = bstr0(path);
+    if (bstr_eatstart0(&bpath, "~")) {
+        // parse to "~" <prefix> "/" <rest>
+        bstr prefix, rest;
+        if (bstr_split_tok(bpath, "/", &prefix, &rest)) {
+            const char *rest0 = rest.start; // ok in this case
+            if (bstr_equals0(prefix, "~")) {
+                res = mp_find_config_file(talloc_ctx, global, rest0);
+                if (!res) {
+                    void *tmp = talloc_new(NULL);
+                    const char *p = mp_get_platform_path(tmp, global, "home");
+                    res = mp_path_join_bstr(talloc_ctx, bstr0(p), rest);
+                    talloc_free(tmp);
+                }
+            } else if (bstr_equals0(prefix, "")) {
+                char *home = getenv("HOME");
+                if (!home)
+                    home = getenv("USERPROFILE");
+                res = mp_path_join_bstr(talloc_ctx, bstr0(home), rest);
+            } else if (bstr_eatstart0(&prefix, "~")) {
+                void *tmp = talloc_new(NULL);
+                char type[80];
+                snprintf(type, sizeof(type), "%.*s", BSTR_P(prefix));
+                const char *p = mp_get_platform_path(tmp, global, type);
+                res = mp_path_join_bstr(talloc_ctx, bstr0(p), rest);
+                talloc_free(tmp);
+            }
+        }
+    }
+    if (!res)
+        res = talloc_strdup(talloc_ctx, path);
+    MP_DBG(global, "user path: '%s' -> '%s'\n", path, res);
+    return res;
+}
+
+char *mp_basename(const char *path)
+{
+    char *s;
+
+#if HAVE_DOS_PATHS
+    if (!mp_is_url(bstr0(path))) {
+        s = strrchr(path, '\\');
+        if (s)
+            path = s + 1;
+        s = strrchr(path, ':');
+        if (s)
+            path = s + 1;
+    }
+#endif
+    s = strrchr(path, '/');
+    return s ? s + 1 : (char *)path;
+}
+
+struct bstr mp_dirname(const char *path)
+{
+    struct bstr ret = {
+        (uint8_t *)path, mp_basename(path) - path
+    };
+    if (ret.len == 0)
+        return bstr0(".");
+    return ret;
+}
+
+
+#if HAVE_DOS_PATHS
+static const char mp_path_separators[] = "\\/";
+#else
+static const char mp_path_separators[] = "/";
+#endif
+
+// Mutates path and removes a trailing '/' (or '\' on Windows)
+void mp_path_strip_trailing_separator(char *path)
+{
+    size_t len = strlen(path);
+    if (len > 0 && strchr(mp_path_separators, path[len - 1]))
+        path[len - 1] = '\0';
+}
+
+char *mp_splitext(const char *path, bstr *root)
+{
+    assert(path);
+    int skip = (*path == '.'); // skip leading dot for "hidden" unix files
+    const char *split = strrchr(path + skip, '.');
+    if (!split || !split[1] || strchr(split, '/'))
+        return NULL;
+    if (root)
+        *root = (bstr){(char *)path, split - path};
+    return (char *)split + 1;
+}
+
+bool mp_path_is_absolute(struct bstr path)
+{
+    if (path.len && strchr(mp_path_separators, path.start[0]))
+        return true;
+
+#if HAVE_DOS_PATHS
+    // Note: "X:filename" is a path relative to the current working directory
+    //       of drive X, and thus is not an absolute path. It needs to be
+    //       followed by \ or /.
+    if (path.len >= 3 && path.start[1] == ':' &&
+        strchr(mp_path_separators, path.start[2]))
+        return true;
+#endif
+
+    return false;
+}
+
+char *mp_path_join_bstr(void *talloc_ctx, struct bstr p1, struct bstr p2)
+{
+    if (p1.len == 0)
+        return bstrdup0(talloc_ctx, p2);
+    if (p2.len == 0)
+        return bstrdup0(talloc_ctx, p1);
+
+    if (mp_path_is_absolute(p2))
+        return bstrdup0(talloc_ctx, p2);
+
+    bool have_separator = strchr(mp_path_separators, p1.start[p1.len - 1]);
+#if HAVE_DOS_PATHS
+    // "X:" only => path relative to "X:" current working directory.
+    if (p1.len == 2 && p1.start[1] == ':')
+        have_separator = true;
+#endif
+
+    return talloc_asprintf(talloc_ctx, "%.*s%s%.*s", BSTR_P(p1),
+                           have_separator ? "" : "/", BSTR_P(p2));
+}
+
+char *mp_path_join(void *talloc_ctx, const char *p1, const char *p2)
+{
+    return mp_path_join_bstr(talloc_ctx, bstr0(p1), bstr0(p2));
+}
+
+char *mp_getcwd(void *talloc_ctx)
+{
+    char *e_wd = getenv("PWD");
+    if (e_wd)
+        return talloc_strdup(talloc_ctx, e_wd);
+
+    char *wd = talloc_array(talloc_ctx, char, 20);
+    while (getcwd(wd, talloc_get_size(wd)) == NULL) {
+        if (errno != ERANGE) {
+            talloc_free(wd);
+            return NULL;
+        }
+        wd = talloc_realloc(talloc_ctx, wd, char, talloc_get_size(wd) * 2);
+    }
+    return wd;
+}
+
+char *mp_normalize_path(void *talloc_ctx, const char *path)
+{
+    if (mp_is_url(bstr0(path)))
+        return talloc_strdup(talloc_ctx, path);
+
+    return mp_path_join(talloc_ctx, mp_getcwd(talloc_ctx), path);
+}
+
+bool mp_path_exists(const char *path)
+{
+    struct stat st;
+    return path && stat(path, &st) == 0;
+}
+
+bool mp_path_isdir(const char *path)
+{
+    struct stat st;
+    return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
+}
+
+// Return false if it's considered a normal local filesystem path.
+bool mp_is_url(bstr path)
+{
+    int proto = bstr_find0(path, "://");
+    if (proto < 1)
+        return false;
+    // Per RFC3986, the first character of the protocol must be alphabetic.
+    // The rest must be alphanumeric plus -, + and .
+    for (int i = 0; i < proto; i++) {
+        unsigned char c = path.start[i];
+        if ((i == 0 && !mp_isalpha(c)) ||
+            (!mp_isalnum(c) && c != '.' && c != '-' && c != '+'))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Return the protocol part of path, e.g. "http" if path is "http://...".
+// On success, out_url (if not NULL) is set to the part after the "://".
+bstr mp_split_proto(bstr path, bstr *out_url)
+{
+    if (!mp_is_url(path))
+        return (bstr){0};
+    bstr r;
+    bstr_split_tok(path, "://", &r, out_url ? out_url : &(bstr){0});
+    return r;
+}
+
+void mp_mkdirp(const char *dir)
+{
+    char *path = talloc_strdup(NULL, dir);
+    char *cdir = path + 1;
+
+    while (cdir) {
+        cdir = strchr(cdir, '/');
+        if (cdir)
+            *cdir = 0;
+
+        mkdir(path, 0700);
+
+        if (cdir)
+            *cdir++ = '/';
+    }
+
+    talloc_free(path);
+}
+
+void mp_mk_user_dir(struct mpv_global *global, const char *type, char *subdir)
+{
+    char *dir = mp_find_user_file(NULL, global, type, subdir);
+    if (dir)
+        mp_mkdirp(dir);
+    talloc_free(dir);
+}
diff --git a/options/path.h b/options/path.h
new file mode 100644
index 0000000..7ec8f7b
--- /dev/null
+++ b/options/path.h
@@ -0,0 +1,98 @@
+/*
+ * Get path to config dir/file.
+ *
+ * This file is part of mpv.
+ *
+ * mpv 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.
+ *
+ * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_PATH_H
+#define MPLAYER_PATH_H
+
+#include <stdbool.h>
+#include "misc/bstr.h"
+
+struct mpv_global;
+struct MPOpts;
+
+void mp_init_paths(struct mpv_global *global, struct MPOpts *opts);
+
+// Search for the input filename in several paths. These include user and global
+// config locations by default. Some platforms may implement additional platform
+// related lookups (i.e.: OSX inside an application bundle).
+char *mp_find_config_file(void *talloc_ctx, struct mpv_global *global,
+                          const char *filename);
+
+// Search for local writable user files within a specific kind of user dir
+// as documented in osdep/path.h. This returns a result even if the file does
+// not exist. Calling it with filename="" is equivalent to retrieving the path
+// to the dir.
+char *mp_find_user_file(void *talloc_ctx, struct mpv_global *global,
+                        const char *type, const char *filename);
+
+// Find all instances of the given config file. Paths are returned in order
+// from lowest to highest priority. filename can contain multiple names
+// separated with '|', with the first having highest priority.
+char **mp_find_all_config_files(void *talloc_ctx, struct mpv_global *global,
+                                const char *filename);
+
+// Normally returns a talloc_strdup'ed copy of the path, except for special
+// paths starting with '~'. Used to allow the user explicitly reference a
+// file from the user's home or mpv config directory.
+char *mp_get_user_path(void *talloc_ctx, struct mpv_global *global,
+                       const char *path);
+
+// Return pointer to filename part of path
+
+char *mp_basename(const char *path);
+
+/* Return file extension, excluding the '.'. If root is not NULL, set it to the
+ * part of the path without extension. So: path == root + "." + extension
+ * Don't consider it a file extension if the only '.' is the first character.
+ * Return NULL if no extension and don't set *root in this case.
+ */
+char *mp_splitext(const char *path, bstr *root);
+
+/* Return struct bstr referencing directory part of path, or if that
+ * would be empty, ".".
+ */
+struct bstr mp_dirname(const char *path);
+
+void mp_path_strip_trailing_separator(char *path);
+
+/* Join two path components and return a newly allocated string
+ * for the result. '/' is inserted between the components if needed.
+ * If p2 is an absolute path then the value of p1 is ignored.
+ */
+char *mp_path_join(void *talloc_ctx, const char *p1, const char *p2);
+char *mp_path_join_bstr(void *talloc_ctx, struct bstr p1, struct bstr p2);
+
+// Return whether the path is absolute.
+bool mp_path_is_absolute(struct bstr path);
+
+char *mp_getcwd(void *talloc_ctx);
+
+char *mp_normalize_path(void *talloc_ctx, const char *path);
+
+bool mp_path_exists(const char *path);
+bool mp_path_isdir(const char *path);
+
+bool mp_is_url(bstr path);
+
+bstr mp_split_proto(bstr path, bstr *out_url);
+
+void mp_mkdirp(const char *dir);
+void mp_mk_user_dir(struct mpv_global *global, const char *type, char *subdir);
+
+#endif /* MPLAYER_PATH_H */