Adding upstream version 0.37.0.upstream/0.37.0

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

1 files changed, 7149 insertions, 0 deletions

diff --git a/player/command.c b/player/command.c
new file mode 100644
index 0000000..8bff0cd
--- /dev/null
+++ b/player/command.c
@@ -0,0 +1,7149 @@
+/*
+ * 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 <float.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <time.h>
+#include <math.h>
+#include <sys/types.h>
+
+#include <ass/ass.h>
+#include <libavutil/avstring.h>
+#include <libavutil/common.h>
+
+#include "mpv_talloc.h"
+#include "client.h"
+#include "external_files.h"
+#include "common/av_common.h"
+#include "common/codecs.h"
+#include "common/msg.h"
+#include "common/msg_control.h"
+#include "common/stats.h"
+#include "filters/f_decoder_wrapper.h"
+#include "command.h"
+#include "osdep/threads.h"
+#include "osdep/timer.h"
+#include "common/common.h"
+#include "input/input.h"
+#include "input/keycodes.h"
+#include "stream/stream.h"
+#include "demux/demux.h"
+#include "demux/stheader.h"
+#include "common/playlist.h"
+#include "sub/dec_sub.h"
+#include "sub/osd.h"
+#include "sub/sd.h"
+#include "options/m_option.h"
+#include "options/m_property.h"
+#include "options/m_config_frontend.h"
+#include "osdep/getpid.h"
+#include "video/out/vo.h"
+#include "video/csputils.h"
+#include "video/hwdec.h"
+#include "audio/aframe.h"
+#include "audio/format.h"
+#include "audio/out/ao.h"
+#include "video/out/bitmap_packer.h"
+#include "options/path.h"
+#include "screenshot.h"
+#include "misc/dispatch.h"
+#include "misc/node.h"
+#include "misc/thread_pool.h"
+#include "misc/thread_tools.h"
+
+#include "osdep/io.h"
+#include "osdep/subprocess.h"
+
+#include "core.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+struct command_ctx {
+    // All properties, terminated with a {0} item.
+    struct m_property *properties;
+
+    double last_seek_time;
+    double last_seek_pts;
+    double marked_pts;
+    bool marked_permanent;
+
+    char **warned_deprecated;
+    int num_warned_deprecated;
+
+    struct overlay *overlays;
+    int num_overlays;
+    // One of these is in use by the OSD; the other one exists so that the
+    // bitmap list can be manipulated without additional synchronization.
+    struct sub_bitmaps overlay_osd[2];
+    int overlay_osd_current;
+    struct bitmap_packer *overlay_packer;
+
+    struct hook_handler **hooks;
+    int num_hooks;
+    int64_t hook_seq; // for hook_handler.seq
+
+    struct ao_hotplug *hotplug;
+
+    struct mp_cmd_ctx *cache_dump_cmd; // in progress cache dumping
+
+    char **script_props;
+    mpv_node udata;
+
+    double cached_window_scale;
+    bool shared_script_warning;
+};
+
+static const struct m_option script_props_type = {
+    .type = &m_option_type_keyvalue_list
+};
+
+static const struct m_option udata_type = {
+    .type = CONF_TYPE_NODE
+};
+
+struct overlay {
+    struct mp_image *source;
+    int x, y;
+};
+
+struct hook_handler {
+    char *client;   // client mpv_handle name (for logging)
+    int64_t client_id; // client mpv_handle ID
+    char *type;     // kind of hook, e.g. "on_load"
+    uint64_t user_id; // user-chosen ID
+    int priority;   // priority for global hook order
+    int64_t seq;    // unique ID, != 0, also for fixed order on equal priorities
+    bool active;    // hook is currently in progress (only 1 at a time for now)
+};
+
+// U+279C HEAVY ROUND-TIPPED RIGHTWARDS ARROW
+// U+00A0 NO-BREAK SPACE
+#define ARROW_SP "\342\236\234\302\240"
+
+const char list_current[] = OSD_ASS_0 ARROW_SP OSD_ASS_1;
+const char list_normal[] = OSD_ASS_0 "{\\alpha&HFF}" ARROW_SP "{\\r}" OSD_ASS_1;
+
+static int edit_filters(struct MPContext *mpctx, struct mp_log *log,
+                        enum stream_type mediatype,
+                        const char *cmd, const char *arg);
+static int set_filters(struct MPContext *mpctx, enum stream_type mediatype,
+                       struct m_obj_settings *new_chain);
+
+static bool is_property_set(int action, void *val);
+
+static void hook_remove(struct MPContext *mpctx, struct hook_handler *h)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    for (int n = 0; n < cmd->num_hooks; n++) {
+        if (cmd->hooks[n] == h) {
+            talloc_free(cmd->hooks[n]);
+            MP_TARRAY_REMOVE_AT(cmd->hooks, cmd->num_hooks, n);
+            return;
+        }
+    }
+    MP_ASSERT_UNREACHABLE();
+}
+
+bool mp_hook_test_completion(struct MPContext *mpctx, char *type)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    for (int n = 0; n < cmd->num_hooks; n++) {
+        struct hook_handler *h = cmd->hooks[n];
+        if (h->active && strcmp(h->type, type) == 0) {
+            if (!mp_client_id_exists(mpctx, h->client_id)) {
+                MP_WARN(mpctx, "client removed during hook handling\n");
+                hook_remove(mpctx, h);
+                break;
+            }
+            return false;
+        }
+    }
+    return true;
+}
+
+static int invoke_hook_handler(struct MPContext *mpctx, struct hook_handler *h)
+{
+    MP_VERBOSE(mpctx, "Running hook: %s/%s\n", h->client, h->type);
+    h->active = true;
+
+    uint64_t reply_id = 0;
+    mpv_event_hook *m = talloc_ptrtype(NULL, m);
+    *m = (mpv_event_hook){
+        .name = talloc_strdup(m, h->type),
+        .id = h->seq,
+    },
+    reply_id = h->user_id;
+    char *name = mp_tprintf(22, "@%"PRIi64, h->client_id);
+    int r = mp_client_send_event(mpctx, name, reply_id, MPV_EVENT_HOOK, m);
+    if (r < 0) {
+        MP_WARN(mpctx, "Sending hook command failed. Removing hook.\n");
+        hook_remove(mpctx, h);
+        mp_wakeup_core(mpctx); // repeat next iteration to finish
+    }
+    return r;
+}
+
+static int run_next_hook_handler(struct MPContext *mpctx, char *type, int index)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+
+    for (int n = index; n < cmd->num_hooks; n++) {
+        struct hook_handler *h = cmd->hooks[n];
+        if (strcmp(h->type, type) == 0)
+            return invoke_hook_handler(mpctx, h);
+    }
+
+    mp_wakeup_core(mpctx); // finished hook
+    return 0;
+}
+
+// Start processing script/client API hooks. This is asynchronous, and the
+// caller needs to use mp_hook_test_completion() to check whether they're done.
+void mp_hook_start(struct MPContext *mpctx, char *type)
+{
+    while (run_next_hook_handler(mpctx, type, 0) < 0) {
+        // We can repeat this until all broken clients have been removed, and
+        // hook processing is successfully started.
+    }
+}
+
+int mp_hook_continue(struct MPContext *mpctx, int64_t client_id, uint64_t id)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+
+    for (int n = 0; n < cmd->num_hooks; n++) {
+        struct hook_handler *h = cmd->hooks[n];
+        if (h->client_id == client_id && h->seq == id) {
+            if (!h->active)
+                break;
+            h->active = false;
+            return run_next_hook_handler(mpctx, h->type, n + 1);
+        }
+    }
+
+    MP_ERR(mpctx, "invalid hook API usage\n");
+    return MPV_ERROR_INVALID_PARAMETER;
+}
+
+static int compare_hook(const void *pa, const void *pb)
+{
+    struct hook_handler **h1 = (void *)pa;
+    struct hook_handler **h2 = (void *)pb;
+    if ((*h1)->priority != (*h2)->priority)
+        return (*h1)->priority - (*h2)->priority;
+    return (*h1)->seq - (*h2)->seq;
+}
+
+void mp_hook_add(struct MPContext *mpctx, char *client, int64_t client_id,
+                 const char *name, uint64_t user_id, int pri)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    struct hook_handler *h = talloc_ptrtype(cmd, h);
+    int64_t seq = ++cmd->hook_seq;
+    *h = (struct hook_handler){
+        .client = talloc_strdup(h, client),
+        .client_id = client_id,
+        .type = talloc_strdup(h, name),
+        .user_id = user_id,
+        .priority = pri,
+        .seq = seq,
+    };
+    MP_TARRAY_APPEND(cmd, cmd->hooks, cmd->num_hooks, h);
+    qsort(cmd->hooks, cmd->num_hooks, sizeof(cmd->hooks[0]), compare_hook);
+}
+
+// Call before a seek, in order to allow revert-seek to undo the seek.
+void mark_seek(struct MPContext *mpctx)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    double now = mp_time_sec();
+    if (now > cmd->last_seek_time + 2.0 || cmd->last_seek_pts == MP_NOPTS_VALUE)
+        cmd->last_seek_pts = get_current_time(mpctx);
+    cmd->last_seek_time = now;
+}
+
+static char *skip_n_lines(char *text, int lines)
+{
+    while (text && lines > 0) {
+        char *next = strchr(text, '\n');
+        text = next ? next + 1 : NULL;
+        lines--;
+    }
+    return text;
+}
+
+static int count_lines(char *text)
+{
+    int count = 0;
+    while (text) {
+        char *next = strchr(text, '\n');
+        if (!next || (next[0] == '\n' && !next[1]))
+            break;
+        text = next + 1;
+        count++;
+    }
+    return count;
+}
+
+// Given a huge string separated by new lines, attempts to cut off text above
+// the current line to keep the line visible, and below to keep rendering
+// performance up. pos gives the current line (0 for the first line).
+// "text" might be returned as is, or it can be freed and a new allocation is
+// returned.
+// This is only a heuristic - we can't deal with line breaking.
+static char *cut_osd_list(struct MPContext *mpctx, char *text, int pos)
+{
+    int screen_h, font_h;
+    osd_get_text_size(mpctx->osd, &screen_h, &font_h);
+    int max_lines = screen_h / MPMAX(font_h, 1) - 1;
+
+    if (!text || max_lines < 5)
+        return text;
+
+    int count = count_lines(text);
+    if (count <= max_lines)
+        return text;
+
+    char *new = talloc_strdup(NULL, "");
+
+    int start = MPMAX(pos - max_lines / 2, 0);
+    if (start == 1)
+        start = 0; // avoid weird transition when pad_h becomes visible
+    int pad_h = start > 0;
+
+    int space = max_lines - pad_h - 1;
+    int pad_t = count - start > space;
+    if (!pad_t)
+        start = count - space;
+
+    if (pad_h) {
+        new = talloc_asprintf_append_buffer(new, "\342\206\221 (%d hidden items)\n",
+                                            start);
+    }
+
+    char *head = skip_n_lines(text, start);
+    if (!head) {
+        talloc_free(new);
+        return text;
+    }
+
+    int lines_shown = max_lines - pad_h - pad_t;
+    char *tail = skip_n_lines(head, lines_shown);
+    new = talloc_asprintf_append_buffer(new, "%.*s",
+                            (int)(tail ? tail - head : strlen(head)), head);
+    if (pad_t) {
+        new = talloc_asprintf_append_buffer(new, "\342\206\223 (%d hidden items)\n",
+                                            count - start - lines_shown + 1);
+    }
+
+    talloc_free(text);
+    return new;
+}
+
+static char *format_delay(double time)
+{
+    return talloc_asprintf(NULL, "%d ms", (int)lrint(time * 1000));
+}
+
+// Property-option bridge. (Maps the property to the option with the same name.)
+static int mp_property_generic_option(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct m_config_option *opt =
+        m_config_get_co(mpctx->mconfig, bstr0(prop->name));
+
+    if (!opt)
+        return M_PROPERTY_UNKNOWN;
+
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = *(opt->opt);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET:
+        if (!opt->data)
+            return M_PROPERTY_NOT_IMPLEMENTED;
+        m_option_copy(opt->opt, arg, opt->data);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_SET:
+        if (m_config_set_option_raw(mpctx->mconfig, opt, arg, 0) < 0)
+            return M_PROPERTY_ERROR;
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+/// Playback speed (RW)
+static int mp_property_playback_speed(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_PRINT) {
+        double speed = mpctx->opts->playback_speed;
+        *(char **)arg = talloc_asprintf(NULL, "%.2f", speed);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_av_speed_correction(void *ctx, struct m_property *prop,
+                                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    char *type = prop->priv;
+    double val = 0;
+    switch (type[0]) {
+    case 'a': val = mpctx->speed_factor_a; break;
+    case 'v': val = mpctx->speed_factor_v; break;
+    default: MP_ASSERT_UNREACHABLE();
+    }
+
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg = talloc_asprintf(NULL, "%+.3g%%", (val - 1) * 100);
+        return M_PROPERTY_OK;
+    }
+
+    return m_property_double_ro(action, arg, val);
+}
+
+static int mp_property_display_sync_active(void *ctx, struct m_property *prop,
+                                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg, mpctx->display_sync_active);
+}
+
+static int mp_property_pid(void *ctx, struct m_property *prop,
+                           int action, void *arg)
+{
+    // 32 bit on linux/windows - which C99 `int' is not guaranteed to hold
+    return m_property_int64_ro(action, arg, mp_getpid());
+}
+
+/// filename with path (RO)
+static int mp_property_path(void *ctx, struct m_property *prop,
+                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->filename)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_strdup_ro(action, arg, mpctx->filename);
+}
+
+static int mp_property_filename(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->filename)
+        return M_PROPERTY_UNAVAILABLE;
+    char *filename = talloc_strdup(NULL, mpctx->filename);
+    if (mp_is_url(bstr0(filename)))
+        mp_url_unescape_inplace(filename);
+    char *f = (char *)mp_basename(filename);
+    if (!f[0])
+        f = filename;
+    if (action == M_PROPERTY_KEY_ACTION) {
+        struct m_property_action_arg *ka = arg;
+        if (strcmp(ka->key, "no-ext") == 0) {
+            action = ka->action;
+            arg = ka->arg;
+            bstr root;
+            if (mp_splitext(f, &root))
+                f = bstrto0(filename, root);
+        }
+    }
+    int r = m_property_strdup_ro(action, arg, f);
+    talloc_free(filename);
+    return r;
+}
+
+static int mp_property_stream_open_filename(void *ctx, struct m_property *prop,
+                                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->stream_open_filename || !mpctx->playing)
+        return M_PROPERTY_UNAVAILABLE;
+    switch (action) {
+    case M_PROPERTY_SET: {
+        if (mpctx->demuxer)
+            return M_PROPERTY_ERROR;
+        mpctx->stream_open_filename =
+            talloc_strdup(mpctx->stream_open_filename, *(char **)arg);
+        mp_notify_property(mpctx, prop->name);
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE:
+    case M_PROPERTY_GET:
+        return m_property_strdup_ro(action, arg, mpctx->stream_open_filename);
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_file_size(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int64_t size = mpctx->demuxer->filesize;
+    if (size < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg = format_file_size(size);
+        return M_PROPERTY_OK;
+    }
+    return m_property_int64_ro(action, arg, size);
+}
+
+static const char *find_non_filename_media_title(MPContext *mpctx)
+{
+    const char *name = mpctx->opts->media_title;
+    if (name && name[0])
+        return name;
+    if (mpctx->demuxer) {
+        name = mp_tags_get_str(mpctx->demuxer->metadata, "service_name");
+        if (name && name[0])
+            return name;
+        name = mp_tags_get_str(mpctx->demuxer->metadata, "title");
+        if (name && name[0])
+            return name;
+        name = mp_tags_get_str(mpctx->demuxer->metadata, "icy-title");
+        if (name && name[0])
+            return name;
+    }
+    if (mpctx->playing && mpctx->playing->title)
+        return mpctx->playing->title;
+    return NULL;
+}
+
+static int mp_property_media_title(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    const char *name = find_non_filename_media_title(mpctx);
+    if (name && name[0])
+        return m_property_strdup_ro(action, arg, name);
+    return mp_property_filename(ctx, prop, action, arg);
+}
+
+static int mp_property_stream_path(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer || !mpctx->demuxer->filename)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_strdup_ro(action, arg, mpctx->demuxer->filename);
+}
+
+/// Demuxer name (RO)
+static int mp_property_demuxer(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_strdup_ro(action, arg, demuxer->desc->name);
+}
+
+static int mp_property_file_format(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+    const char *name = demuxer->filetype ? demuxer->filetype : demuxer->desc->name;
+    return m_property_strdup_ro(action, arg, name);
+}
+
+static int mp_property_stream_pos(void *ctx, struct m_property *prop,
+                                  int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer || demuxer->filepos < 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_int64_ro(action, arg, demuxer->filepos);
+}
+
+/// Stream end offset (RO)
+static int mp_property_stream_end(void *ctx, struct m_property *prop,
+                                  int action, void *arg)
+{
+    return mp_property_file_size(ctx, prop, action, arg);
+}
+
+// Does some magic to handle "<name>/full" as time formatted with milliseconds.
+// Assumes prop is the type of the actual property.
+static int property_time(int action, void *arg, double time)
+{
+    if (time == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+
+    const struct m_option time_type = {.type = CONF_TYPE_TIME};
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(double *)arg = time;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = time_type;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *ka = arg;
+
+        if (strcmp(ka->key, "full") != 0)
+            return M_PROPERTY_UNKNOWN;
+
+        switch (ka->action) {
+        case M_PROPERTY_GET:
+            *(double *)ka->arg = time;
+            return M_PROPERTY_OK;
+        case M_PROPERTY_PRINT:
+            *(char **)ka->arg = mp_format_time(time, true);
+            return M_PROPERTY_OK;
+        case M_PROPERTY_GET_TYPE:
+            *(struct m_option *)ka->arg = time_type;
+            return M_PROPERTY_OK;
+        }
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_duration(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    double len = get_time_length(mpctx);
+
+    if (len < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return property_time(action, arg, len);
+}
+
+static int mp_property_avsync(void *ctx, struct m_property *prop,
+                              int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->ao_chain || !mpctx->vo_chain)
+        return M_PROPERTY_UNAVAILABLE;
+    if (action == M_PROPERTY_PRINT) {
+        // Truncate anything < 1e-4 to avoid switching to scientific notation
+        if (fabs(mpctx->last_av_difference) < 1e-4) {
+            *(char **)arg = talloc_strdup(NULL, "0");
+        } else {
+            *(char **)arg = talloc_asprintf(NULL, "%+.2g", mpctx->last_av_difference);
+        }
+        return M_PROPERTY_OK;
+    }
+    return m_property_double_ro(action, arg, mpctx->last_av_difference);
+}
+
+static int mp_property_total_avsync_change(void *ctx, struct m_property *prop,
+                                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->ao_chain || !mpctx->vo_chain)
+        return M_PROPERTY_UNAVAILABLE;
+    if (mpctx->total_avsync_change == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, mpctx->total_avsync_change);
+}
+
+static int mp_property_frame_drop_dec(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct mp_decoder_wrapper *dec = mpctx->vo_chain && mpctx->vo_chain->track
+        ? mpctx->vo_chain->track->dec : NULL;
+    if (!dec)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg,
+                             mp_decoder_wrapper_get_frames_dropped(dec));
+}
+
+static int mp_property_mistimed_frame_count(void *ctx, struct m_property *prop,
+                                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->vo_chain || !mpctx->display_sync_active)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg, mpctx->mistimed_frames_total);
+}
+
+static int mp_property_vsync_ratio(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->vo_chain || !mpctx->display_sync_active)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int vsyncs = 0, frames = 0;
+    for (int n = 0; n < mpctx->num_past_frames; n++) {
+        int vsync = mpctx->past_frames[n].num_vsyncs;
+        if (vsync < 0)
+            break;
+        vsyncs += vsync;
+        frames += 1;
+    }
+
+    if (!frames)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_double_ro(action, arg, vsyncs / (double)frames);
+}
+
+static int mp_property_frame_drop_vo(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->vo_chain)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg, vo_get_drop_count(mpctx->video_out));
+}
+
+static int mp_property_vo_delayed_frame_count(void *ctx, struct m_property *prop,
+                                              int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->vo_chain)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg, vo_get_delayed_count(mpctx->video_out));
+}
+
+/// Current position in percent (RW)
+static int mp_property_percent_pos(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
+    case M_PROPERTY_SET: {
+        double pos = *(double *)arg;
+        queue_seek(mpctx, MPSEEK_FACTOR, pos / 100.0, MPSEEK_DEFAULT, 0);
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET: {
+        double pos = get_current_pos_ratio(mpctx, false) * 100.0;
+        if (pos < 0)
+            return M_PROPERTY_UNAVAILABLE;
+        *(double *)arg = pos;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){
+            .type = CONF_TYPE_DOUBLE,
+            .min = 0,
+            .max = 100,
+        };
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT: {
+        int pos = get_percent_pos(mpctx);
+        if (pos < 0)
+            return M_PROPERTY_UNAVAILABLE;
+        *(char **)arg = talloc_asprintf(NULL, "%d", pos);
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_time_start(void *ctx, struct m_property *prop,
+                                  int action, void *arg)
+{
+    // minor backwards-compat.
+    return property_time(action, arg, 0);
+}
+
+/// Current position in seconds (RW)
+static int mp_property_time_pos(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (action == M_PROPERTY_SET) {
+        queue_seek(mpctx, MPSEEK_ABSOLUTE, *(double *)arg, MPSEEK_DEFAULT, 0);
+        return M_PROPERTY_OK;
+    }
+    return property_time(action, arg, get_current_time(mpctx));
+}
+
+/// Current audio pts in seconds (R)
+static int mp_property_audio_pts(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized || mpctx->audio_status < STATUS_PLAYING ||
+        mpctx->audio_status >= STATUS_EOF)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return property_time(action, arg, playing_audio_pts(mpctx));
+}
+
+static bool time_remaining(MPContext *mpctx, double *remaining)
+{
+    double len = get_time_length(mpctx);
+    double playback = get_playback_time(mpctx);
+
+    if (playback == MP_NOPTS_VALUE || len <= 0)
+        return false;
+
+    *remaining = len - playback;
+
+    return len >= 0;
+}
+
+static int mp_property_remaining(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    double remaining;
+    if (!time_remaining(ctx, &remaining))
+        return M_PROPERTY_UNAVAILABLE;
+
+    return property_time(action, arg, remaining);
+}
+
+static int mp_property_playtime_remaining(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    double remaining;
+    if (!time_remaining(mpctx, &remaining))
+        return M_PROPERTY_UNAVAILABLE;
+
+    double speed = mpctx->video_speed;
+    return property_time(action, arg, remaining / speed);
+}
+
+static int mp_property_playback_time(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (action == M_PROPERTY_SET) {
+        queue_seek(mpctx, MPSEEK_ABSOLUTE, *(double *)arg, MPSEEK_DEFAULT, 0);
+        return M_PROPERTY_OK;
+    }
+    return property_time(action, arg, get_playback_time(mpctx));
+}
+
+/// Current chapter (RW)
+static int mp_property_chapter(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int chapter = get_current_chapter(mpctx);
+    int num = get_chapter_count(mpctx);
+    if (chapter < -1)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(int *) arg = chapter;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){
+            .type = CONF_TYPE_INT,
+            .min = -1,
+            .max = num - 1,
+        };
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT: {
+        *(char **) arg = chapter_display_name(mpctx, chapter);
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_SWITCH:
+    case M_PROPERTY_SET: ;
+        mark_seek(mpctx);
+        int step_all;
+        if (action == M_PROPERTY_SWITCH) {
+            struct m_property_switch_arg *sarg = arg;
+            step_all = lrint(sarg->inc);
+            // Check threshold for relative backward seeks
+            if (mpctx->opts->chapter_seek_threshold >= 0 && step_all < 0) {
+                double current_chapter_start =
+                    chapter_start_time(mpctx, chapter);
+                // If we are far enough into a chapter, seek back to the
+                // beginning of current chapter instead of previous one
+                if (current_chapter_start != MP_NOPTS_VALUE &&
+                    get_current_time(mpctx) - current_chapter_start >
+                    mpctx->opts->chapter_seek_threshold)
+                {
+                    step_all++;
+                }
+            }
+        } else // Absolute set
+            step_all = *(int *)arg - chapter;
+        chapter += step_all;
+        if (chapter < 0) // avoid using -1 if first chapter starts at 0
+            chapter = (chapter_start_time(mpctx, 0) <= 0) ? 0 : -1;
+        if (chapter >= num && step_all > 0) {
+            if (mpctx->opts->keep_open) {
+                seek_to_last_frame(mpctx);
+            } else {
+                // semi-broken file; ignore for user convenience
+                if (action == M_PROPERTY_SWITCH && num < 2)
+                    return M_PROPERTY_UNAVAILABLE;
+                if (!mpctx->stop_play)
+                    mpctx->stop_play = PT_NEXT_ENTRY;
+                mp_wakeup_core(mpctx);
+            }
+        } else {
+            double pts = chapter_start_time(mpctx, chapter);
+            if (pts != MP_NOPTS_VALUE) {
+                queue_seek(mpctx, MPSEEK_CHAPTER, pts, MPSEEK_DEFAULT, 0);
+                mpctx->last_chapter_seek = chapter;
+                mpctx->last_chapter_flag = true;
+            }
+        }
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int get_chapter_entry(int item, int action, void *arg, void *ctx)
+{
+    struct MPContext *mpctx = ctx;
+    char *name = chapter_name(mpctx, item);
+    double time = chapter_start_time(mpctx, item);
+    struct m_sub_property props[] = {
+        {"title",       SUB_PROP_STR(name)},
+        {"time",        {.type = CONF_TYPE_TIME}, {.time = time}},
+        {0}
+    };
+
+    int r = m_property_read_sub(props, action, arg);
+    return r;
+}
+
+static int parse_node_chapters(struct MPContext *mpctx,
+                               struct mpv_node *given_chapters)
+{
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (given_chapters->format != MPV_FORMAT_NODE_ARRAY)
+        return M_PROPERTY_ERROR;
+
+    double len = get_time_length(mpctx);
+
+    talloc_free(mpctx->chapters);
+    mpctx->num_chapters = 0;
+    mpctx->chapters = talloc_array(NULL, struct demux_chapter, 0);
+
+    for (int n = 0; n < given_chapters->u.list->num; n++) {
+        struct mpv_node *chapter_data = &given_chapters->u.list->values[n];
+
+        if (chapter_data->format != MPV_FORMAT_NODE_MAP)
+            continue;
+
+        mpv_node_list *chapter_data_elements = chapter_data->u.list;
+
+        double time = -1;
+        char *title = 0;
+
+        for (int e = 0; e < chapter_data_elements->num; e++) {
+            struct mpv_node *chapter_data_element =
+                &chapter_data_elements->values[e];
+            char *key = chapter_data_elements->keys[e];
+            switch (chapter_data_element->format) {
+            case MPV_FORMAT_INT64:
+                if (strcmp(key, "time") == 0)
+                    time = (double)chapter_data_element->u.int64;
+                break;
+            case MPV_FORMAT_DOUBLE:
+                if (strcmp(key, "time") == 0)
+                    time = chapter_data_element->u.double_;
+                break;
+            case MPV_FORMAT_STRING:
+                if (strcmp(key, "title") == 0)
+                    title = chapter_data_element->u.string;
+                break;
+            }
+        }
+
+        if (time >= 0 && time < len) {
+            struct demux_chapter new = {
+                .pts = time,
+                .metadata = talloc_zero(mpctx->chapters, struct mp_tags),
+            };
+            if (title)
+                mp_tags_set_str(new.metadata, "title", title);
+            MP_TARRAY_APPEND(NULL, mpctx->chapters, mpctx->num_chapters, new);
+        }
+    }
+
+    mp_notify(mpctx, MP_EVENT_CHAPTER_CHANGE, NULL);
+    mp_notify_property(mpctx, "chapter-list");
+
+    return M_PROPERTY_OK;
+}
+
+static int mp_property_list_chapters(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int count = get_chapter_count(mpctx);
+    switch (action) {
+    case M_PROPERTY_PRINT: {
+        int cur = mpctx->playback_initialized ? get_current_chapter(mpctx) : -1;
+        char *res = NULL;
+        int n;
+
+        if (count < 1) {
+            res = talloc_asprintf_append(res, "No chapters.");
+        }
+
+        for (n = 0; n < count; n++) {
+            char *name = chapter_display_name(mpctx, n);
+            double t = chapter_start_time(mpctx, n);
+            char* time = mp_format_time(t, false);
+            res = talloc_asprintf_append(res, "%s", time);
+            talloc_free(time);
+            const char *m = n == cur ? list_current : list_normal;
+            res = talloc_asprintf_append(res, "   %s%s\n", m, name);
+            talloc_free(name);
+        }
+
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_SET: {
+        struct mpv_node *given_chapters = arg;
+        return parse_node_chapters(mpctx, given_chapters);
+    }
+    }
+    return m_property_read_list(action, arg, count, get_chapter_entry, mpctx);
+}
+
+static int mp_property_current_edition(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer || demuxer->num_editions <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(action, arg, demuxer->edition);
+}
+
+static int mp_property_edition(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    char *name = NULL;
+
+    if (!demuxer)
+        return mp_property_generic_option(mpctx, prop, action, arg);
+
+    int ed = demuxer->edition;
+
+    if (demuxer->num_editions <= 1)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
+    case M_PROPERTY_GET_CONSTRICTED_TYPE: {
+        *(struct m_option *)arg = (struct m_option){
+            .type = CONF_TYPE_INT,
+            .min = 0,
+            .max = demuxer->num_editions - 1,
+        };
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_PRINT: {
+        if (ed < 0)
+            return M_PROPERTY_UNAVAILABLE;
+        name = mp_tags_get_str(demuxer->editions[ed].metadata, "title");
+        if (name) {
+            *(char **) arg = talloc_strdup(NULL, name);
+        } else {
+            *(char **) arg = talloc_asprintf(NULL, "%d", ed + 1);
+        }
+        return M_PROPERTY_OK;
+    }
+    default:
+        return mp_property_generic_option(mpctx, prop, action, arg);
+    }
+}
+
+static int get_edition_entry(int item, int action, void *arg, void *ctx)
+{
+    struct MPContext *mpctx = ctx;
+
+    struct demuxer *demuxer = mpctx->demuxer;
+    struct demux_edition *ed = &demuxer->editions[item];
+
+    char *title = mp_tags_get_str(ed->metadata, "title");
+
+    struct m_sub_property props[] = {
+        {"id",          SUB_PROP_INT(item)},
+        {"title",       SUB_PROP_STR(title),
+                        .unavailable = !title},
+        {"default",     SUB_PROP_BOOL(ed->default_edition)},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static int property_list_editions(void *ctx, struct m_property *prop,
+                                  int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (action == M_PROPERTY_PRINT) {
+        char *res = NULL;
+
+        struct demux_edition *editions = demuxer->editions;
+        int num_editions = demuxer->num_editions;
+        int current = demuxer->edition;
+
+        if (!num_editions)
+            res = talloc_asprintf_append(res, "No editions.");
+
+        for (int n = 0; n < num_editions; n++) {
+            struct demux_edition *ed = &editions[n];
+
+            res = talloc_strdup_append(res, n == current ? list_current
+                                                         : list_normal);
+            res = talloc_asprintf_append(res, "%d: ", n);
+            char *title = mp_tags_get_str(ed->metadata, "title");
+            if (!title)
+                title = "unnamed";
+            res = talloc_asprintf_append(res, "'%s'\n", title);
+        }
+
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    return m_property_read_list(action, arg, demuxer->num_editions,
+                                get_edition_entry, mpctx);
+}
+
+/// Number of chapters in file
+static int mp_property_chapters(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+    int count = get_chapter_count(mpctx);
+    return m_property_int_ro(action, arg, count);
+}
+
+static int mp_property_editions(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+    if (demuxer->num_editions <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(action, arg, demuxer->num_editions);
+}
+
+static int get_tag_entry(int item, int action, void *arg, void *ctx)
+{
+    struct mp_tags *tags = ctx;
+
+    struct m_sub_property props[] = {
+        {"key",     SUB_PROP_STR(tags->keys[item])},
+        {"value",   SUB_PROP_STR(tags->values[item])},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+// tags can be NULL for M_PROPERTY_GET_TYPE. (In all other cases, tags must be
+// provided, even for M_PROPERTY_KEY_ACTION GET_TYPE sub-actions.)
+static int tag_property(int action, void *arg, struct mp_tags *tags)
+{
+    switch (action) {
+    case M_PROPERTY_GET_NODE: // same as GET, because type==mpv_node
+    case M_PROPERTY_GET: {
+        mpv_node_list *list = talloc_zero(NULL, mpv_node_list);
+        mpv_node node = {
+            .format = MPV_FORMAT_NODE_MAP,
+            .u.list = list,
+        };
+        list->num = tags->num_keys;
+        list->values = talloc_array(list, mpv_node, list->num);
+        list->keys = talloc_array(list, char*, list->num);
+        for (int n = 0; n < tags->num_keys; n++) {
+            list->keys[n] = talloc_strdup(list, tags->keys[n]);
+            list->values[n] = (struct mpv_node){
+                .format = MPV_FORMAT_STRING,
+                .u.string = talloc_strdup(list, tags->values[n]),
+            };
+        }
+        *(mpv_node*)arg = node;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE: {
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_PRINT: {
+        char *res = NULL;
+        for (int n = 0; n < tags->num_keys; n++) {
+            res = talloc_asprintf_append_buffer(res, "%s: %s\n",
+                                                tags->keys[n], tags->values[n]);
+        }
+        if (!res)
+            res = talloc_strdup(NULL, "(empty)");
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *ka = arg;
+        bstr key;
+        char *rem;
+        m_property_split_path(ka->key, &key, &rem);
+        if (bstr_equals0(key, "list")) {
+            struct m_property_action_arg nka = *ka;
+            nka.key = rem;
+            return m_property_read_list(action, &nka, tags->num_keys,
+                                        get_tag_entry, tags);
+        }
+        // Direct access without this prefix is allowed for compatibility.
+        bstr k = bstr0(ka->key);
+        bstr_eatstart0(&k, "by-key/");
+        char *meta = mp_tags_get_bstr(tags, k);
+        if (!meta)
+            return M_PROPERTY_UNKNOWN;
+        switch (ka->action) {
+        case M_PROPERTY_GET:
+            *(char **)ka->arg = talloc_strdup(NULL, meta);
+            return M_PROPERTY_OK;
+        case M_PROPERTY_GET_TYPE:
+            *(struct m_option *)ka->arg = (struct m_option){
+                .type = CONF_TYPE_STRING,
+            };
+            return M_PROPERTY_OK;
+        }
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+/// Demuxer meta data
+static int mp_property_metadata(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return tag_property(action, arg, demuxer->metadata);
+}
+
+static int mp_property_filtered_metadata(void *ctx, struct m_property *prop,
+                                         int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->filtered_tags)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return tag_property(action, arg, mpctx->filtered_tags);
+}
+
+static int mp_property_chapter_metadata(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int chapter = get_current_chapter(mpctx);
+    if (chapter < 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return tag_property(action, arg, mpctx->chapters[chapter].metadata);
+}
+
+static int mp_property_filter_metadata(void *ctx, struct m_property *prop,
+                                       int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    const char *type = prop->priv;
+
+    if (action == M_PROPERTY_KEY_ACTION) {
+        struct m_property_action_arg *ka = arg;
+        bstr key;
+        char *rem;
+        m_property_split_path(ka->key, &key, &rem);
+        struct mp_tags *metadata = NULL;
+        struct mp_output_chain *chain = NULL;
+        if (strcmp(type, "vf") == 0) {
+            chain = mpctx->vo_chain ? mpctx->vo_chain->filter : NULL;
+        } else if (strcmp(type, "af") == 0) {
+            chain = mpctx->ao_chain ? mpctx->ao_chain->filter : NULL;
+        }
+        if (!chain)
+            return M_PROPERTY_UNAVAILABLE;
+
+        if (ka->action != M_PROPERTY_GET_TYPE) {
+            struct mp_filter_command cmd = {
+                .type = MP_FILTER_COMMAND_GET_META,
+                .res = &metadata,
+            };
+            mp_output_chain_command(chain, mp_tprintf(80, "%.*s", BSTR_P(key)),
+                                    &cmd);
+
+            if (!metadata)
+                return M_PROPERTY_ERROR;
+        }
+
+        int res;
+        if (strlen(rem)) {
+            struct m_property_action_arg next_ka = *ka;
+            next_ka.key = rem;
+            res = tag_property(M_PROPERTY_KEY_ACTION, &next_ka, metadata);
+        } else {
+            res = tag_property(ka->action, ka->arg, metadata);
+        }
+        talloc_free(metadata);
+        return res;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_core_idle(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg, !mpctx->playback_active);
+}
+
+static int mp_property_idle(void *ctx, struct m_property *prop,
+                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg, mpctx->stop_play == PT_STOP);
+}
+
+static int mp_property_window_id(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    int64_t wid;
+    if (!vo || vo_control(vo, VOCTRL_GET_WINDOW_ID, &wid) <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_int64_ro(action, arg, wid);
+}
+
+static int mp_property_eof_reached(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+    bool eof = mpctx->video_status == STATUS_EOF &&
+               mpctx->audio_status == STATUS_EOF;
+    return m_property_bool_ro(action, arg, eof);
+}
+
+static int mp_property_seeking(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_bool_ro(action, arg, !mpctx->restart_complete);
+}
+
+static int mp_property_playback_abort(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg, !mpctx->playing || mpctx->stop_play);
+}
+
+static int mp_property_cache_speed(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct demux_reader_state s;
+    demux_get_reader_state(mpctx->demuxer, &s);
+
+    uint64_t val = s.bytes_per_second;
+
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg = talloc_strdup_append(format_file_size(val), "/s");
+        return M_PROPERTY_OK;
+    }
+    return m_property_int64_ro(action, arg, val);
+}
+
+static int mp_property_demuxer_cache_duration(void *ctx, struct m_property *prop,
+                                              int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct demux_reader_state s;
+    demux_get_reader_state(mpctx->demuxer, &s);
+
+    if (s.ts_duration < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_double_ro(action, arg, s.ts_duration);
+}
+
+static int mp_property_demuxer_cache_time(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct demux_reader_state s;
+    demux_get_reader_state(mpctx->demuxer, &s);
+
+    if (s.ts_end == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_double_ro(action, arg, s.ts_end);
+}
+
+static int mp_property_demuxer_cache_idle(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct demux_reader_state s;
+    demux_get_reader_state(mpctx->demuxer, &s);
+
+    return m_property_bool_ro(action, arg, s.idle);
+}
+
+static int mp_property_demuxer_cache_state(void *ctx, struct m_property *prop,
+                                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (action == M_PROPERTY_GET_TYPE) {
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    }
+    if (action != M_PROPERTY_GET)
+        return M_PROPERTY_NOT_IMPLEMENTED;
+
+    struct demux_reader_state s;
+    demux_get_reader_state(mpctx->demuxer, &s);
+
+    struct mpv_node *r = (struct mpv_node *)arg;
+    node_init(r, MPV_FORMAT_NODE_MAP, NULL);
+
+    if (s.ts_end != MP_NOPTS_VALUE)
+        node_map_add_double(r, "cache-end", s.ts_end);
+
+    if (s.ts_reader != MP_NOPTS_VALUE)
+        node_map_add_double(r, "reader-pts", s.ts_reader);
+
+    if (s.ts_duration >= 0)
+        node_map_add_double(r, "cache-duration", s.ts_duration);
+
+    node_map_add_flag(r, "eof", s.eof);
+    node_map_add_flag(r, "underrun", s.underrun);
+    node_map_add_flag(r, "idle", s.idle);
+    node_map_add_int64(r, "total-bytes", s.total_bytes);
+    node_map_add_int64(r, "fw-bytes", s.fw_bytes);
+    if (s.file_cache_bytes >= 0)
+        node_map_add_int64(r, "file-cache-bytes", s.file_cache_bytes);
+    if (s.bytes_per_second > 0)
+        node_map_add_int64(r, "raw-input-rate", s.bytes_per_second);
+    if (s.seeking != MP_NOPTS_VALUE)
+        node_map_add_double(r, "debug-seeking", s.seeking);
+    node_map_add_int64(r, "debug-low-level-seeks", s.low_level_seeks);
+    node_map_add_int64(r, "debug-byte-level-seeks", s.byte_level_seeks);
+    if (s.ts_last != MP_NOPTS_VALUE)
+        node_map_add_double(r, "debug-ts-last", s.ts_last);
+
+    node_map_add_flag(r, "bof-cached", s.bof_cached);
+    node_map_add_flag(r, "eof-cached", s.eof_cached);
+
+    struct mpv_node *ranges =
+        node_map_add(r, "seekable-ranges", MPV_FORMAT_NODE_ARRAY);
+    for (int n = s.num_seek_ranges - 1; n >= 0; n--) {
+        struct demux_seek_range *range = &s.seek_ranges[n];
+        struct mpv_node *sub = node_array_add(ranges, MPV_FORMAT_NODE_MAP);
+        node_map_add_double(sub, "start", range->start);
+        node_map_add_double(sub, "end", range->end);
+    }
+
+    return M_PROPERTY_OK;
+}
+
+static int mp_property_demuxer_start_time(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_double_ro(action, arg, mpctx->demuxer->start_time);
+}
+
+static int mp_property_paused_for_cache(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playback_initialized)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_bool_ro(action, arg, mpctx->paused_for_cache);
+}
+
+static int mp_property_cache_buffering(void *ctx, struct m_property *prop,
+                                       int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int state = get_cache_buffering_percentage(mpctx);
+    if (state < 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(action, arg, state);
+}
+
+static int mp_property_demuxer_is_network(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_bool_ro(action, arg, mpctx->demuxer->is_network);
+}
+
+
+static int mp_property_clock(void *ctx, struct m_property *prop,
+                             int action, void *arg)
+{
+    char outstr[6];
+    time_t t = time(NULL);
+    struct tm *tmp = localtime(&t);
+
+    if ((tmp != NULL) && (strftime(outstr, sizeof(outstr), "%H:%M", tmp) == 5))
+        return m_property_strdup_ro(action, arg, outstr);
+    return M_PROPERTY_UNAVAILABLE;
+}
+
+static int mp_property_seekable(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_bool_ro(action, arg, mpctx->demuxer->seekable);
+}
+
+static int mp_property_partially_seekable(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_bool_ro(action, arg, mpctx->demuxer->partially_seekable);
+}
+
+static int mp_property_mixer_active(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg, !!mpctx->ao);
+}
+
+/// Volume (RW)
+static int mp_property_volume(void *ctx, struct m_property *prop,
+                              int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct MPOpts *opts = mpctx->opts;
+
+    switch (action) {
+    case M_PROPERTY_GET_CONSTRICTED_TYPE:
+        *(struct m_option *)arg = (struct m_option){
+            .type = CONF_TYPE_FLOAT,
+            .min = 0,
+            .max = opts->softvol_max,
+        };
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT:
+        *(char **)arg = talloc_asprintf(NULL, "%i", (int)opts->softvol_volume);
+        return M_PROPERTY_OK;
+    }
+
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_ao_volume(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct ao *ao = mpctx->ao;
+    if (!ao)
+        return M_PROPERTY_NOT_IMPLEMENTED;
+
+    switch (action) {
+    case M_PROPERTY_SET: {
+        float vol = *(float *)arg;
+        if (ao_control(ao, AOCONTROL_SET_VOLUME, &vol) != CONTROL_OK)
+            return M_PROPERTY_UNAVAILABLE;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET: {
+        if (ao_control(ao, AOCONTROL_GET_VOLUME, arg) != CONTROL_OK)
+            return M_PROPERTY_UNAVAILABLE;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){
+            .type = CONF_TYPE_FLOAT,
+            .min = 0,
+            .max = 100,
+        };
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT: {
+        float vol = 0;
+        if (ao_control(ao, AOCONTROL_GET_VOLUME, &vol) != CONTROL_OK)
+            return M_PROPERTY_UNAVAILABLE;
+        *(char **)arg = talloc_asprintf(NULL, "%.f", vol);
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+
+static int mp_property_ao_mute(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct ao *ao = mpctx->ao;
+    if (!ao)
+        return M_PROPERTY_NOT_IMPLEMENTED;
+
+    switch (action) {
+    case M_PROPERTY_SET: {
+        bool value = *(int *)arg;
+        if (ao_control(ao, AOCONTROL_SET_MUTE, &value) != CONTROL_OK)
+            return M_PROPERTY_UNAVAILABLE;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET: {
+        bool value = false;
+        if (ao_control(ao, AOCONTROL_GET_MUTE, &value) != CONTROL_OK)
+            return M_PROPERTY_UNAVAILABLE;
+        *(int *)arg = value;
+        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;
+}
+
+static int get_device_entry(int item, int action, void *arg, void *ctx)
+{
+    struct ao_device_list *list = ctx;
+    struct ao_device_desc *entry = &list->devices[item];
+
+    struct m_sub_property props[] = {
+        {"name",        SUB_PROP_STR(entry->name)},
+        {"description", SUB_PROP_STR(entry->desc)},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static void create_hotplug(struct MPContext *mpctx)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+
+    if (!cmd->hotplug) {
+        cmd->hotplug = ao_hotplug_create(mpctx->global, mp_wakeup_core_cb,
+                                         mpctx);
+    }
+}
+
+static int mp_property_audio_device(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    struct MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+    if (action == M_PROPERTY_PRINT) {
+        create_hotplug(mpctx);
+
+        char *name = NULL;
+        if (mp_property_generic_option(mpctx, prop, M_PROPERTY_GET, &name) < 1)
+            name = NULL;
+
+        struct ao_device_list *list = ao_hotplug_get_device_list(cmd->hotplug, mpctx->ao);
+        for (int n = 0; n < list->num_devices; n++) {
+            struct ao_device_desc *dev = &list->devices[n];
+            if (dev->name && name && strcmp(dev->name, name) == 0) {
+                *(char **)arg = talloc_strdup(NULL, dev->desc ? dev->desc : "?");
+                talloc_free(name);
+                return M_PROPERTY_OK;
+            }
+        }
+
+        talloc_free(name);
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_audio_devices(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    struct MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+    create_hotplug(mpctx);
+
+    struct ao_device_list *list = ao_hotplug_get_device_list(cmd->hotplug, mpctx->ao);
+    return m_property_read_list(action, arg, list->num_devices,
+                                get_device_entry, list);
+}
+
+static int mp_property_ao(void *ctx, struct m_property *p, int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_strdup_ro(action, arg,
+                                    mpctx->ao ? ao_get_name(mpctx->ao) : NULL);
+}
+
+/// Audio delay (RW)
+static int mp_property_audio_delay(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg = format_delay(mpctx->opts->audio_delay);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+/// Audio codec tag (RO)
+static int mp_property_audio_codec_name(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_AUDIO];
+    const char *c = track && track->stream ? track->stream->codec->codec : NULL;
+    return m_property_strdup_ro(action, arg, c);
+}
+
+/// Audio codec name (RO)
+static int mp_property_audio_codec(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_AUDIO];
+    char desc[256] = "";
+    if (track && track->dec)
+        mp_decoder_wrapper_get_desc(track->dec, desc, sizeof(desc));
+    return m_property_strdup_ro(action, arg, desc[0] ? desc : NULL);
+}
+
+static int property_audiofmt(struct mp_aframe *fmt, int action, void *arg)
+{
+    if (!fmt || !mp_aframe_config_is_valid(fmt))
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct mp_chmap chmap = {0};
+    mp_aframe_get_chmap(fmt, &chmap);
+
+    struct m_sub_property props[] = {
+        {"samplerate",      SUB_PROP_INT(mp_aframe_get_rate(fmt))},
+        {"channel-count",   SUB_PROP_INT(chmap.num)},
+        {"channels",        SUB_PROP_STR(mp_chmap_to_str(&chmap))},
+        {"hr-channels",     SUB_PROP_STR(mp_chmap_to_str_hr(&chmap))},
+        {"format",          SUB_PROP_STR(af_fmt_to_str(mp_aframe_get_format(fmt)))},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_audio_params(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return property_audiofmt(mpctx->ao_chain ?
+        mpctx->ao_chain->filter->input_aformat : NULL, action, arg);
+}
+
+static int mp_property_audio_out_params(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct mp_aframe *frame = NULL;
+    if (mpctx->ao) {
+        frame = mp_aframe_create();
+        int samplerate;
+        int format;
+        struct mp_chmap channels;
+        ao_get_format(mpctx->ao, &samplerate, &format, &channels);
+        mp_aframe_set_rate(frame, samplerate);
+        mp_aframe_set_format(frame, format);
+        mp_aframe_set_chmap(frame, &channels);
+    }
+    int r = property_audiofmt(frame, action, arg);
+    talloc_free(frame);
+    return r;
+}
+
+static struct track* track_next(struct MPContext *mpctx, enum stream_type type,
+                                int direction, struct track *track)
+{
+    assert(direction == -1 || direction == +1);
+    struct track *prev = NULL, *next = NULL;
+    bool seen = track == NULL;
+    for (int n = 0; n < mpctx->num_tracks; n++) {
+        struct track *cur = mpctx->tracks[n];
+        if (cur->type == type) {
+            if (cur == track) {
+                seen = true;
+            } else if (!cur->selected) {
+                if (seen && !next) {
+                    next = cur;
+                }
+                if (!seen || !track) {
+                    prev = cur;
+                }
+            }
+        }
+    }
+    return direction > 0 ? next : prev;
+}
+
+static int property_switch_track(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    const int *def = prop->priv;
+    int order = def[0];
+    enum stream_type type = def[1];
+
+    struct track *track = mpctx->current_track[order][type];
+
+    switch (action) {
+    case M_PROPERTY_GET:
+        if (mpctx->playback_initialized) {
+            *(int *)arg = track ? track->user_tid : -2;
+        } else {
+            *(int *)arg = mpctx->opts->stream_id[order][type];
+        }
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT:
+        if (track) {
+            char *lang = track->lang;
+            if (!lang && type != STREAM_VIDEO) {
+                lang = "unknown";
+            } else if (!lang) {
+                lang = "";
+            }
+
+            if (track->title) {
+                *(char **)arg = talloc_asprintf(NULL, "(%d) %s (\"%s\")",
+                                           track->user_tid, lang, track->title);
+            } else {
+                *(char **)arg = talloc_asprintf(NULL, "(%d) %s",
+                                                track->user_tid, lang);
+            }
+        } else {
+            const char *msg = "no";
+            if (!mpctx->playback_initialized &&
+                mpctx->opts->stream_id[order][type] == -1)
+                msg = "auto";
+            *(char **) arg = talloc_strdup(NULL, msg);
+        }
+        return M_PROPERTY_OK;
+
+    case M_PROPERTY_SWITCH: {
+        if (mpctx->playback_initialized) {
+            struct m_property_switch_arg *sarg = arg;
+            do {
+                track = track_next(mpctx, type, sarg->inc >= 0 ? +1 : -1, track);
+                mp_switch_track_n(mpctx, order, type, track, FLAG_MARK_SELECTION);
+            } while (mpctx->current_track[order][type] != track);
+            print_track_list(mpctx, "Track switched:");
+        } else {
+            // Simply cycle between "no" and "auto". It's possible that this does
+            // not always do what the user means, but keep the complexity low.
+            mark_track_selection(mpctx, order, type,
+                mpctx->opts->stream_id[order][type] == -1 ? -2 : -1);
+        }
+        return M_PROPERTY_OK;
+    }
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int track_channels(struct track *track)
+{
+    return track->stream ? track->stream->codec->channels.num : 0;
+}
+
+static int get_track_entry(int item, int action, void *arg, void *ctx)
+{
+    struct MPContext *mpctx = ctx;
+    struct track *track = mpctx->tracks[item];
+
+    struct mp_codec_params p =
+        track->stream ? *track->stream->codec : (struct mp_codec_params){0};
+
+    char decoder_desc[256] = {0};
+    if (track->dec)
+        mp_decoder_wrapper_get_desc(track->dec, decoder_desc, sizeof(decoder_desc));
+
+    bool has_rg = track->stream && track->stream->codec->replaygain_data;
+    struct replaygain_data rg = has_rg ? *track->stream->codec->replaygain_data
+                                       : (struct replaygain_data){0};
+
+    double par = 0.0;
+    if (p.par_h)
+        par = p.par_w / (double) p.par_h;
+
+    int order = -1;
+    if (track->selected) {
+        for (int i = 0; i < num_ptracks[track->type]; i++) {
+            if (mpctx->current_track[i][track->type] == track) {
+                order = i;
+                break;
+            }
+        }
+    }
+
+    bool has_crop = mp_rect_w(p.crop) > 0 && mp_rect_h(p.crop) > 0;
+    struct m_sub_property props[] = {
+        {"id",          SUB_PROP_INT(track->user_tid)},
+        {"type",        SUB_PROP_STR(stream_type_name(track->type)),
+                        .unavailable = !stream_type_name(track->type)},
+        {"src-id",      SUB_PROP_INT(track->demuxer_id),
+                        .unavailable = track->demuxer_id == -1},
+        {"title",       SUB_PROP_STR(track->title),
+                        .unavailable = !track->title},
+        {"lang",        SUB_PROP_STR(track->lang),
+                        .unavailable = !track->lang},
+        {"audio-channels", SUB_PROP_INT(track_channels(track)),
+                        .unavailable = track_channels(track) <= 0},
+        {"image",       SUB_PROP_BOOL(track->image)},
+        {"albumart",    SUB_PROP_BOOL(track->attached_picture)},
+        {"default",     SUB_PROP_BOOL(track->default_track)},
+        {"forced",      SUB_PROP_BOOL(track->forced_track)},
+        {"dependent",   SUB_PROP_BOOL(track->dependent_track)},
+        {"visual-impaired",  SUB_PROP_BOOL(track->visual_impaired_track)},
+        {"hearing-impaired", SUB_PROP_BOOL(track->hearing_impaired_track)},
+        {"external",    SUB_PROP_BOOL(track->is_external)},
+        {"selected",    SUB_PROP_BOOL(track->selected)},
+        {"main-selection", SUB_PROP_INT(order), .unavailable = order < 0},
+        {"external-filename", SUB_PROP_STR(track->external_filename),
+                        .unavailable = !track->external_filename},
+        {"ff-index",    SUB_PROP_INT(track->ff_index)},
+        {"hls-bitrate", SUB_PROP_INT(track->hls_bitrate),
+                        .unavailable = !track->hls_bitrate},
+        {"program-id",  SUB_PROP_INT(track->program_id),
+                        .unavailable = track->program_id < 0},
+        {"decoder-desc", SUB_PROP_STR(decoder_desc),
+                        .unavailable = !decoder_desc[0]},
+        {"codec",       SUB_PROP_STR(p.codec),
+                        .unavailable = !p.codec},
+        {"demux-w",     SUB_PROP_INT(p.disp_w), .unavailable = !p.disp_w},
+        {"demux-h",     SUB_PROP_INT(p.disp_h), .unavailable = !p.disp_h},
+        {"demux-crop-x",SUB_PROP_INT(p.crop.x0), .unavailable = !has_crop},
+        {"demux-crop-y",SUB_PROP_INT(p.crop.y0), .unavailable = !has_crop},
+        {"demux-crop-w",SUB_PROP_INT(mp_rect_w(p.crop)), .unavailable = !has_crop},
+        {"demux-crop-h",SUB_PROP_INT(mp_rect_h(p.crop)), .unavailable = !has_crop},
+        {"demux-channel-count", SUB_PROP_INT(p.channels.num),
+                        .unavailable = !p.channels.num},
+        {"demux-channels", SUB_PROP_STR(mp_chmap_to_str(&p.channels)),
+                        .unavailable = !p.channels.num},
+        {"demux-samplerate", SUB_PROP_INT(p.samplerate),
+                        .unavailable = !p.samplerate},
+        {"demux-fps",   SUB_PROP_DOUBLE(p.fps), .unavailable = p.fps <= 0},
+        {"demux-bitrate",  SUB_PROP_INT(p.bitrate), .unavailable = p.bitrate <= 0},
+        {"demux-rotation", SUB_PROP_INT(p.rotate),  .unavailable = p.rotate <= 0},
+        {"demux-par",      SUB_PROP_DOUBLE(par),    .unavailable = par <= 0},
+        {"replaygain-track-peak", SUB_PROP_FLOAT(rg.track_peak),
+                        .unavailable = !has_rg},
+        {"replaygain-track-gain", SUB_PROP_FLOAT(rg.track_gain),
+                        .unavailable = !has_rg},
+        {"replaygain-album-peak", SUB_PROP_FLOAT(rg.album_peak),
+                        .unavailable = !has_rg},
+        {"replaygain-album-gain", SUB_PROP_FLOAT(rg.album_gain),
+                        .unavailable = !has_rg},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static const char *track_type_name(enum stream_type t)
+{
+    switch (t) {
+    case STREAM_VIDEO: return "Video";
+    case STREAM_AUDIO: return "Audio";
+    case STREAM_SUB: return "Sub";
+    }
+    return NULL;
+}
+
+static int property_list_tracks(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_PRINT) {
+        char *res = NULL;
+
+        for (int type = 0; type < STREAM_TYPE_COUNT; type++) {
+            for (int n = 0; n < mpctx->num_tracks; n++) {
+                struct track *track = mpctx->tracks[n];
+                if (track->type != type)
+                    continue;
+
+                res = talloc_asprintf_append(res, "%s: ",
+                                             track_type_name(track->type));
+                res = talloc_strdup_append(res,
+                                track->selected ? list_current : list_normal);
+                res = talloc_asprintf_append(res, "(%d) ", track->user_tid);
+                if (track->title)
+                    res = talloc_asprintf_append(res, "'%s' ", track->title);
+                if (track->lang)
+                    res = talloc_asprintf_append(res, "(%s) ", track->lang);
+                if (track->is_external)
+                    res = talloc_asprintf_append(res, "(external) ");
+                res = talloc_asprintf_append(res, "\n");
+            }
+
+            res = talloc_asprintf_append(res, "\n");
+        }
+
+        struct demuxer *demuxer = mpctx->demuxer;
+        if (demuxer && demuxer->num_editions > 1)
+            res = talloc_asprintf_append(res, "\nEdition: %d of %d\n",
+                                        demuxer->edition + 1,
+                                        demuxer->num_editions);
+
+        *(char **)arg = res;
+        return M_PROPERTY_OK;
+    }
+    return m_property_read_list(action, arg, mpctx->num_tracks,
+                                get_track_entry, mpctx);
+}
+
+static int property_current_tracks(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+
+    if (action != M_PROPERTY_KEY_ACTION)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int type = -1;
+    int order = 0;
+
+    struct m_property_action_arg *ka = arg;
+    bstr key;
+    char *rem;
+    m_property_split_path(ka->key, &key, &rem);
+
+    if (bstr_equals0(key, "video")) {
+        type = STREAM_VIDEO;
+    } else if (bstr_equals0(key, "audio")) {
+        type = STREAM_AUDIO;
+    } else if (bstr_equals0(key, "sub")) {
+        type = STREAM_SUB;
+    } else if (bstr_equals0(key, "sub2")) {
+        type = STREAM_SUB;
+        order = 1;
+    }
+
+    if (type < 0)
+        return M_PROPERTY_UNKNOWN;
+
+    struct track *t = mpctx->current_track[order][type];
+
+    if (!t && mpctx->lavfi) {
+        for (int n = 0; n < mpctx->num_tracks; n++) {
+            if (mpctx->tracks[n]->type == type && mpctx->tracks[n]->selected) {
+                t = mpctx->tracks[n];
+                break;
+            }
+        }
+    }
+
+    if (!t)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int index = -1;
+    for (int n = 0; n < mpctx->num_tracks; n++) {
+        if (mpctx->tracks[n] == t) {
+            index = n;
+            break;
+        }
+    }
+    assert(index >= 0);
+
+    char *name = mp_tprintf(80, "track-list/%d/%s", index, rem);
+    return mp_property_do(name, ka->action, ka->arg, ctx);
+}
+
+static int mp_property_hwdec_current(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+    struct mp_decoder_wrapper *dec = track ? track->dec : NULL;
+
+    if (!dec)
+        return M_PROPERTY_UNAVAILABLE;
+
+    char *current = NULL;
+    mp_decoder_wrapper_control(dec, VDCTRL_GET_HWDEC, &current);
+    if (!current || !current[0])
+        current = "no";
+    return m_property_strdup_ro(action, arg, current);
+}
+
+static int mp_property_hwdec_interop(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->video_out || !mpctx->video_out->hwdec_devs)
+        return M_PROPERTY_UNAVAILABLE;
+
+    char *names = hwdec_devices_get_names(mpctx->video_out->hwdec_devs);
+    int res = m_property_strdup_ro(action, arg, names);
+    talloc_free(names);
+    return res;
+}
+
+static int get_frame_count(struct MPContext *mpctx)
+{
+    struct demuxer *demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return -1;
+    if (!mpctx->vo_chain)
+        return -1;
+    double len = get_time_length(mpctx);
+    double fps = mpctx->vo_chain->filter->container_fps;
+    if (len < 0 || fps <= 0)
+        return 0;
+
+    return len * fps;
+}
+
+static int mp_property_frame_number(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int frames = get_frame_count(mpctx);
+    if (frames < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg,
+        lrint(get_current_pos_ratio(mpctx, false) * frames));
+}
+
+static int mp_property_frame_count(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int frames = get_frame_count(mpctx);
+    if (frames < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_int_ro(action, arg, frames);
+}
+
+/// Video codec tag (RO)
+static int mp_property_video_format(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+    const char *c = track && track->stream ? track->stream->codec->codec : NULL;
+    return m_property_strdup_ro(action, arg, c);
+}
+
+/// Video codec name (RO)
+static int mp_property_video_codec(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+    char desc[256] = "";
+    if (track && track->dec)
+        mp_decoder_wrapper_get_desc(track->dec, desc, sizeof(desc));
+    return m_property_strdup_ro(action, arg, desc[0] ? desc : NULL);
+}
+
+static const char *get_aspect_ratio_name(double ratio)
+{
+    // Depending on cropping/mastering exact ratio may differ.
+#define RATIO_THRESH 0.025
+#define RATIO_CASE(ref, name)                     \
+    if (fabs(ratio - (ref)) < RATIO_THRESH)       \
+        return name;                              \
+
+    // https://en.wikipedia.org/wiki/Aspect_ratio_(image)
+    RATIO_CASE(9.0 / 16.0, "Vertical")
+    RATIO_CASE(1.0, "Square");
+    RATIO_CASE(19.0 / 16.0, "Movietone Ratio");
+    RATIO_CASE(5.0 / 4.0, "5:4");
+    RATIO_CASE(4.0 / 3.0, "4:3");
+    RATIO_CASE(11.0 / 8.0, "Academy Ratio");
+    RATIO_CASE(1.43, "IMAX Ratio");
+    RATIO_CASE(3.0 / 2.0, "VistaVision Ratio");
+    RATIO_CASE(16.0 / 10.0, "16:10");
+    RATIO_CASE(5.0 / 3.0, "35mm Widescreen Ratio");
+    RATIO_CASE(16.0 / 9.0, "16:9");
+    RATIO_CASE(7.0 / 4.0, "Early 35mm Widescreen Ratio");
+    RATIO_CASE(1.85, "Academy Flat");
+    RATIO_CASE(256.0 / 135.0, "SMPTE/DCI Ratio");
+    RATIO_CASE(2.0, "Univisium");
+    RATIO_CASE(2.208, "70mm film");
+    RATIO_CASE(2.35, "Scope");
+    RATIO_CASE(2.39, "Panavision");
+    RATIO_CASE(2.55, "Original CinemaScope");
+    RATIO_CASE(2.59, "Full-frame Cinerama");
+    RATIO_CASE(24.0 / 9.0, "Full-frame Super 16mm");
+    RATIO_CASE(2.76, "Ultra Panavision 70");
+    RATIO_CASE(32.0 / 9.0, "32:9");
+    RATIO_CASE(3.6, "Ultra-WideScreen 3.6");
+    RATIO_CASE(4.0, "Polyvision");
+    RATIO_CASE(12.0, "Circle-Vision 360°");
+
+    return NULL;
+
+#undef RATIO_THRESH
+#undef RATIO_CASE
+}
+
+static int property_imgparams(struct mp_image_params p, int action, void *arg)
+{
+    if (!p.imgfmt)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int d_w, d_h;
+    mp_image_params_get_dsize(&p, &d_w, &d_h);
+
+    struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(p.imgfmt);
+    int bpp = 0;
+    for (int i = 0; i < desc.num_planes; i++)
+        bpp += desc.bpp[i] >> (desc.xs[i] + desc.ys[i]);
+
+    // Alpha type is not supported by FFmpeg, so MP_ALPHA_AUTO may mean alpha
+    // is of an unknown type, or simply not present. Normalize to AUTO=no alpha.
+    if (!!(desc.flags & MP_IMGFLAG_ALPHA) != (p.alpha != MP_ALPHA_AUTO)) {
+        p.alpha =
+            (desc.flags & MP_IMGFLAG_ALPHA) ? MP_ALPHA_STRAIGHT : MP_ALPHA_AUTO;
+    }
+
+    const struct pl_hdr_metadata *hdr = &p.color.hdr;
+    bool has_cie_y     = pl_hdr_metadata_contains(hdr, PL_HDR_METADATA_CIE_Y);
+    bool has_hdr10     = pl_hdr_metadata_contains(hdr, PL_HDR_METADATA_HDR10);
+    bool has_hdr10plus = pl_hdr_metadata_contains(hdr, PL_HDR_METADATA_HDR10PLUS);
+
+    bool has_crop = mp_rect_w(p.crop) > 0 && mp_rect_h(p.crop) > 0;
+    const char *aspect_name = get_aspect_ratio_name(d_w / (double)d_h);
+    const char *sar_name = get_aspect_ratio_name(p.w / (double)p.h);
+    struct m_sub_property props[] = {
+        {"pixelformat",     SUB_PROP_STR(mp_imgfmt_to_name(p.imgfmt))},
+        {"hw-pixelformat",  SUB_PROP_STR(mp_imgfmt_to_name(p.hw_subfmt)),
+                            .unavailable = !p.hw_subfmt},
+        {"average-bpp",     SUB_PROP_INT(bpp),
+                            .unavailable = !bpp},
+        {"w",               SUB_PROP_INT(p.w)},
+        {"h",               SUB_PROP_INT(p.h)},
+        {"dw",              SUB_PROP_INT(d_w)},
+        {"dh",              SUB_PROP_INT(d_h)},
+        {"crop-x",          SUB_PROP_INT(p.crop.x0), .unavailable = !has_crop},
+        {"crop-y",          SUB_PROP_INT(p.crop.y0), .unavailable = !has_crop},
+        {"crop-w",          SUB_PROP_INT(mp_rect_w(p.crop)), .unavailable = !has_crop},
+        {"crop-h",          SUB_PROP_INT(mp_rect_h(p.crop)), .unavailable = !has_crop},
+        {"aspect",          SUB_PROP_FLOAT(d_w / (double)d_h)},
+        {"aspect-name",     SUB_PROP_STR(aspect_name), .unavailable = !aspect_name},
+        {"par",             SUB_PROP_FLOAT(p.p_w / (double)p.p_h)},
+        {"sar",             SUB_PROP_FLOAT(p.w / (double)p.h)},
+        {"sar-name",        SUB_PROP_STR(sar_name), .unavailable = !sar_name},
+        {"colormatrix",
+            SUB_PROP_STR(m_opt_choice_str(mp_csp_names, p.color.space))},
+        {"colorlevels",
+            SUB_PROP_STR(m_opt_choice_str(mp_csp_levels_names, p.color.levels))},
+        {"primaries",
+            SUB_PROP_STR(m_opt_choice_str(mp_csp_prim_names, p.color.primaries))},
+        {"gamma",
+            SUB_PROP_STR(m_opt_choice_str(mp_csp_trc_names, p.color.gamma))},
+        {"sig-peak", SUB_PROP_FLOAT(p.color.hdr.max_luma / MP_REF_WHITE)},
+        {"light",
+            SUB_PROP_STR(m_opt_choice_str(mp_csp_light_names, p.color.light))},
+        {"chroma-location",
+            SUB_PROP_STR(m_opt_choice_str(mp_chroma_names, p.chroma_location))},
+        {"stereo-in",
+            SUB_PROP_STR(m_opt_choice_str(mp_stereo3d_names, p.stereo3d))},
+        {"rotate",          SUB_PROP_INT(p.rotate)},
+        {"alpha",
+            SUB_PROP_STR(m_opt_choice_str(mp_alpha_names, p.alpha)),
+            // avoid using "auto" for "no", so just make it unavailable
+            .unavailable = p.alpha == MP_ALPHA_AUTO},
+        {"min-luma",    SUB_PROP_FLOAT(hdr->min_luma),     .unavailable = !has_hdr10},
+        {"max-luma",    SUB_PROP_FLOAT(hdr->max_luma),     .unavailable = !has_hdr10},
+        {"max-cll",     SUB_PROP_FLOAT(hdr->max_cll),      .unavailable = !has_hdr10},
+        {"max-fall",    SUB_PROP_FLOAT(hdr->max_fall),     .unavailable = !has_hdr10},
+        {"scene-max-r", SUB_PROP_FLOAT(hdr->scene_max[0]), .unavailable = !has_hdr10plus},
+        {"scene-max-g", SUB_PROP_FLOAT(hdr->scene_max[1]), .unavailable = !has_hdr10plus},
+        {"scene-max-b", SUB_PROP_FLOAT(hdr->scene_max[2]), .unavailable = !has_hdr10plus},
+        {"scene-avg",   SUB_PROP_FLOAT(hdr->scene_avg),    .unavailable = !has_hdr10plus},
+        {"max-pq-y",    SUB_PROP_FLOAT(hdr->max_pq_y),     .unavailable = !has_cie_y},
+        {"avg-pq-y",    SUB_PROP_FLOAT(hdr->avg_pq_y),     .unavailable = !has_cie_y},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static struct mp_image_params get_video_out_params(struct MPContext *mpctx)
+{
+    if (!mpctx->vo_chain)
+        return (struct mp_image_params){0};
+
+    struct mp_image_params o_params = mpctx->vo_chain->filter->output_params;
+    if (mpctx->video_out) {
+        struct m_geometry *gm = &mpctx->video_out->opts->video_crop;
+        if (gm->xy_valid || (gm->wh_valid && (gm->w > 0 || gm->h > 0)))
+        {
+            m_rect_apply(&o_params.crop, o_params.w, o_params.h, gm);
+        }
+    }
+
+    return o_params;
+}
+
+static int mp_property_vo_imgparams(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int valid = m_property_read_sub_validate(ctx, prop, action, arg);
+    if (valid != M_PROPERTY_VALID)
+        return valid;
+
+    return property_imgparams(vo_get_current_params(vo), action, arg);
+}
+
+static int mp_property_dec_imgparams(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct mp_image_params p = {0};
+    struct vo_chain *vo_c = mpctx->vo_chain;
+    if (!vo_c || !vo_c->track)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int valid = m_property_read_sub_validate(ctx, prop, action, arg);
+    if (valid != M_PROPERTY_VALID)
+        return valid;
+
+    mp_decoder_wrapper_get_video_dec_params(vo_c->track->dec, &p);
+    if (!p.imgfmt)
+        return M_PROPERTY_UNAVAILABLE;
+    return property_imgparams(p, action, arg);
+}
+
+static int mp_property_vd_imgparams(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo_chain *vo_c = mpctx->vo_chain;
+    if (!vo_c)
+        return M_PROPERTY_UNAVAILABLE;
+    struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+    struct mp_codec_params *c =
+        track && track->stream ? track->stream->codec : NULL;
+    if (vo_c->filter->input_params.imgfmt) {
+        return property_imgparams(vo_c->filter->input_params, action, arg);
+    } else if (c && c->disp_w && c->disp_h) {
+        // Simplistic fallback for stupid scripts querying "width"/"height"
+        // before the first frame is decoded.
+        struct m_sub_property props[] = {
+            {"w", SUB_PROP_INT(c->disp_w)},
+            {"h", SUB_PROP_INT(c->disp_h)},
+            {0}
+        };
+        return m_property_read_sub(props, action, arg);
+    }
+    return M_PROPERTY_UNAVAILABLE;
+}
+
+static int mp_property_video_frame_info(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->video_out)
+        return M_PROPERTY_UNAVAILABLE;
+
+    int valid = m_property_read_sub_validate(ctx, prop, action, arg);
+    if (valid != M_PROPERTY_VALID)
+        return valid;
+
+    struct mp_image *f = vo_get_current_frame(mpctx->video_out);
+    if (!f)
+        return M_PROPERTY_UNAVAILABLE;
+
+    const char *pict_types[] = {0, "I", "P", "B"};
+    const char *pict_type = f->pict_type >= 1 && f->pict_type <= 3
+                          ? pict_types[f->pict_type] : NULL;
+
+    struct m_sub_property props[] = {
+        {"picture-type",    SUB_PROP_STR(pict_type), .unavailable = !pict_type},
+        {"interlaced",      SUB_PROP_BOOL(!!(f->fields & MP_IMGFIELD_INTERLACED))},
+        {"tff",             SUB_PROP_BOOL(!!(f->fields & MP_IMGFIELD_TOP_FIRST))},
+        {"repeat",          SUB_PROP_BOOL(!!(f->fields & MP_IMGFIELD_REPEAT_FIRST))},
+        {0}
+    };
+
+    talloc_free(f);
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_current_window_scale(void *ctx, struct m_property *prop,
+                                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct mp_image_params params = get_video_out_params(mpctx);
+    int vid_w, vid_h;
+    mp_image_params_get_dsize(&params, &vid_w, &vid_h);
+    if (vid_w < 1 || vid_h < 1)
+        return M_PROPERTY_UNAVAILABLE;
+
+    if (params.rotate % 180 == 90 && (vo->driver->caps & VO_CAP_ROTATE90))
+        MPSWAP(int, vid_w, vid_h);
+
+    if (vo->monitor_par < 1) {
+        vid_h = MPCLAMP(vid_h / vo->monitor_par, 1, 16000);
+    } else {
+        vid_w = MPCLAMP(vid_w * vo->monitor_par, 1, 16000);
+    }
+
+    if (action == M_PROPERTY_SET) {
+        // Also called by update_window_scale as a NULL property.
+        double scale = *(double *)arg;
+        int s[2] = {vid_w * scale, vid_h * scale};
+        if (s[0] <= 0 || s[1] <= 0)
+            return M_PROPERTY_INVALID_FORMAT;
+        vo_control(vo, VOCTRL_SET_UNFS_WINDOW_SIZE, s);
+        return M_PROPERTY_OK;
+    }
+
+    int s[2];
+    if (vo_control(vo, VOCTRL_GET_UNFS_WINDOW_SIZE, s) <= 0 ||
+        s[0] < 1 || s[1] < 1)
+        return M_PROPERTY_UNAVAILABLE;
+
+    double xs = (double)s[0] / vid_w;
+    double ys = (double)s[1] / vid_h;
+    return m_property_double_ro(action, arg, (xs + ys) / 2);
+}
+
+static void update_window_scale(struct MPContext *mpctx)
+{
+    double scale = mpctx->opts->vo->window_scale;
+    mp_property_current_window_scale(mpctx, (struct m_property *)NULL,
+                                     M_PROPERTY_SET, (void*)&scale);
+}
+
+static int mp_property_display_fps(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    double fps = mpctx->video_out ? vo_get_display_fps(mpctx->video_out) : 0;
+    switch (action) {
+    case M_PROPERTY_GET:
+        if (fps <= 0)
+            return M_PROPERTY_UNAVAILABLE;
+        return m_property_double_ro(action, arg, fps);
+    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;
+}
+
+static int mp_property_estimated_display_fps(void *ctx, struct m_property *prop,
+                                             int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+    double interval = vo_get_estimated_vsync_interval(vo) / 1e9;
+    if (interval <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, 1.0 / interval);
+}
+
+static int mp_property_vsync_jitter(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+    double stddev = vo_get_estimated_vsync_jitter(vo);
+    if (stddev < 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, stddev);
+}
+
+static int mp_property_display_resolution(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+    int res[2];
+    if (vo_control(vo, VOCTRL_GET_DISPLAY_RES, &res) <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    if (strcmp(prop->name, "display-width") == 0) {
+        return m_property_int_ro(action, arg, res[0]);
+    } else {
+        return m_property_int_ro(action, arg, res[1]);
+    }
+}
+
+static int mp_property_hidpi_scale(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+    if (!cmd->cached_window_scale) {
+        double scale = 0;
+        if (vo_control(vo, VOCTRL_GET_HIDPI_SCALE, &scale) < 1 || !scale)
+            scale = -1;
+        cmd->cached_window_scale = scale;
+    }
+    if (cmd->cached_window_scale < 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, cmd->cached_window_scale);
+}
+
+static int mp_property_focused(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+
+    bool focused;
+    if (vo_control(vo, VOCTRL_GET_FOCUSED, &focused) < 1)
+        return M_PROPERTY_UNAVAILABLE;
+
+    return m_property_bool_ro(action, arg, focused);
+}
+
+static int mp_property_display_names(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct vo *vo = mpctx->video_out;
+    if (!vo)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET: {
+        char** display_names;
+        if (vo_control(vo, VOCTRL_GET_DISPLAY_NAMES, &display_names) < 1)
+            return M_PROPERTY_UNAVAILABLE;
+
+        *(char ***)arg = display_names;
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_vo_configured(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_bool_ro(action, arg,
+                        mpctx->video_out && mpctx->video_out->config_ok);
+}
+
+static void get_frame_perf(struct mpv_node *node, struct mp_frame_perf *perf)
+{
+    for (int i = 0; i < perf->count; i++) {
+        struct mp_pass_perf *data = &perf->perf[i];
+        struct mpv_node *pass = node_array_add(node, MPV_FORMAT_NODE_MAP);
+
+        node_map_add_string(pass, "desc", perf->desc[i]);
+        node_map_add(pass, "last", MPV_FORMAT_INT64)->u.int64 = data->last;
+        node_map_add(pass, "avg", MPV_FORMAT_INT64)->u.int64 = data->avg;
+        node_map_add(pass, "peak", MPV_FORMAT_INT64)->u.int64 = data->peak;
+        node_map_add(pass, "count", MPV_FORMAT_INT64)->u.int64 = data->count;
+        struct mpv_node *samples = node_map_add(pass, "samples", MPV_FORMAT_NODE_ARRAY);
+        for (int n = 0; n < data->count; n++)
+            node_array_add(samples, MPV_FORMAT_INT64)->u.int64 = data->samples[n];
+    }
+}
+
+static char *asprint_perf(char *res, struct mp_frame_perf *perf)
+{
+    for (int i = 0; i < perf->count; i++) {
+        struct mp_pass_perf *pass = &perf->perf[i];
+        res = talloc_asprintf_append(res,
+                  "- %s: last %dus avg %dus peak %dus\n", perf->desc[i],
+                  (int)pass->last/1000, (int)pass->avg/1000, (int)pass->peak/1000);
+    }
+
+    return res;
+}
+
+static int mp_property_vo_passes(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->video_out)
+        return M_PROPERTY_UNAVAILABLE;
+
+    // Return early, to avoid having to go through a completely unnecessary VOCTRL
+    switch (action) {
+    case M_PROPERTY_PRINT:
+    case M_PROPERTY_GET:
+        break;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
+        return M_PROPERTY_OK;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+
+    struct voctrl_performance_data *data = talloc_ptrtype(NULL, data);
+    if (vo_control(mpctx->video_out, VOCTRL_PERFORMANCE_DATA, data) <= 0) {
+        talloc_free(data);
+        return M_PROPERTY_UNAVAILABLE;
+    }
+
+    switch (action) {
+    case M_PROPERTY_PRINT: {
+        char *res = NULL;
+        res = talloc_asprintf_append(res, "fresh:\n");
+        res = asprint_perf(res, &data->fresh);
+        res = talloc_asprintf_append(res, "\nredraw:\n");
+        res = asprint_perf(res, &data->redraw);
+        *(char **)arg = res;
+        break;
+    }
+
+    case M_PROPERTY_GET: {
+        struct mpv_node node;
+        node_init(&node, MPV_FORMAT_NODE_MAP, NULL);
+        struct mpv_node *fresh = node_map_add(&node, "fresh", MPV_FORMAT_NODE_ARRAY);
+        struct mpv_node *redraw = node_map_add(&node, "redraw", MPV_FORMAT_NODE_ARRAY);
+        get_frame_perf(fresh, &data->fresh);
+        get_frame_perf(redraw, &data->redraw);
+        *(struct mpv_node *)arg = node;
+        break;
+    }
+    }
+
+    talloc_free(data);
+    return M_PROPERTY_OK;
+}
+
+static int mp_property_perf_info(void *ctx, struct m_property *p, int action,
+                                 void *arg)
+{
+    MPContext *mpctx = ctx;
+
+    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: {
+        stats_global_query(mpctx->global, (struct mpv_node *)arg);
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_vo(void *ctx, struct m_property *p, int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return m_property_strdup_ro(action, arg,
+                    mpctx->video_out ? mpctx->video_out->driver->name : NULL);
+}
+
+static int mp_property_osd_dim(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct mp_osd_res vo_res = osd_get_vo_res(mpctx->osd);
+
+    if (!mpctx->video_out || !mpctx->video_out->config_ok)
+        vo_res = (struct mp_osd_res){0};
+
+    double aspect = 1.0 * vo_res.w / MPMAX(vo_res.h, 1) /
+                    (vo_res.display_par ? vo_res.display_par : 1);
+
+    struct m_sub_property props[] = {
+        {"w",       SUB_PROP_INT(vo_res.w)},
+        {"h",       SUB_PROP_INT(vo_res.h)},
+        {"par",     SUB_PROP_DOUBLE(vo_res.display_par)},
+        {"aspect",  SUB_PROP_DOUBLE(aspect)},
+        {"mt",      SUB_PROP_INT(vo_res.mt)},
+        {"mb",      SUB_PROP_INT(vo_res.mb)},
+        {"ml",      SUB_PROP_INT(vo_res.ml)},
+        {"mr",      SUB_PROP_INT(vo_res.mr)},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_osd_sym(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    char temp[20];
+    get_current_osd_sym(mpctx, temp, sizeof(temp));
+    return m_property_strdup_ro(action, arg, temp);
+}
+
+static int mp_property_osd_ass(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    struct m_sub_property props[] = {
+        {"0",   SUB_PROP_STR(OSD_ASS_0)},
+        {"1",   SUB_PROP_STR(OSD_ASS_1)},
+        {0}
+    };
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_mouse_pos(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+
+    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;
+        int x, y, hover;
+        mp_input_get_mouse_pos(mpctx->input, &x, &y, &hover);
+
+        node_init(&node, MPV_FORMAT_NODE_MAP, NULL);
+        node_map_add_int64(&node, "x", x);
+        node_map_add_int64(&node, "y", y);
+        node_map_add_flag(&node, "hover", hover);
+        *(struct mpv_node *)arg = node;
+
+        return M_PROPERTY_OK;
+    }
+    }
+
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+/// Video fps (RO)
+static int mp_property_fps(void *ctx, struct m_property *prop,
+                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    float fps = mpctx->vo_chain ? mpctx->vo_chain->filter->container_fps : 0;
+    if (fps < 0.1 || !isfinite(fps))
+        return M_PROPERTY_UNAVAILABLE;;
+    return m_property_float_ro(action, arg, fps);
+}
+
+static int mp_property_vf_fps(void *ctx, struct m_property *prop,
+                              int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->vo_chain)
+        return M_PROPERTY_UNAVAILABLE;
+    double avg = calc_average_frame_duration(mpctx);
+    if (avg <= 0)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, 1.0 / avg);
+}
+
+#define doubles_equal(x, y) (fabs((x) - (y)) <= 0.001)
+
+static int mp_property_video_aspect_override(void *ctx, struct m_property *prop,
+                                             int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_PRINT) {
+        double aspect_ratio;
+        mp_property_generic_option(mpctx, prop, M_PROPERTY_GET, &aspect_ratio);
+
+        if (doubles_equal(aspect_ratio, 2.35 / 1.0))
+            *(char **)arg = talloc_asprintf(NULL, "2.35:1");
+        else if (doubles_equal(aspect_ratio, 16.0 / 9.0))
+            *(char **)arg = talloc_asprintf(NULL, "16:9");
+        else if (doubles_equal(aspect_ratio, 16.0 / 10.0))
+            *(char **)arg = talloc_asprintf(NULL, "16:10");
+        else if (doubles_equal(aspect_ratio, 4.0 / 3.0))
+            *(char **)arg = talloc_asprintf(NULL, "4:3");
+        else if (doubles_equal(aspect_ratio, -1.0))
+            *(char **)arg = talloc_asprintf(NULL, "Original");
+        else
+            *(char **)arg = talloc_asprintf(NULL, "%.3f", aspect_ratio);
+
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+/// Subtitle delay (RW)
+static int mp_property_sub_delay(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct MPOpts *opts = mpctx->opts;
+    switch (action) {
+    case M_PROPERTY_PRINT:
+        *(char **)arg = format_delay(opts->subs_rend->sub_delay);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+/// Subtitle speed (RW)
+static int mp_property_sub_speed(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct MPOpts *opts = mpctx->opts;
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg =
+            talloc_asprintf(NULL, "%4.1f%%", 100 * opts->subs_rend->sub_speed);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_sub_pos(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct MPOpts *opts = mpctx->opts;
+    if (action == M_PROPERTY_PRINT) {
+        *(char **)arg = talloc_asprintf(NULL, "%4.2f%%/100", opts->subs_rend->sub_pos);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_sub_ass_extradata(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[0][STREAM_SUB];
+    struct dec_sub *sub = track ? track->d_sub : NULL;
+    if (!sub)
+        return M_PROPERTY_UNAVAILABLE;
+    switch (action) {
+    case M_PROPERTY_GET: {
+        char *data = sub_ass_get_extradata(sub);
+        if (!data)
+            return M_PROPERTY_UNAVAILABLE;
+        *(char **)arg = data;
+        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;
+}
+
+static int get_sub_text(void *ctx, struct m_property *prop,
+                        int action, void *arg, int sub_index)
+{
+    int type = *(int *)prop->priv;
+    MPContext *mpctx = ctx;
+    struct track *track = mpctx->current_track[sub_index][STREAM_SUB];
+    struct dec_sub *sub = track ? track->d_sub : NULL;
+    double pts = mpctx->playback_pts;
+    if (!sub || pts == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
+    case M_PROPERTY_GET: {
+        char *text = sub_get_text(sub, pts, type);
+        if (!text)
+            text = talloc_strdup(NULL, "");
+        *(char **)arg = text;
+        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;
+}
+
+static int mp_property_sub_text(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    return get_sub_text(ctx, prop, action, arg, 0);
+}
+
+static int mp_property_secondary_sub_text(void *ctx, struct m_property *prop,
+                                          int action, void *arg)
+{
+    return get_sub_text(ctx, prop, action, arg, 1);
+}
+
+static struct sd_times get_times(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    struct sd_times res = { .start = MP_NOPTS_VALUE, .end = MP_NOPTS_VALUE };
+    MPContext *mpctx = ctx;
+    int track_ind = *(int *)prop->priv;
+    struct track *track = mpctx->current_track[track_ind][STREAM_SUB];
+    struct dec_sub *sub = track ? track->d_sub : NULL;
+    double pts = mpctx->playback_pts;
+    if (!sub || pts == MP_NOPTS_VALUE)
+        return res;
+    return sub_get_times(sub, pts);
+}
+
+static int mp_property_sub_start(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    double start = get_times(ctx, prop, action, arg).start;
+    if (start == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, start);
+}
+
+
+static int mp_property_sub_end(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    double end = get_times(ctx, prop, action, arg).end;
+    if (end == MP_NOPTS_VALUE)
+        return M_PROPERTY_UNAVAILABLE;
+    return m_property_double_ro(action, arg, end);
+}
+
+static int mp_property_playlist_current_pos(void *ctx, struct m_property *prop,
+                                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct playlist *pl = mpctx->playlist;
+
+    switch (action) {
+    case M_PROPERTY_GET: {
+        *(int *)arg = playlist_entry_to_index(pl, pl->current);
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_SET: {
+        pl->current = playlist_entry_from_index(pl, *(int *)arg);
+        mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+        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;
+}
+
+
+static int mp_property_playlist_playing_pos(void *ctx, struct m_property *prop,
+                                            int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct playlist *pl = mpctx->playlist;
+    return m_property_int_ro(action, arg,
+                             playlist_entry_to_index(pl, mpctx->playing));
+}
+
+static int mp_property_playlist_pos_x(void *ctx, struct m_property *prop,
+                                      int action, void *arg, int base)
+{
+    MPContext *mpctx = ctx;
+    struct playlist *pl = mpctx->playlist;
+
+    switch (action) {
+    case M_PROPERTY_GET: {
+        int pos = playlist_entry_to_index(pl, pl->current);
+        *(int *)arg = pos < 0 ? -1 : pos + base;
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_SET: {
+        int pos = *(int *)arg - base;
+        if (pos >= 0 && playlist_entry_to_index(pl, pl->current) == pos)
+            return M_PROPERTY_OK;
+        mp_set_playlist_entry(mpctx, playlist_entry_from_index(pl, pos));
+        return M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_INT};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_CONSTRICTED_TYPE: {
+        struct m_option opt = {
+            .type = CONF_TYPE_INT,
+            .min = base,
+            .max = playlist_entry_count(pl) - 1 + base,
+        };
+        *(struct m_option *)arg = opt;
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_playlist_pos(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    return mp_property_playlist_pos_x(ctx, prop, action, arg, 0);
+}
+
+static int mp_property_playlist_pos_1(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    return mp_property_playlist_pos_x(ctx, prop, action, arg, 1);
+}
+
+static int get_playlist_entry(int item, int action, void *arg, void *ctx)
+{
+    struct MPContext *mpctx = ctx;
+
+    struct playlist_entry *e = playlist_entry_from_index(mpctx->playlist, item);
+    if (!e)
+        return M_PROPERTY_ERROR;
+
+    bool current = mpctx->playlist->current == e;
+    bool playing = mpctx->playing == e;
+    struct m_sub_property props[] = {
+        {"filename",      SUB_PROP_STR(e->filename)},
+        {"current",       SUB_PROP_BOOL(1), .unavailable = !current},
+        {"playing",       SUB_PROP_BOOL(1), .unavailable = !playing},
+        {"title",         SUB_PROP_STR(e->title), .unavailable = !e->title},
+        {"id",            SUB_PROP_INT64(e->id)},
+        {"playlist-path", SUB_PROP_STR(e->playlist_path), .unavailable = !e->playlist_path},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_playlist_path(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (!mpctx->playlist->current)
+        return M_PROPERTY_UNAVAILABLE;
+
+    struct playlist_entry *e = mpctx->playlist->current;
+    return m_property_strdup_ro(action, arg, e->playlist_path);
+}
+
+static int mp_property_playlist(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_PRINT) {
+        struct playlist *pl = mpctx->playlist;
+        char *res = talloc_strdup(NULL, "");
+
+        for (int n = 0; n < pl->num_entries; n++) {
+            struct playlist_entry *e = pl->entries[n];
+            char *p = e->title;
+            if (!p) {
+                p = e->filename;
+                if (!mp_is_url(bstr0(p))) {
+                    char *s = mp_basename(e->filename);
+                    if (s[0])
+                        p = s;
+                }
+            }
+            const char *m = pl->current == e ? list_current : list_normal;
+            res = talloc_asprintf_append(res, "%s%s\n", m, p);
+        }
+
+        *(char **)arg =
+            cut_osd_list(mpctx, res, playlist_entry_to_index(pl, pl->current));
+        return M_PROPERTY_OK;
+    }
+
+    return m_property_read_list(action, arg, playlist_entry_count(mpctx->playlist),
+                                get_playlist_entry, mpctx);
+}
+
+static char *print_obj_osd_list(struct m_obj_settings *list)
+{
+    char *res = NULL;
+    for (int n = 0; list && list[n].name; n++) {
+        res = talloc_asprintf_append(res, "%s [", list[n].name);
+        for (int i = 0; list[n].attribs && list[n].attribs[i]; i += 2) {
+            res = talloc_asprintf_append(res, "%s%s=%s", i > 0 ? " " : "",
+                                         list[n].attribs[i],
+                                         list[n].attribs[i + 1]);
+        }
+        res = talloc_asprintf_append(res, "]");
+        if (!list[n].enabled)
+            res = talloc_strdup_append(res, " (disabled)");
+        res = talloc_strdup_append(res, "\n");
+    }
+    if (!res)
+        res = talloc_strdup(NULL, "(empty)");
+    return res;
+}
+
+static int property_filter(struct m_property *prop, int action, void *arg,
+                           MPContext *mpctx, enum stream_type mt)
+{
+    if (action == M_PROPERTY_PRINT) {
+        struct m_config_option *opt = m_config_get_co(mpctx->mconfig,
+                                                      bstr0(prop->name));
+        *(char **)arg = print_obj_osd_list(*(struct m_obj_settings **)opt->data);
+        return M_PROPERTY_OK;
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_vf(void *ctx, struct m_property *prop,
+                          int action, void *arg)
+{
+    return property_filter(prop, action, arg, ctx, STREAM_VIDEO);
+}
+
+static int mp_property_af(void *ctx, struct m_property *prop,
+                          int action, void *arg)
+{
+    return property_filter(prop, action, arg, ctx, STREAM_AUDIO);
+}
+
+static int mp_property_ab_loop(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    struct MPContext *mpctx = ctx;
+    if (action == M_PROPERTY_KEY_ACTION) {
+        double val;
+        if (mp_property_generic_option(mpctx, prop, M_PROPERTY_GET, &val) < 1)
+            return M_PROPERTY_ERROR;
+
+        return property_time(action, arg, val);
+    }
+    return mp_property_generic_option(mpctx, prop, action, arg);
+}
+
+static int mp_property_packet_bitrate(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    int type = (uintptr_t)prop->priv & ~0x100;
+    bool old = (uintptr_t)prop->priv & 0x100;
+
+    struct demuxer *demuxer = NULL;
+    if (mpctx->current_track[0][type])
+        demuxer = mpctx->current_track[0][type]->demuxer;
+    if (!demuxer)
+        demuxer = mpctx->demuxer;
+    if (!demuxer)
+        return M_PROPERTY_UNAVAILABLE;
+
+    double r[STREAM_TYPE_COUNT];
+    demux_get_bitrate_stats(demuxer, r);
+    if (r[type] < 0)
+        return M_PROPERTY_UNAVAILABLE;
+
+    // r[type] is in bytes/second -> bits
+    double rate = r[type] * 8;
+
+    // Same story, but used kilobits for some reason.
+    if (old)
+        return m_property_int64_ro(action, arg, llrint(rate / 1000.0));
+
+    if (action == M_PROPERTY_PRINT) {
+        rate /= 1000;
+        if (rate < 1000) {
+            *(char **)arg = talloc_asprintf(NULL, "%d kbps", (int)rate);
+        } else {
+            *(char **)arg = talloc_asprintf(NULL, "%.3f mbps", rate / 1000.0);
+        }
+        return M_PROPERTY_OK;
+    }
+    return m_property_int64_ro(action, arg, llrint(rate));
+}
+
+static int mp_property_cwd(void *ctx, struct m_property *prop,
+                           int action, void *arg)
+{
+    switch (action) {
+    case M_PROPERTY_GET: {
+        char *cwd = mp_getcwd(NULL);
+        if (!cwd)
+            return M_PROPERTY_ERROR;
+        *(char **)arg = cwd;
+        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;
+}
+
+static int mp_property_protocols(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(char ***)arg = stream_get_proto_list();
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_keylist(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(char ***)arg = mp_get_key_list();
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int get_decoder_entry(int item, int action, void *arg, void *ctx)
+{
+    struct mp_decoder_list *codecs = ctx;
+    struct mp_decoder_entry *c = &codecs->entries[item];
+
+    struct m_sub_property props[] = {
+        {"codec",       SUB_PROP_STR(c->codec)},
+        {"driver" ,     SUB_PROP_STR(c->decoder)},
+        {"description", SUB_PROP_STR(c->desc)},
+        {0}
+    };
+
+    return m_property_read_sub(props, action, arg);
+}
+
+static int mp_property_decoders(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    struct mp_decoder_list *codecs = talloc_zero(NULL, struct mp_decoder_list);
+    struct mp_decoder_list *v = talloc_steal(codecs, video_decoder_list());
+    struct mp_decoder_list *a = talloc_steal(codecs, audio_decoder_list());
+    mp_append_decoders(codecs, v);
+    mp_append_decoders(codecs, a);
+    int r = m_property_read_list(action, arg, codecs->num_entries,
+                                 get_decoder_entry, codecs);
+    talloc_free(codecs);
+    return r;
+}
+
+static int mp_property_encoders(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    struct mp_decoder_list *codecs = talloc_zero(NULL, struct mp_decoder_list);
+    mp_add_lavc_encoders(codecs);
+    int r = m_property_read_list(action, arg, codecs->num_entries,
+                                 get_decoder_entry, codecs);
+    talloc_free(codecs);
+    return r;
+}
+
+static int mp_property_lavf_demuxers(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(char ***)arg = mp_get_lavf_demuxers();
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_version(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    return m_property_strdup_ro(action, arg, mpv_version);
+}
+
+static int mp_property_configuration(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    return m_property_strdup_ro(action, arg, CONFIGURATION);
+}
+
+static int mp_property_ffmpeg(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    return m_property_strdup_ro(action, arg, av_version_info());
+}
+
+static int mp_property_libass_version(void *ctx, struct m_property *prop,
+                                      int action, void *arg)
+{
+    return m_property_int64_ro(action, arg, ass_library_version());
+}
+
+static int mp_property_platform(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    return m_property_strdup_ro(action, arg, PLATFORM);
+}
+
+static int mp_property_alias(void *ctx, struct m_property *prop,
+                             int action, void *arg)
+{
+    const char *real_property = prop->priv;
+    return mp_property_do(real_property, action, arg, ctx);
+}
+
+static int mp_property_deprecated_alias(void *ctx, struct m_property *prop,
+                                        int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+    const char *real_property = prop->priv;
+    for (int n = 0; n < cmd->num_warned_deprecated; n++) {
+        if (strcmp(cmd->warned_deprecated[n], prop->name) == 0)
+            goto done;
+    }
+    MP_WARN(mpctx, "Warning: property '%s' was replaced with '%s' and "
+            "might be removed in the future.\n", prop->name, real_property);
+    MP_TARRAY_APPEND(cmd, cmd->warned_deprecated, cmd->num_warned_deprecated,
+                     (char *)prop->name);
+
+done:
+    return mp_property_do(real_property, action, arg, ctx);
+}
+
+static int access_options(struct m_property_action_arg *ka, bool local,
+                          MPContext *mpctx)
+{
+    struct m_config_option *opt = m_config_get_co(mpctx->mconfig,
+                                                  bstr0(ka->key));
+    if (!opt)
+        return M_PROPERTY_UNKNOWN;
+    if (!opt->data)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch (ka->action) {
+    case M_PROPERTY_GET:
+        m_option_copy(opt->opt, ka->arg, opt->data);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_SET: {
+        if (local && !mpctx->playing)
+            return M_PROPERTY_ERROR;
+        int flags = local ? M_SETOPT_BACKUP : 0;
+        int r = m_config_set_option_raw(mpctx->mconfig, opt, ka->arg, flags);
+        mp_wakeup_core(mpctx);
+        return r < 0 ? M_PROPERTY_ERROR : M_PROPERTY_OK;
+    }
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)ka->arg = *opt->opt;
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int access_option_list(int action, void *arg, bool local, MPContext *mpctx)
+{
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET:
+        *(char ***)arg = m_config_list_options(NULL, mpctx->mconfig);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_KEY_ACTION:
+        return access_options(arg, local, mpctx);
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+
+static int mp_property_options(void *ctx, struct m_property *prop,
+                               int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return access_option_list(action, arg, false, mpctx);
+}
+
+static int mp_property_local_options(void *ctx, struct m_property *prop,
+                                     int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    return access_option_list(action, arg, true, mpctx);
+}
+
+static int mp_property_option_info(void *ctx, struct m_property *prop,
+                                   int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    switch (action) {
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *ka = arg;
+        bstr key;
+        char *rem;
+        m_property_split_path(ka->key, &key, &rem);
+        struct m_config_option *co = m_config_get_co(mpctx->mconfig, key);
+        if (!co)
+            return M_PROPERTY_UNKNOWN;
+        const struct m_option *opt = co->opt;
+
+        union m_option_value def = m_option_value_default;
+        const void *def_ptr = m_config_get_co_default(mpctx->mconfig, co);
+        if (def_ptr && opt->type->size > 0)
+            memcpy(&def, def_ptr, opt->type->size);
+
+        bool has_minmax = opt->min < opt->max &&
+            (opt->type->flags & M_OPT_TYPE_USES_RANGE);
+        char **choices = NULL;
+
+        if (opt->type == &m_option_type_choice) {
+            const struct m_opt_choice_alternatives *alt = opt->priv;
+            int num = 0;
+            for ( ; alt->name; alt++)
+                MP_TARRAY_APPEND(NULL, choices, num, alt->name);
+            MP_TARRAY_APPEND(NULL, choices, num, NULL);
+        }
+        if (opt->type == &m_option_type_obj_settings_list) {
+            const struct m_obj_list *objs = opt->priv;
+            int num = 0;
+            for (int n = 0; ; n++) {
+                struct m_obj_desc desc = {0};
+                if (!objs->get_desc(&desc, n))
+                    break;
+                MP_TARRAY_APPEND(NULL, choices, num, (char *)desc.name);
+            }
+            MP_TARRAY_APPEND(NULL, choices, num, NULL);
+        }
+
+        struct m_sub_property props[] = {
+            {"name",                    SUB_PROP_STR(co->name)},
+            {"type",                    SUB_PROP_STR(opt->type->name)},
+            {"set-from-commandline",    SUB_PROP_BOOL(co->is_set_from_cmdline)},
+            {"set-locally",             SUB_PROP_BOOL(co->is_set_locally)},
+            {"default-value",           *opt, def},
+            {"min",                     SUB_PROP_DOUBLE(opt->min),
+             .unavailable = !(has_minmax && opt->min != DBL_MIN)},
+            {"max",                     SUB_PROP_DOUBLE(opt->max),
+             .unavailable = !(has_minmax && opt->max != DBL_MAX)},
+            {"choices", .type = {.type = CONF_TYPE_STRING_LIST},
+             .value = {.string_list = choices}, .unavailable = !choices},
+            {0}
+        };
+
+        struct m_property_action_arg next_ka = *ka;
+        next_ka.key = rem;
+        int r = m_property_read_sub(props, M_PROPERTY_KEY_ACTION, &next_ka);
+        talloc_free(choices);
+        return r;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_list(void *ctx, struct m_property *prop,
+                            int action, void *arg)
+{
+    struct MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET: {
+        char **list = NULL;
+        int num = 0;
+        for (int n = 0; cmd->properties[n].name; n++) {
+            MP_TARRAY_APPEND(NULL, list, num,
+                                talloc_strdup(NULL, cmd->properties[n].name));
+        }
+        MP_TARRAY_APPEND(NULL, list, num, NULL);
+        *(char ***)arg = list;
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_profile_list(void *ctx, struct m_property *prop,
+                           int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    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 *)arg = m_config_get_profiles(mpctx->mconfig);
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_commands(void *ctx, struct m_property *prop,
+                           int action, void *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 *root = arg;
+        node_init(root, MPV_FORMAT_NODE_ARRAY, NULL);
+
+        for (int n = 0; mp_cmds[n].name; n++) {
+            const struct mp_cmd_def *cmd = &mp_cmds[n];
+            struct mpv_node *entry = node_array_add(root, MPV_FORMAT_NODE_MAP);
+
+            node_map_add_string(entry, "name", cmd->name);
+
+            struct mpv_node *args =
+                node_map_add(entry, "args", MPV_FORMAT_NODE_ARRAY);
+            for (int i = 0; i < MP_CMD_DEF_MAX_ARGS; i++) {
+                const struct m_option *a = &cmd->args[i];
+                if (!a->type)
+                    break;
+                struct mpv_node *ae = node_array_add(args, MPV_FORMAT_NODE_MAP);
+                node_map_add_string(ae, "name", a->name);
+                node_map_add_string(ae, "type", a->type->name);
+                node_map_add_flag(ae, "optional", a->flags & MP_CMD_OPT_ARG);
+            }
+
+            node_map_add_flag(entry, "vararg", cmd->vararg);
+        }
+
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int mp_property_bindings(void *ctx, struct m_property *prop,
+                                int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    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 *)arg = mp_input_get_bindings(mpctx->input);
+        return M_PROPERTY_OK;
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+
+static int mp_property_script_props(void *ctx, struct m_property *prop,
+                                    int action, void *arg)
+{
+    MPContext *mpctx = ctx;
+    struct command_ctx *cmd = mpctx->command_ctx;
+    if (!cmd->shared_script_warning) {
+        MP_WARN(mpctx, "The shared-script-properties property is deprecated and will "
+                "be removed in the future. Use the user-data property instead.\n");
+        cmd->shared_script_warning = true;
+    }
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = script_props_type;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET:
+        m_option_copy(&script_props_type, arg, &cmd->script_props);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_SET:
+        m_option_copy(&script_props_type, &cmd->script_props, arg);
+        mp_notify_property(mpctx, prop->name);
+        return M_PROPERTY_OK;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int do_list_udata(int item, int action, void *arg, void *ctx);
+
+struct udata_ctx {
+    MPContext *mpctx;
+    const char *path;
+    mpv_node *node;
+    void *ta_parent;
+};
+
+static int do_op_udata(struct udata_ctx* ctx, int action, void *arg)
+{
+    MPContext *mpctx = ctx->mpctx;
+    mpv_node *node = ctx->node;
+
+    switch (action) {
+    case M_PROPERTY_GET_TYPE:
+        *(struct m_option *)arg = udata_type;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_GET:
+    case M_PROPERTY_GET_NODE: // same as GET, because type==mpv_node
+        assert(node);
+        m_option_copy(&udata_type, arg, node);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT: {
+        char *str = m_option_pretty_print(&udata_type, node);
+        *(char **)arg = str;
+        return str != NULL;
+    }
+    case M_PROPERTY_SET:
+    case M_PROPERTY_SET_NODE:
+        assert(node);
+        m_option_copy(&udata_type, node, arg);
+        talloc_steal(ctx->ta_parent, node_get_alloc(node));
+        mp_notify_property(mpctx, ctx->path);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_KEY_ACTION: {
+        assert(node);
+
+        // If we're operating on an array, sub-object access is handled by m_property_read_list
+        if (node->format == MPV_FORMAT_NODE_ARRAY)
+            return m_property_read_list(action, arg, node->u.list->num, &do_list_udata, ctx);
+
+        // Sub-objects only make sense for arrays and maps
+        if (node->format != MPV_FORMAT_NODE_MAP)
+            return M_PROPERTY_NOT_IMPLEMENTED;
+
+        struct m_property_action_arg *act = arg;
+
+        // See if the next layer down will also be a sub-object access
+        bstr key;
+        char *rem;
+        bool has_split = m_property_split_path(act->key, &key, &rem);
+
+        if (!has_split && act->action == M_PROPERTY_DELETE) {
+            // Find the object we're looking for
+            int i;
+            for (i = 0; i < node->u.list->num; i++) {
+                if (bstr_equals0(key, node->u.list->keys[i]))
+                    break;
+            }
+
+            // Return if it didn't exist
+            if (i == node->u.list->num)
+                return M_PROPERTY_UNKNOWN;
+
+            // Delete the item
+            m_option_free(&udata_type, &node->u.list->values[i]);
+            talloc_free(node->u.list->keys[i]);
+
+            // Shift the remaining items back
+            for (i++; i < node->u.list->num; i++) {
+                node->u.list->values[i - 1] = node->u.list->values[i];
+                node->u.list->keys[i - 1] = node->u.list->keys[i];
+            }
+
+            // And decrement the count
+            node->u.list->num--;
+
+            return M_PROPERTY_OK;
+        }
+
+        // Look up the next level down
+        mpv_node *cnode = node_map_bget(node, key);
+
+        if (!cnode) {
+            switch (act->action) {
+                case M_PROPERTY_SET:
+                case M_PROPERTY_SET_NODE: {
+                    // If we're doing a set, and the key doesn't exist, create it.
+                    // If we're recursing another layer down, make it an empty map;
+                    // otherwise, make it NONE, since we'll be overwriting it at the next level.
+                    cnode = node_map_badd(node, key, has_split ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NONE);
+                    if (!cnode)
+                        return M_PROPERTY_ERROR;
+                    break;
+                case M_PROPERTY_GET_TYPE:
+                    // Nonexistent keys have type NODE, so they can be overwritten
+                    *(struct m_option *)act->arg = udata_type;
+                    return M_PROPERTY_OK;
+                default:
+                    // We can't perform any other options on nonexistent keys
+                    return M_PROPERTY_UNKNOWN;
+                }
+            }
+        }
+
+        struct udata_ctx nctx = *ctx;
+        nctx.node = cnode;
+        nctx.ta_parent = node_get_alloc(node);
+
+        // If we're going down another level, set up a new key-action.
+        if (has_split) {
+            struct m_property_action_arg sub_act = {
+                .key = rem,
+                .action = act->action,
+                .arg = act->arg,
+            };
+
+            return do_op_udata(&nctx, M_PROPERTY_KEY_ACTION, &sub_act);
+        } else {
+            return do_op_udata(&nctx, act->action, act->arg);
+        }
+    }
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+static int do_list_udata(int item, int action, void *arg, void *ctx)
+{
+    struct udata_ctx nctx = *(struct udata_ctx*)ctx;
+    nctx.node = &nctx.node->u.list->values[item];
+    nctx.ta_parent = &nctx.node->u.list;
+
+    return do_op_udata(&nctx, action, arg);
+}
+
+static int mp_property_udata(void *ctx, struct m_property *prop,
+                                 int action, void *arg)
+{
+    // The root of udata is a shared map; don't allow overwriting
+    // or deleting the whole thing
+    if (action == M_PROPERTY_SET || action == M_PROPERTY_SET_NODE ||
+        action == M_PROPERTY_DELETE)
+        return M_PROPERTY_NOT_IMPLEMENTED;
+
+    char *path = NULL;
+    if (action == M_PROPERTY_KEY_ACTION) {
+        struct m_property_action_arg *act = arg;
+        if (act->action == M_PROPERTY_SET || act->action == M_PROPERTY_SET_NODE)
+            path = talloc_asprintf(NULL, "%s/%s", prop->name, act->key);
+    }
+
+    struct MPContext *mpctx = ctx;
+    struct udata_ctx nctx = {
+        .mpctx = mpctx,
+        .path = path,
+        .node = &mpctx->command_ctx->udata,
+        .ta_parent = &mpctx->command_ctx,
+    };
+
+    int ret = do_op_udata(&nctx, action, arg);
+
+    talloc_free(path);
+
+    return ret;
+}
+
+// Redirect a property name to another
+#define M_PROPERTY_ALIAS(name, real_property) \
+    {(name), mp_property_alias, .priv = (real_property)}
+
+#define M_PROPERTY_DEPRECATED_ALIAS(name, real_property) \
+    {(name), mp_property_deprecated_alias, .priv = (real_property)}
+
+// Base list of properties. This does not include option-mapped properties.
+static const struct m_property mp_properties_base[] = {
+    // General
+    {"pid", mp_property_pid},
+    {"speed", mp_property_playback_speed},
+    {"audio-speed-correction", mp_property_av_speed_correction, .priv = "a"},
+    {"video-speed-correction", mp_property_av_speed_correction, .priv = "v"},
+    {"display-sync-active", mp_property_display_sync_active},
+    {"filename", mp_property_filename},
+    {"stream-open-filename", mp_property_stream_open_filename},
+    {"file-size", mp_property_file_size},
+    {"path", mp_property_path},
+    {"media-title", mp_property_media_title},
+    {"stream-path", mp_property_stream_path},
+    {"current-demuxer", mp_property_demuxer},
+    {"file-format", mp_property_file_format},
+    {"stream-pos", mp_property_stream_pos},
+    {"stream-end", mp_property_stream_end},
+    {"duration", mp_property_duration},
+    {"avsync", mp_property_avsync},
+    {"total-avsync-change", mp_property_total_avsync_change},
+    {"mistimed-frame-count", mp_property_mistimed_frame_count},
+    {"vsync-ratio", mp_property_vsync_ratio},
+    {"display-width", mp_property_display_resolution},
+    {"display-height", mp_property_display_resolution},
+    {"decoder-frame-drop-count", mp_property_frame_drop_dec},
+    {"frame-drop-count", mp_property_frame_drop_vo},
+    {"vo-delayed-frame-count", mp_property_vo_delayed_frame_count},
+    {"percent-pos", mp_property_percent_pos},
+    {"time-start", mp_property_time_start},
+    {"time-pos", mp_property_time_pos},
+    {"time-remaining", mp_property_remaining},
+    {"audio-pts", mp_property_audio_pts},
+    {"playtime-remaining", mp_property_playtime_remaining},
+    {"playback-time", mp_property_playback_time},
+    {"chapter", mp_property_chapter},
+    {"edition", mp_property_edition},
+    {"current-edition", mp_property_current_edition},
+    {"chapters", mp_property_chapters},
+    {"editions", mp_property_editions},
+    {"metadata", mp_property_metadata},
+    {"filtered-metadata", mp_property_filtered_metadata},
+    {"chapter-metadata", mp_property_chapter_metadata},
+    {"vf-metadata", mp_property_filter_metadata, .priv = "vf"},
+    {"af-metadata", mp_property_filter_metadata, .priv = "af"},
+    {"core-idle", mp_property_core_idle},
+    {"eof-reached", mp_property_eof_reached},
+    {"seeking", mp_property_seeking},
+    {"playback-abort", mp_property_playback_abort},
+    {"cache-speed", mp_property_cache_speed},
+    {"demuxer-cache-duration", mp_property_demuxer_cache_duration},
+    {"demuxer-cache-time", mp_property_demuxer_cache_time},
+    {"demuxer-cache-idle", mp_property_demuxer_cache_idle},
+    {"demuxer-start-time", mp_property_demuxer_start_time},
+    {"demuxer-cache-state", mp_property_demuxer_cache_state},
+    {"cache-buffering-state", mp_property_cache_buffering},
+    {"paused-for-cache", mp_property_paused_for_cache},
+    {"demuxer-via-network", mp_property_demuxer_is_network},
+    {"clock", mp_property_clock},
+    {"seekable", mp_property_seekable},
+    {"partially-seekable", mp_property_partially_seekable},
+    {"idle-active", mp_property_idle},
+    {"window-id", mp_property_window_id},
+
+    {"chapter-list", mp_property_list_chapters},
+    {"track-list", property_list_tracks},
+    {"current-tracks", property_current_tracks},
+    {"edition-list", property_list_editions},
+
+    {"playlist", mp_property_playlist},
+    {"playlist-path", mp_property_playlist_path},
+    {"playlist-pos", mp_property_playlist_pos},
+    {"playlist-pos-1", mp_property_playlist_pos_1},
+    {"playlist-current-pos", mp_property_playlist_current_pos},
+    {"playlist-playing-pos", mp_property_playlist_playing_pos},
+    M_PROPERTY_ALIAS("playlist-count", "playlist/count"),
+
+    // Audio
+    {"mixer-active", mp_property_mixer_active},
+    {"volume", mp_property_volume},
+    {"ao-volume", mp_property_ao_volume},
+    {"ao-mute", mp_property_ao_mute},
+    {"audio-delay", mp_property_audio_delay},
+    {"audio-codec-name", mp_property_audio_codec_name},
+    {"audio-codec", mp_property_audio_codec},
+    {"audio-params", mp_property_audio_params},
+    {"audio-out-params", mp_property_audio_out_params},
+    {"aid", property_switch_track, .priv = (void *)(const int[]){0, STREAM_AUDIO}},
+    {"audio-device", mp_property_audio_device},
+    {"audio-device-list", mp_property_audio_devices},
+    {"current-ao", mp_property_ao},
+
+    // Video
+    {"video-out-params", mp_property_vo_imgparams},
+    {"video-dec-params", mp_property_dec_imgparams},
+    {"video-params", mp_property_vd_imgparams},
+    {"video-format", mp_property_video_format},
+    {"video-frame-info", mp_property_video_frame_info},
+    {"video-codec", mp_property_video_codec},
+    M_PROPERTY_ALIAS("dwidth", "video-out-params/dw"),
+    M_PROPERTY_ALIAS("dheight", "video-out-params/dh"),
+    M_PROPERTY_ALIAS("width", "video-params/w"),
+    M_PROPERTY_ALIAS("height", "video-params/h"),
+    {"current-window-scale", mp_property_current_window_scale},
+    {"vo-configured", mp_property_vo_configured},
+    {"vo-passes", mp_property_vo_passes},
+    {"perf-info", mp_property_perf_info},
+    {"current-vo", mp_property_vo},
+    {"container-fps", mp_property_fps},
+    {"estimated-vf-fps", mp_property_vf_fps},
+    {"video-aspect-override", mp_property_video_aspect_override},
+    {"vid", property_switch_track, .priv = (void *)(const int[]){0, STREAM_VIDEO}},
+    {"hwdec-current", mp_property_hwdec_current},
+    {"hwdec-interop", mp_property_hwdec_interop},
+
+    {"estimated-frame-count", mp_property_frame_count},
+    {"estimated-frame-number", mp_property_frame_number},
+
+    {"osd-dimensions", mp_property_osd_dim},
+    M_PROPERTY_ALIAS("osd-width", "osd-dimensions/w"),
+    M_PROPERTY_ALIAS("osd-height", "osd-dimensions/h"),
+    M_PROPERTY_ALIAS("osd-par", "osd-dimensions/par"),
+
+    {"osd-sym-cc", mp_property_osd_sym},
+    {"osd-ass-cc", mp_property_osd_ass},
+
+    {"mouse-pos", mp_property_mouse_pos},
+
+    // Subs
+    {"sid", property_switch_track, .priv = (void *)(const int[]){0, STREAM_SUB}},
+    {"secondary-sid", property_switch_track,
+     .priv = (void *)(const int[]){1, STREAM_SUB}},
+    {"sub-delay", mp_property_sub_delay},
+    {"sub-speed", mp_property_sub_speed},
+    {"sub-pos", mp_property_sub_pos},
+    {"sub-ass-extradata", mp_property_sub_ass_extradata},
+    {"sub-text", mp_property_sub_text,
+        .priv = (void *)&(const int){SD_TEXT_TYPE_PLAIN}},
+    {"secondary-sub-text", mp_property_secondary_sub_text,
+        .priv = (void *)&(const int){SD_TEXT_TYPE_PLAIN}},
+    {"sub-text-ass", mp_property_sub_text,
+        .priv = (void *)&(const int){SD_TEXT_TYPE_ASS}},
+    {"sub-start", mp_property_sub_start,
+        .priv = (void *)&(const int){0}},
+    {"secondary-sub-start", mp_property_sub_start,
+        .priv = (void *)&(const int){1}},
+    {"sub-end", mp_property_sub_end,
+        .priv = (void *)&(const int){0}},
+    {"secondary-sub-end", mp_property_sub_end,
+        .priv = (void *)&(const int){1}},
+
+    {"vf", mp_property_vf},
+    {"af", mp_property_af},
+
+    {"ab-loop-a", mp_property_ab_loop},
+    {"ab-loop-b", mp_property_ab_loop},
+
+#define PROPERTY_BITRATE(name, old, type) \
+    {name, mp_property_packet_bitrate, (void *)(uintptr_t)((type)|(old?0x100:0))}
+    PROPERTY_BITRATE("packet-video-bitrate", true, STREAM_VIDEO),
+    PROPERTY_BITRATE("packet-audio-bitrate", true, STREAM_AUDIO),
+    PROPERTY_BITRATE("packet-sub-bitrate", true, STREAM_SUB),
+
+    PROPERTY_BITRATE("video-bitrate", false, STREAM_VIDEO),
+    PROPERTY_BITRATE("audio-bitrate", false, STREAM_AUDIO),
+    PROPERTY_BITRATE("sub-bitrate", false, STREAM_SUB),
+
+    {"focused", mp_property_focused},
+    {"display-names", mp_property_display_names},
+    {"display-fps", mp_property_display_fps},
+    {"estimated-display-fps", mp_property_estimated_display_fps},
+    {"vsync-jitter", mp_property_vsync_jitter},
+    {"display-hidpi-scale", mp_property_hidpi_scale},
+
+    {"working-directory", mp_property_cwd},
+
+    {"protocol-list", mp_property_protocols},
+    {"decoder-list", mp_property_decoders},
+    {"encoder-list", mp_property_encoders},
+    {"demuxer-lavf-list", mp_property_lavf_demuxers},
+    {"input-key-list", mp_property_keylist},
+
+    {"mpv-version", mp_property_version},
+    {"mpv-configuration", mp_property_configuration},
+    {"ffmpeg-version", mp_property_ffmpeg},
+    {"libass-version", mp_property_libass_version},
+    {"platform", mp_property_platform},
+
+    {"options", mp_property_options},
+    {"file-local-options", mp_property_local_options},
+    {"option-info", mp_property_option_info},
+    {"property-list", mp_property_list},
+    {"profile-list", mp_profile_list},
+    {"command-list", mp_property_commands},
+    {"input-bindings", mp_property_bindings},
+
+    {"shared-script-properties", mp_property_script_props},
+    {"user-data", mp_property_udata},
+
+    M_PROPERTY_ALIAS("video", "vid"),
+    M_PROPERTY_ALIAS("audio", "aid"),
+    M_PROPERTY_ALIAS("sub", "sid"),
+
+    // compatibility
+    M_PROPERTY_ALIAS("colormatrix", "video-params/colormatrix"),
+    M_PROPERTY_ALIAS("colormatrix-input-range", "video-params/colorlevels"),
+    M_PROPERTY_ALIAS("colormatrix-primaries", "video-params/primaries"),
+    M_PROPERTY_ALIAS("colormatrix-gamma", "video-params/gamma"),
+
+    M_PROPERTY_DEPRECATED_ALIAS("sub-forced-only-cur", "sub-forced-events-only"),
+};
+
+// Each entry describes which properties an event (possibly) changes.
+#define E(x, ...) [x] = (const char*const[]){__VA_ARGS__, NULL}
+static const char *const *const mp_event_property_change[] = {
+    E(MPV_EVENT_START_FILE, "*"),
+    E(MPV_EVENT_END_FILE, "*"),
+    E(MPV_EVENT_FILE_LOADED, "*"),
+    E(MP_EVENT_CHANGE_ALL, "*"),
+    E(MP_EVENT_TRACKS_CHANGED, "track-list", "current-tracks"),
+    E(MP_EVENT_TRACK_SWITCHED, "track-list", "current-tracks"),
+    E(MPV_EVENT_IDLE, "*"),
+    E(MPV_EVENT_TICK, "time-pos", "audio-pts", "stream-pos", "avsync",
+      "percent-pos", "time-remaining", "playtime-remaining", "playback-time",
+      "estimated-vf-fps", "total-avsync-change", "audio-speed-correction",
+      "video-speed-correction", "vo-delayed-frame-count", "mistimed-frame-count",
+      "vsync-ratio", "estimated-display-fps", "vsync-jitter", "sub-text",
+      "secondary-sub-text", "audio-bitrate", "video-bitrate", "sub-bitrate",
+      "decoder-frame-drop-count", "frame-drop-count", "video-frame-info",
+      "vf-metadata", "af-metadata", "sub-start", "sub-end", "secondary-sub-start",
+      "secondary-sub-end", "video-out-params", "video-dec-params", "video-params"),
+    E(MP_EVENT_DURATION_UPDATE, "duration"),
+    E(MPV_EVENT_VIDEO_RECONFIG, "video-out-params", "video-params",
+      "video-format", "video-codec", "video-bitrate", "dwidth", "dheight",
+      "width", "height", "container-fps", "aspect", "aspect-name", "vo-configured", "current-vo",
+      "video-dec-params", "osd-dimensions",
+      "hwdec", "hwdec-current", "hwdec-interop"),
+    E(MPV_EVENT_AUDIO_RECONFIG, "audio-format", "audio-codec", "audio-bitrate",
+      "samplerate", "channels", "audio", "volume", "mute",
+      "current-ao", "audio-codec-name", "audio-params",
+      "audio-out-params", "volume-max", "mixer-active"),
+    E(MPV_EVENT_SEEK, "seeking", "core-idle", "eof-reached"),
+    E(MPV_EVENT_PLAYBACK_RESTART, "seeking", "core-idle", "eof-reached"),
+    E(MP_EVENT_METADATA_UPDATE, "metadata", "filtered-metadata", "media-title"),
+    E(MP_EVENT_CHAPTER_CHANGE, "chapter", "chapter-metadata"),
+    E(MP_EVENT_CACHE_UPDATE,
+      "demuxer-cache-duration", "demuxer-cache-idle", "paused-for-cache",
+      "demuxer-cache-time", "cache-buffering-state", "cache-speed",
+      "demuxer-cache-state"),
+    E(MP_EVENT_WIN_RESIZE, "current-window-scale", "osd-width", "osd-height",
+      "osd-par", "osd-dimensions"),
+    E(MP_EVENT_WIN_STATE, "display-names", "display-fps", "display-width",
+      "display-height"),
+    E(MP_EVENT_WIN_STATE2, "display-hidpi-scale"),
+    E(MP_EVENT_FOCUS, "focused"),
+    E(MP_EVENT_CHANGE_PLAYLIST, "playlist", "playlist-pos", "playlist-pos-1",
+      "playlist-count", "playlist/count", "playlist-current-pos",
+      "playlist-playing-pos"),
+    E(MP_EVENT_INPUT_PROCESSED, "mouse-pos"),
+    E(MP_EVENT_CORE_IDLE, "core-idle", "eof-reached"),
+};
+#undef E
+
+// If there is no prefix, return length+1 (avoids matching full name as prefix).
+static int prefix_len(const char *p)
+{
+    const char *end = strchr(p, '/');
+    return end ? end - p : strlen(p) + 1;
+}
+
+static bool match_property(const char *a, const char *b)
+{
+    if (strcmp(a, "*") == 0)
+        return true;
+    // Give options and properties the same ID each, so change notifications
+    // work both way.
+    if (strncmp(a, "options/", 8) == 0)
+        a += 8;
+    if (strncmp(b, "options/", 8) == 0)
+        b += 8;
+    int len_a = prefix_len(a);
+    int len_b = prefix_len(b);
+    return strncmp(a, b, MPMIN(len_a, len_b)) == 0;
+}
+
+// Return a bitset of events which change the property.
+uint64_t mp_get_property_event_mask(const char *name)
+{
+    uint64_t mask = 0;
+    for (int n = 0; n < MP_ARRAY_SIZE(mp_event_property_change); n++) {
+        const char *const *const list = mp_event_property_change[n];
+        for (int i = 0; list && list[i]; i++) {
+            if (match_property(list[i], name))
+                mask |= 1ULL << n;
+        }
+    }
+    return mask;
+}
+
+// Return an ID for the property. It might not be unique, but is good enough
+// for property change handling. Return -1 if property unknown.
+int mp_get_property_id(struct MPContext *mpctx, const char *name)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+    for (int n = 0; ctx->properties[n].name; n++) {
+        if (match_property(ctx->properties[n].name, name))
+            return n;
+    }
+    return -1;
+}
+
+static bool is_property_set(int action, void *val)
+{
+    switch (action) {
+    case M_PROPERTY_SET:
+    case M_PROPERTY_SWITCH:
+    case M_PROPERTY_SET_STRING:
+    case M_PROPERTY_SET_NODE:
+    case M_PROPERTY_MULTIPLY:
+        return true;
+    case M_PROPERTY_KEY_ACTION: {
+        struct m_property_action_arg *key = val;
+        return is_property_set(key->action, key->arg);
+    }
+    default:
+        return false;
+    }
+}
+
+int mp_property_do(const char *name, int action, void *val,
+                   struct MPContext *ctx)
+{
+    struct command_ctx *cmd = ctx->command_ctx;
+    int r = m_property_do(ctx->log, cmd->properties, name, action, val, ctx);
+
+    if (mp_msg_test(ctx->log, MSGL_V) && is_property_set(action, val)) {
+        struct m_option ot = {0};
+        void *data = val;
+        switch (action) {
+        case M_PROPERTY_SET_NODE:
+            ot.type = &m_option_type_node;
+            break;
+        case M_PROPERTY_SET_STRING:
+            ot.type = &m_option_type_string;
+            data = &val;
+            break;
+        }
+        char *t = ot.type ? m_option_print(&ot, data) : NULL;
+        MP_VERBOSE(ctx, "Set property: %s%s%s -> %d\n",
+                   name, t ? "=" : "", t ? t : "", r);
+        talloc_free(t);
+    }
+    return r;
+}
+
+char *mp_property_expand_string(struct MPContext *mpctx, const char *str)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+    return m_properties_expand_string(ctx->properties, str, mpctx);
+}
+
+// Before expanding properties, parse C-style escapes like "\n"
+char *mp_property_expand_escaped_string(struct MPContext *mpctx, const char *str)
+{
+    void *tmp = talloc_new(NULL);
+    bstr strb = bstr0(str);
+    bstr dst = {0};
+    while (strb.len) {
+        if (!mp_append_escaped_string(tmp, &dst, &strb)) {
+            talloc_free(tmp);
+            return talloc_strdup(NULL, "(broken escape sequences)");
+        }
+        // pass " through literally
+        if (!bstr_eatstart0(&strb, "\""))
+            break;
+        bstr_xappend(tmp, &dst, bstr0("\""));
+    }
+    char *r = mp_property_expand_string(mpctx, dst.start);
+    talloc_free(tmp);
+    return r;
+}
+
+void property_print_help(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+    m_properties_print_help_list(mpctx->log, ctx->properties);
+}
+
+/* List of default ways to show a property on OSD.
+ *
+ * If osd_progbar is set, a bar showing the current position between min/max
+ * values of the property is shown. In this case osd_msg is only used for
+ * terminal output if there is no video; it'll be a label shown together with
+ * percentage.
+ */
+static const struct property_osd_display {
+    // property name
+    const char *name;
+    // name used on OSD
+    const char *osd_name;
+    // progressbar type
+    int osd_progbar;
+    // Needs special ways to display the new value (seeks are delayed)
+    int seek_msg, seek_bar;
+    // Show a marker thing on OSD bar. Ignored if osd_progbar==0.
+    float marker;
+    // Free-form message (if NULL, osd_name or the property name is used)
+    const char *msg;
+} property_osd_display[] = {
+    // general
+    {"loop-playlist", "Loop"},
+    {"loop-file", "Loop current file"},
+    {"chapter",
+     .seek_msg = OSD_SEEK_INFO_CHAPTER_TEXT,
+     .seek_bar = OSD_SEEK_INFO_BAR},
+    {"hr-seek", "hr-seek"},
+    {"speed", "Speed"},
+    {"clock", "Clock"},
+    {"edition", "Edition"},
+    // audio
+    {"volume", "Volume",
+     .msg = "Volume: ${?volume:${volume}% ${?mute==yes:(Muted)}}${!volume:${volume}}",
+     .osd_progbar = OSD_VOLUME, .marker = 100},
+    {"ao-volume", "AO Volume",
+     .msg = "AO Volume: ${?ao-volume:${ao-volume}% ${?ao-mute==yes:(Muted)}}${!ao-volume:${ao-volume}}",
+     .osd_progbar = OSD_VOLUME, .marker = 100},
+    {"mute", "Mute"},
+    {"ao-mute", "AO Mute"},
+    {"audio-delay", "A-V delay"},
+    {"audio", "Audio"},
+    // video
+    {"panscan", "Panscan", .osd_progbar = OSD_PANSCAN},
+    {"taskbar-progress", "Progress in taskbar"},
+    {"snap-window", "Snap to screen edges"},
+    {"ontop", "Stay on top"},
+    {"on-all-workspaces", "Visibility on all workspaces"},
+    {"border", "Border"},
+    {"framedrop", "Framedrop"},
+    {"deinterlace", "Deinterlace"},
+    {"gamma", "Gamma", .osd_progbar = OSD_BRIGHTNESS },
+    {"brightness", "Brightness", .osd_progbar = OSD_BRIGHTNESS},
+    {"contrast", "Contrast", .osd_progbar = OSD_CONTRAST},
+    {"saturation", "Saturation", .osd_progbar = OSD_SATURATION},
+    {"hue", "Hue", .osd_progbar = OSD_HUE},
+    {"angle", "Angle"},
+    // subs
+    {"sub", "Subtitles"},
+    {"secondary-sid", "Secondary subtitles"},
+    {"sub-pos", "Sub position"},
+    {"sub-delay", "Sub delay"},
+    {"sub-speed", "Sub speed"},
+    {"sub-visibility",
+     .msg = "Subtitles ${!sub-visibility==yes:hidden}"
+      "${?sub-visibility==yes:visible${?sub==no: (but no subtitles selected)}}"},
+    {"secondary-sub-visibility",
+     .msg = "Secondary Subtitles ${!secondary-sub-visibility==yes:hidden}"
+      "${?secondary-sub-visibility==yes:visible${?secondary-sid==no: (but no secondary subtitles selected)}}"},
+    {"sub-forced-events-only", "Forced sub only"},
+    {"sub-scale", "Sub Scale"},
+    {"sub-ass-vsfilter-aspect-compat", "Subtitle VSFilter aspect compat"},
+    {"sub-ass-override", "ASS subtitle style override"},
+    {"vf", "Video filters", .msg = "Video filters:\n${vf}"},
+    {"af", "Audio filters", .msg = "Audio filters:\n${af}"},
+    {"ab-loop-a", "A-B loop start"},
+    {"ab-loop-b", .msg = "A-B loop: ${ab-loop-a} - ${ab-loop-b}"
+                            "${?=ab-loop-count==0: (disabled)}"},
+    {"audio-device", "Audio device"},
+    {"hwdec", .msg = "Hardware decoding: ${hwdec-current}"},
+    {"video-aspect-override", "Aspect ratio override"},
+    // By default, don't display the following properties on OSD
+    {"pause", NULL},
+    {"fullscreen", NULL},
+    {"window-minimized", NULL},
+    {"window-maximized", NULL},
+    {0}
+};
+
+static void show_property_osd(MPContext *mpctx, const char *name, int osd_mode)
+{
+    struct MPOpts *opts = mpctx->opts;
+    struct property_osd_display disp = {.name = name, .osd_name = name};
+
+    if (!osd_mode)
+        return;
+
+    // look for the command
+    for (const struct property_osd_display *p = property_osd_display; p->name; p++)
+    {
+        if (!strcmp(p->name, name)) {
+            disp = *p;
+            break;
+        }
+    }
+
+    if (osd_mode == MP_ON_OSD_AUTO) {
+        osd_mode =
+            ((disp.msg || disp.osd_name || disp.seek_msg) ? MP_ON_OSD_MSG : 0) |
+            ((disp.osd_progbar || disp.seek_bar) ? MP_ON_OSD_BAR : 0);
+    }
+
+    if (!disp.osd_progbar)
+        disp.osd_progbar = ' ';
+
+    if (!disp.osd_name)
+        disp.osd_name = name;
+
+    if (disp.seek_msg || disp.seek_bar) {
+        mpctx->add_osd_seek_info |=
+            (osd_mode & MP_ON_OSD_MSG ? disp.seek_msg : 0) |
+            (osd_mode & MP_ON_OSD_BAR ? disp.seek_bar : 0);
+        return;
+    }
+
+    struct m_option prop = {0};
+    mp_property_do(name, M_PROPERTY_GET_CONSTRICTED_TYPE, &prop, mpctx);
+    if ((osd_mode & MP_ON_OSD_BAR)) {
+        if (prop.type == CONF_TYPE_INT && prop.min < prop.max) {
+            int n = prop.min;
+            if (disp.osd_progbar)
+                n = disp.marker;
+            int i;
+            if (mp_property_do(name, M_PROPERTY_GET, &i, mpctx) > 0)
+                set_osd_bar(mpctx, disp.osd_progbar, prop.min, prop.max, n, i);
+        } else if (prop.type == CONF_TYPE_FLOAT && prop.min < prop.max) {
+            float n = prop.min;
+            if (disp.osd_progbar)
+                n = disp.marker;
+            float f;
+            if (mp_property_do(name, M_PROPERTY_GET, &f, mpctx) > 0)
+                set_osd_bar(mpctx, disp.osd_progbar, prop.min, prop.max, n, f);
+        }
+    }
+
+    if (osd_mode & MP_ON_OSD_MSG) {
+        void *tmp = talloc_new(NULL);
+
+        const char *msg = disp.msg;
+        if (!msg)
+            msg = talloc_asprintf(tmp, "%s: ${%s}", disp.osd_name, name);
+
+        char *osd_msg = talloc_steal(tmp, mp_property_expand_string(mpctx, msg));
+
+        if (osd_msg && osd_msg[0])
+            set_osd_msg(mpctx, 1, opts->osd_duration, "%s", osd_msg);
+
+        talloc_free(tmp);
+    }
+}
+
+static bool reinit_filters(MPContext *mpctx, enum stream_type mediatype)
+{
+    switch (mediatype) {
+    case STREAM_VIDEO:
+        return reinit_video_filters(mpctx) >= 0;
+    case STREAM_AUDIO:
+        return reinit_audio_filters(mpctx) >= 0;
+    }
+    return false;
+}
+
+static const char *const filter_opt[STREAM_TYPE_COUNT] = {
+    [STREAM_VIDEO] = "vf",
+    [STREAM_AUDIO] = "af",
+};
+
+static int set_filters(struct MPContext *mpctx, enum stream_type mediatype,
+                       struct m_obj_settings *new_chain)
+{
+    bstr option = bstr0(filter_opt[mediatype]);
+    struct m_config_option *co = m_config_get_co(mpctx->mconfig, option);
+    if (!co)
+        return -1;
+
+    struct m_obj_settings **list = co->data;
+    struct m_obj_settings *old_settings = *list;
+    *list = NULL;
+    m_option_copy(co->opt, list, &new_chain);
+
+    bool success = reinit_filters(mpctx, mediatype);
+
+    if (success) {
+        m_option_free(co->opt, &old_settings);
+        m_config_notify_change_opt_ptr(mpctx->mconfig, list);
+    } else {
+        m_option_free(co->opt, list);
+        *list = old_settings;
+    }
+
+    return success ? 0 : -1;
+}
+
+static int edit_filters(struct MPContext *mpctx, struct mp_log *log,
+                        enum stream_type mediatype,
+                        const char *cmd, const char *arg)
+{
+    bstr option = bstr0(filter_opt[mediatype]);
+    struct m_config_option *co = m_config_get_co(mpctx->mconfig, option);
+    if (!co)
+        return -1;
+
+    // The option parser is used to modify the filter list itself.
+    char optname[20];
+    snprintf(optname, sizeof(optname), "%.*s-%s", BSTR_P(option), cmd);
+
+    struct m_obj_settings *new_chain = NULL;
+    m_option_copy(co->opt, &new_chain, co->data);
+
+    int r = m_option_parse(log, co->opt, bstr0(optname), bstr0(arg), &new_chain);
+    if (r >= 0)
+        r = set_filters(mpctx, mediatype, new_chain);
+
+    m_option_free(co->opt, &new_chain);
+
+    return r >= 0 ? 0 : -1;
+}
+
+static int edit_filters_osd(struct MPContext *mpctx, enum stream_type mediatype,
+                            const char *cmd, const char *arg, bool on_osd)
+{
+    int r = edit_filters(mpctx, mpctx->log, mediatype, cmd, arg);
+    if (on_osd) {
+        if (r >= 0) {
+            const char *prop = filter_opt[mediatype];
+            show_property_osd(mpctx, prop, MP_ON_OSD_MSG);
+        } else {
+            set_osd_msg(mpctx, 1, mpctx->opts->osd_duration,
+                         "Changing filters failed!");
+        }
+    }
+    return r;
+}
+
+static void recreate_overlays(struct MPContext *mpctx)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    int overlay_next = !cmd->overlay_osd_current;
+    struct sub_bitmaps *new = &cmd->overlay_osd[overlay_next];
+    new->format = SUBBITMAP_BGRA;
+    new->change_id = 1;
+
+    bool valid = false;
+
+    new->num_parts = 0;
+    for (int n = 0; n < cmd->num_overlays; n++) {
+        struct overlay *o = &cmd->overlays[n];
+        if (o->source) {
+            struct mp_image *s = o->source;
+            struct sub_bitmap b = {
+                .bitmap = s->planes[0],
+                .stride = s->stride[0],
+                .w = s->w, .dw = s->w,
+                .h = s->h, .dh = s->h,
+                .x = o->x,
+                .y = o->y,
+            };
+            MP_TARRAY_APPEND(cmd, new->parts, new->num_parts, b);
+        }
+    }
+
+    if (!cmd->overlay_packer)
+        cmd->overlay_packer = talloc_zero(cmd, struct bitmap_packer);
+
+    cmd->overlay_packer->padding = 1; // assume bilinear scaling
+    packer_set_size(cmd->overlay_packer, new->num_parts);
+
+    for (int n = 0; n < new->num_parts; n++)
+        cmd->overlay_packer->in[n] = (struct pos){new->parts[n].w, new->parts[n].h};
+
+    if (packer_pack(cmd->overlay_packer) < 0 || new->num_parts == 0)
+        goto done;
+
+    struct pos bb[2];
+    packer_get_bb(cmd->overlay_packer, bb);
+
+    new->packed_w = bb[1].x;
+    new->packed_h = bb[1].y;
+
+    if (!new->packed || new->packed->w < new->packed_w ||
+                        new->packed->h < new->packed_h)
+    {
+        talloc_free(new->packed);
+        new->packed = mp_image_alloc(IMGFMT_BGRA, cmd->overlay_packer->w,
+                                                  cmd->overlay_packer->h);
+        if (!new->packed)
+            goto done;
+    }
+
+    if (!mp_image_make_writeable(new->packed))
+        goto done;
+
+    // clear padding
+    mp_image_clear(new->packed, 0, 0, new->packed->w, new->packed->h);
+
+    for (int n = 0; n < new->num_parts; n++) {
+        struct sub_bitmap *b = &new->parts[n];
+        struct pos pos = cmd->overlay_packer->result[n];
+
+        int stride = new->packed->stride[0];
+        void *pdata = (uint8_t *)new->packed->planes[0] + pos.y * stride + pos.x * 4;
+        memcpy_pic(pdata, b->bitmap, b->w * 4, b->h, stride, b->stride);
+
+        b->bitmap = pdata;
+        b->stride = stride;
+
+        b->src_x = pos.x;
+        b->src_y = pos.y;
+    }
+
+    valid = true;
+done:
+    if (!valid) {
+        new->format = SUBBITMAP_EMPTY;
+        new->num_parts = 0;
+    }
+
+    osd_set_external2(mpctx->osd, new);
+    mp_wakeup_core(mpctx);
+    cmd->overlay_osd_current = overlay_next;
+}
+
+// Set overlay with the given ID to the contents as described by "new".
+static void replace_overlay(struct MPContext *mpctx, int id, struct overlay *new)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    assert(id >= 0);
+    if (id >= cmd->num_overlays) {
+        MP_TARRAY_GROW(cmd, cmd->overlays, id);
+        while (cmd->num_overlays <= id)
+            cmd->overlays[cmd->num_overlays++] = (struct overlay){0};
+    }
+
+    struct overlay *ptr = &cmd->overlays[id];
+
+    talloc_free(ptr->source);
+    *ptr = *new;
+
+    recreate_overlays(mpctx);
+}
+
+static void cmd_overlay_add(void *pcmd)
+{
+    struct mp_cmd_ctx *cmd = pcmd;
+    struct MPContext *mpctx = cmd->mpctx;
+    int id = cmd->args[0].v.i, x = cmd->args[1].v.i, y = cmd->args[2].v.i;
+    char *file = cmd->args[3].v.s;
+    int offset = cmd->args[4].v.i;
+    char *fmt = cmd->args[5].v.s;
+    int w = cmd->args[6].v.i, h = cmd->args[7].v.i, stride = cmd->args[8].v.i;
+
+    if (strcmp(fmt, "bgra") != 0) {
+        MP_ERR(mpctx, "overlay-add: unsupported OSD format '%s'\n", fmt);
+        goto error;
+    }
+    if (id < 0 || id >= 64) { // arbitrary upper limit
+        MP_ERR(mpctx, "overlay-add: invalid id %d\n", id);
+        goto error;
+    }
+    if (w <= 0 || h <= 0 || stride < w * 4 || (stride % 4)) {
+        MP_ERR(mpctx, "overlay-add: inconsistent parameters\n");
+        goto error;
+    }
+    struct overlay overlay = {
+        .source = mp_image_alloc(IMGFMT_BGRA, w, h),
+        .x = x,
+        .y = y,
+    };
+    if (!overlay.source)
+        goto error;
+    int fd = -1;
+    bool close_fd = true;
+    void *p = NULL;
+    if (file[0] == '@') {
+        char *end;
+        fd = strtol(&file[1], &end, 10);
+        if (!file[1] || end[0])
+            fd = -1;
+        close_fd = false;
+    } else if (file[0] == '&') {
+        char *end;
+        unsigned long long addr = strtoull(&file[1], &end, 0);
+        if (!file[1] || end[0])
+            addr = 0;
+        p = (void *)(uintptr_t)addr;
+    } else {
+        fd = open(file, O_RDONLY | O_BINARY | O_CLOEXEC);
+    }
+    int map_size = 0;
+    if (fd >= 0) {
+        map_size = offset + h * stride;
+        void *m = mmap(NULL, map_size, PROT_READ, MAP_SHARED, fd, 0);
+        if (close_fd)
+            close(fd);
+        if (m && m != MAP_FAILED)
+            p = m;
+    }
+    if (!p) {
+        MP_ERR(mpctx, "overlay-add: could not open or map '%s'\n", file);
+        talloc_free(overlay.source);
+        goto error;
+    }
+    memcpy_pic(overlay.source->planes[0], (char *)p + offset, w * 4, h,
+               overlay.source->stride[0], stride);
+    if (map_size)
+        munmap(p, map_size);
+
+    replace_overlay(mpctx, id, &overlay);
+    return;
+error:
+    cmd->success = false;
+}
+
+static void cmd_overlay_remove(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    struct command_ctx *cmdctx = mpctx->command_ctx;
+    int id = cmd->args[0].v.i;
+    if (id >= 0 && id < cmdctx->num_overlays)
+        replace_overlay(mpctx, id, &(struct overlay){0});
+}
+
+static void overlay_uninit(struct MPContext *mpctx)
+{
+    struct command_ctx *cmd = mpctx->command_ctx;
+    if (!mpctx->osd)
+        return;
+    for (int id = 0; id < cmd->num_overlays; id++)
+        replace_overlay(mpctx, id, &(struct overlay){0});
+    osd_set_external2(mpctx->osd, NULL);
+    for (int n = 0; n < 2; n++)
+        mp_image_unrefp(&cmd->overlay_osd[n].packed);
+}
+
+static void cmd_osd_overlay(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    double rc[4] = {0};
+
+    struct osd_external_ass ov = {
+        .owner  = cmd->cmd->sender,
+        .id     = cmd->args[0].v.i64,
+        .format = cmd->args[1].v.i,
+        .data   = cmd->args[2].v.s,
+        .res_x  = cmd->args[3].v.i,
+        .res_y  = cmd->args[4].v.i,
+        .z      = cmd->args[5].v.i,
+        .hidden = cmd->args[6].v.b,
+        .out_rc = cmd->args[7].v.b ? rc : NULL,
+    };
+
+    osd_set_external(mpctx->osd, &ov);
+
+    struct mpv_node *res = &cmd->result;
+    node_init(res, MPV_FORMAT_NODE_MAP, NULL);
+
+    // (An empty rc uses INFINITY, avoid in JSON, just leave it unset.)
+    if (rc[0] < rc[2] && rc[1] < rc[3]) {
+        node_map_add_double(res, "x0", rc[0]);
+        node_map_add_double(res, "y0", rc[1]);
+        node_map_add_double(res, "x1", rc[2]);
+        node_map_add_double(res, "y1", rc[3]);
+    }
+
+    mp_wakeup_core(mpctx);
+}
+
+static struct track *find_track_with_url(struct MPContext *mpctx, int type,
+                                         const char *url)
+{
+    for (int n = 0; n < mpctx->num_tracks; n++) {
+        struct track *track = mpctx->tracks[n];
+        if (track && track->type == type && track->is_external &&
+            strcmp(track->external_filename, url) == 0)
+            return track;
+    }
+    return NULL;
+}
+
+// Whether this property should react to key events generated by auto-repeat.
+static bool check_property_autorepeat(char *property,  struct MPContext *mpctx)
+{
+    struct m_option prop = {0};
+    if (mp_property_do(property, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0)
+        return true;
+
+    // This is a heuristic at best.
+    if (prop.type->flags & M_OPT_TYPE_CHOICE)
+        return false;
+
+    return true;
+}
+
+// Whether changes to this property (add/cycle cmds) benefit from cmd->scale
+static bool check_property_scalable(char *property, struct MPContext *mpctx)
+{
+    struct m_option prop = {0};
+    if (mp_property_do(property, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0)
+        return true;
+
+    // These properties are backed by a floating-point number
+    return prop.type == &m_option_type_float ||
+           prop.type == &m_option_type_double ||
+           prop.type == &m_option_type_time ||
+           prop.type == &m_option_type_aspect;
+}
+
+static void show_property_status(struct mp_cmd_ctx *cmd, const char *name, int r)
+{
+    struct MPContext *mpctx = cmd->mpctx;
+    struct MPOpts *opts = mpctx->opts;
+    int osd_duration = opts->osd_duration;
+    int osdl = cmd->msg_osd ? 1 : OSD_LEVEL_INVISIBLE;
+
+    if (r == M_PROPERTY_OK || r == M_PROPERTY_UNAVAILABLE) {
+        show_property_osd(mpctx, name, cmd->on_osd);
+        if (r == M_PROPERTY_UNAVAILABLE)
+            cmd->success = false;
+    } else if (r == M_PROPERTY_UNKNOWN) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Unknown property: '%s'", name);
+        cmd->success = false;
+    } else if (r <= 0) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Failed to set property '%s'",
+                    name);
+        cmd->success = false;
+    }
+}
+
+static void change_property_cmd(struct mp_cmd_ctx *cmd,
+                                const char *name, int action, void *arg)
+{
+    int r = mp_property_do(name, action, arg, cmd->mpctx);
+    show_property_status(cmd, name, r);
+}
+
+static void cmd_cycle_values(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int first = 0, dir = 1;
+
+    if (strcmp(cmd->args[first].v.s, "!reverse") == 0) {
+        first += 1;
+        dir = -1;
+    }
+
+    const char *name = cmd->args[first].v.s;
+    first += 1;
+
+    if (first >= cmd->num_args) {
+        MP_ERR(mpctx, "cycle-values command does not have any value arguments.\n");
+        cmd->success = false;
+        return;
+    }
+
+    struct m_option prop = {0};
+    int r = mp_property_do(name, M_PROPERTY_GET_TYPE, &prop, mpctx);
+    if (r <= 0) {
+        show_property_status(cmd, name, r);
+        return;
+    }
+
+    union m_option_value curval = m_option_value_default;
+    r = mp_property_do(name, M_PROPERTY_GET, &curval, mpctx);
+    if (r <= 0) {
+        show_property_status(cmd, name, r);
+        return;
+    }
+
+    int current = -1;
+    for (int n = first; n < cmd->num_args; n++) {
+        union m_option_value val = m_option_value_default;
+        if (m_option_parse(mpctx->log, &prop, bstr0(name),
+                           bstr0(cmd->args[n].v.s), &val) < 0)
+            continue;
+
+        if (m_option_equal(&prop, &curval, &val))
+            current = n;
+
+        m_option_free(&prop, &val);
+
+        if (current >= 0)
+            break;
+    }
+
+    m_option_free(&prop, &curval);
+
+    if (current >= 0) {
+        current += dir;
+        if (current < first)
+            current = cmd->num_args - 1;
+        if (current >= cmd->num_args)
+            current = first;
+    } else {
+        MP_VERBOSE(mpctx, "Current value not found. Picking default.\n");
+        current = dir > 0 ? first : cmd->num_args - 1;
+    }
+
+    change_property_cmd(cmd, name, M_PROPERTY_SET_STRING, cmd->args[current].v.s);
+}
+
+struct cmd_list_ctx {
+    struct MPContext *mpctx;
+
+    // actual list command
+    struct mp_cmd_ctx *parent;
+
+    bool current_valid;
+    mp_thread_id current_tid;
+    bool completed_recursive;
+
+    // list of sub commands yet to run
+    struct mp_cmd **sub;
+    int num_sub;
+};
+
+static void continue_cmd_list(struct cmd_list_ctx *list);
+
+static void on_cmd_list_sub_completion(struct mp_cmd_ctx *cmd)
+{
+    struct cmd_list_ctx *list = cmd->on_completion_priv;
+
+    if (list->current_valid && mp_thread_id_equal(list->current_tid, mp_thread_current_id())) {
+        list->completed_recursive = true;
+    } else {
+        continue_cmd_list(list);
+    }
+}
+
+static void continue_cmd_list(struct cmd_list_ctx *list)
+{
+    while (list->parent->args[0].v.p) {
+        struct mp_cmd *sub = list->parent->args[0].v.p;
+        list->parent->args[0].v.p = sub->queue_next;
+
+        ta_set_parent(sub, NULL);
+
+        if (sub->flags & MP_ASYNC_CMD) {
+            // We run it "detached" (fire & forget)
+            run_command(list->mpctx, sub, NULL, NULL, NULL);
+        } else {
+            // Run the next command once this one completes.
+
+            list->completed_recursive = false;
+            list->current_valid = true;
+            list->current_tid = mp_thread_current_id();
+
+            run_command(list->mpctx, sub, NULL, on_cmd_list_sub_completion, list);
+
+            list->current_valid = false;
+
+            // run_command() either recursively calls the completion function,
+            // or lets the command continue run in the background. If it was
+            // completed recursively, we can just continue our loop. Otherwise
+            // the completion handler will invoke this loop again elsewhere.
+            // We could unconditionally call continue_cmd_list() in the handler
+            // instead, but then stack depth would grow with list length.
+            if (!list->completed_recursive)
+                return;
+        }
+    }
+
+    mp_cmd_ctx_complete(list->parent);
+    talloc_free(list);
+}
+
+static void cmd_list(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+
+    cmd->completed = false;
+
+    struct cmd_list_ctx *list = talloc_zero(NULL, struct cmd_list_ctx);
+    list->mpctx = cmd->mpctx;
+    list->parent = p;
+
+    continue_cmd_list(list);
+}
+
+const struct mp_cmd_def mp_cmd_list = { "list", cmd_list, .exec_async = true };
+
+// Signal that the command is complete now. This also deallocates cmd.
+// You must call this function in a state where the core is locked for the
+// current thread (e.g. from the main thread, or from within mp_dispatch_lock()).
+// Completion means the command is finished, even if it errored or never ran.
+// Keep in mind that calling this can execute further user command that can
+// change arbitrary state (due to cmd_list).
+void mp_cmd_ctx_complete(struct mp_cmd_ctx *cmd)
+{
+    cmd->completed = true;
+    if (!cmd->success)
+        mpv_free_node_contents(&cmd->result);
+    if (cmd->on_completion)
+        cmd->on_completion(cmd);
+    if (cmd->abort)
+        mp_abort_remove(cmd->mpctx, cmd->abort);
+    mpv_free_node_contents(&cmd->result);
+    talloc_free(cmd);
+}
+
+static void run_command_on_worker_thread(void *p)
+{
+    struct mp_cmd_ctx *ctx = p;
+    struct MPContext *mpctx = ctx->mpctx;
+
+    mp_core_lock(mpctx);
+
+    bool exec_async = ctx->cmd->def->exec_async;
+    ctx->cmd->def->handler(ctx);
+    if (!exec_async)
+        mp_cmd_ctx_complete(ctx);
+
+    mpctx->outstanding_async -= 1;
+    if (!mpctx->outstanding_async && mp_is_shutting_down(mpctx))
+        mp_wakeup_core(mpctx);
+
+    mp_core_unlock(mpctx);
+}
+
+// Run the given command. Upon command completion, on_completion is called. This
+// can happen within the function, or for async commands, some time after the
+// function returns (the caller is supposed to be able to handle both cases). In
+// both cases, the callback will be called while the core is locked (i.e. you
+// can access the core freely).
+// If abort is non-NULL, then the caller creates the abort object. It must have
+// been allocated with talloc. run_command() will register/unregister/destroy
+// it. Must not be set if cmd->def->can_abort==false.
+// on_completion_priv is copied to mp_cmd_ctx.on_completion_priv and can be
+// accessed from the completion callback.
+// The completion callback is invoked exactly once. If it's NULL, it's ignored.
+// Ownership of cmd goes to the caller.
+void run_command(struct MPContext *mpctx, struct mp_cmd *cmd,
+                 struct mp_abort_entry *abort,
+                 void (*on_completion)(struct mp_cmd_ctx *cmd),
+                 void *on_completion_priv)
+{
+    struct mp_cmd_ctx *ctx = talloc(NULL, struct mp_cmd_ctx);
+    *ctx = (struct mp_cmd_ctx){
+        .mpctx = mpctx,
+        .cmd = talloc_steal(ctx, cmd),
+        .args = cmd->args,
+        .num_args = cmd->nargs,
+        .priv = cmd->def->priv,
+        .abort = talloc_steal(ctx, abort),
+        .success = true,
+        .completed = true,
+        .on_completion = on_completion,
+        .on_completion_priv = on_completion_priv,
+    };
+
+    if (!ctx->abort && cmd->def->can_abort)
+        ctx->abort = talloc_zero(ctx, struct mp_abort_entry);
+
+    assert(cmd->def->can_abort == !!ctx->abort);
+
+    if (ctx->abort) {
+        ctx->abort->coupled_to_playback |= cmd->def->abort_on_playback_end;
+        mp_abort_add(mpctx, ctx->abort);
+    }
+
+    struct MPOpts *opts = mpctx->opts;
+    ctx->on_osd = cmd->flags & MP_ON_OSD_FLAGS;
+    bool auto_osd = ctx->on_osd == MP_ON_OSD_AUTO;
+    ctx->msg_osd = auto_osd || (ctx->on_osd & MP_ON_OSD_MSG);
+    ctx->bar_osd = auto_osd || (ctx->on_osd & MP_ON_OSD_BAR);
+    ctx->seek_msg_osd = auto_osd ? opts->osd_on_seek & 2 : ctx->msg_osd;
+    ctx->seek_bar_osd = auto_osd ? opts->osd_on_seek & 1 : ctx->bar_osd;
+
+    bool noise = cmd->def->is_noisy || cmd->mouse_move;
+    mp_cmd_dump(mpctx->log, noise ? MSGL_TRACE : MSGL_DEBUG, "Run command:", cmd);
+
+    if (cmd->flags & MP_EXPAND_PROPERTIES) {
+        for (int n = 0; n < cmd->nargs; n++) {
+            if (cmd->args[n].type->type == CONF_TYPE_STRING) {
+                char *s = mp_property_expand_string(mpctx, cmd->args[n].v.s);
+                if (!s) {
+                    ctx->success = false;
+                    mp_cmd_ctx_complete(ctx);
+                    return;
+                }
+                talloc_free(cmd->args[n].v.s);
+                cmd->args[n].v.s = s;
+            }
+        }
+    }
+
+    if (cmd->def->spawn_thread) {
+        mpctx->outstanding_async += 1; // prevent that core disappears
+        if (!mp_thread_pool_queue(mpctx->thread_pool,
+                                  run_command_on_worker_thread, ctx))
+        {
+            mpctx->outstanding_async -= 1;
+            ctx->success = false;
+            mp_cmd_ctx_complete(ctx);
+        }
+    } else {
+        bool exec_async = cmd->def->exec_async;
+        cmd->def->handler(ctx);
+        if (!exec_async)
+            mp_cmd_ctx_complete(ctx);
+    }
+}
+
+// When a command shows a message. status is the level (e.g. MSGL_INFO), and
+// msg+vararg is as in printf (don't include a trailing "\n").
+void mp_cmd_msg(struct mp_cmd_ctx *cmd, int status, const char *msg, ...)
+{
+    va_list ap;
+    char *s;
+
+    va_start(ap, msg);
+    s = talloc_vasprintf(NULL, msg, ap);
+    va_end(ap);
+
+    MP_MSG(cmd->mpctx, status, "%s\n", s);
+    if (cmd->msg_osd && status <= MSGL_INFO)
+        set_osd_msg(cmd->mpctx, 1, cmd->mpctx->opts->osd_duration, "%s", s);
+
+    talloc_free(s);
+}
+
+static void cmd_seek(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    double v = cmd->args[0].v.d * cmd->cmd->scale;
+    int abs = cmd->args[1].v.i & 3;
+    enum seek_precision precision = MPSEEK_DEFAULT;
+    switch (((cmd->args[2].v.i | cmd->args[1].v.i) >> 3) & 3) {
+    case 1: precision = MPSEEK_KEYFRAME; break;
+    case 2: precision = MPSEEK_EXACT; break;
+    }
+    if (!mpctx->playback_initialized) {
+        cmd->success = false;
+        return;
+    }
+
+    mark_seek(mpctx);
+    switch (abs) {
+    case 0: { // Relative seek
+        queue_seek(mpctx, MPSEEK_RELATIVE, v, precision, MPSEEK_FLAG_DELAY);
+        set_osd_function(mpctx, (v > 0) ? OSD_FFW : OSD_REW);
+        break;
+    }
+    case 1: { // Absolute seek by percentage
+        double ratio = v / 100.0;
+        double cur_pos = get_current_pos_ratio(mpctx, false);
+        queue_seek(mpctx, MPSEEK_FACTOR, ratio, precision, MPSEEK_FLAG_DELAY);
+        set_osd_function(mpctx, cur_pos < ratio ? OSD_FFW : OSD_REW);
+        break;
+    }
+    case 2: { // Absolute seek to a timestamp in seconds
+        if (v < 0) {
+            // Seek from end
+            double len = get_time_length(mpctx);
+            if (len < 0) {
+                cmd->success = false;
+                return;
+            }
+            v = MPMAX(0, len + v);
+        }
+        queue_seek(mpctx, MPSEEK_ABSOLUTE, v, precision, MPSEEK_FLAG_DELAY);
+        set_osd_function(mpctx,
+                         v > get_current_time(mpctx) ? OSD_FFW : OSD_REW);
+        break;
+    }
+    case 3: { // Relative seek by percentage
+        queue_seek(mpctx, MPSEEK_FACTOR,
+                   get_current_pos_ratio(mpctx, false) + v / 100.0,
+                   precision, MPSEEK_FLAG_DELAY);
+        set_osd_function(mpctx, v > 0 ? OSD_FFW : OSD_REW);
+        break;
+    }}
+    if (cmd->seek_bar_osd)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
+    if (cmd->seek_msg_osd)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
+}
+
+static void cmd_revert_seek(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    struct command_ctx *cmdctx = mpctx->command_ctx;
+
+    if (!mpctx->playback_initialized) {
+        cmd->success = false;
+        return;
+    }
+
+    double oldpts = cmdctx->last_seek_pts;
+    if (cmdctx->marked_pts != MP_NOPTS_VALUE)
+        oldpts = cmdctx->marked_pts;
+    if (cmd->args[0].v.i & 3) {
+        cmdctx->marked_pts = get_current_time(mpctx);
+        cmdctx->marked_permanent = cmd->args[0].v.i & 1;
+    } else if (oldpts != MP_NOPTS_VALUE) {
+        if (!cmdctx->marked_permanent) {
+            cmdctx->marked_pts = MP_NOPTS_VALUE;
+            cmdctx->last_seek_pts = get_current_time(mpctx);
+        }
+        queue_seek(mpctx, MPSEEK_ABSOLUTE, oldpts, MPSEEK_EXACT,
+                   MPSEEK_FLAG_DELAY);
+        set_osd_function(mpctx, OSD_REW);
+        if (cmd->seek_bar_osd)
+            mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
+        if (cmd->seek_msg_osd)
+            mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
+    } else {
+        cmd->success = false;
+    }
+}
+
+static void cmd_set(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+
+    change_property_cmd(cmd, cmd->args[0].v.s,
+                        M_PROPERTY_SET_STRING, cmd->args[1].v.s);
+}
+
+static void cmd_del(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    const char *name = cmd->args[0].v.s;
+    int osdl = cmd->msg_osd ? 1 : OSD_LEVEL_INVISIBLE;
+    int osd_duration = mpctx->opts->osd_duration;
+
+    int r = mp_property_do(name, M_PROPERTY_DELETE, NULL, mpctx);
+
+    if (r == M_PROPERTY_OK) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Deleted property: '%s'", name);
+        cmd->success = true;
+    } else if (r == M_PROPERTY_UNKNOWN) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Unknown property: '%s'", name);
+        cmd->success = false;
+    } else if (r <= 0) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Failed to set property '%s'",
+                    name);
+        cmd->success = false;
+    }
+}
+
+static void cmd_change_list(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    char *name = cmd->args[0].v.s;
+    char *op = cmd->args[1].v.s;
+    char *value = cmd->args[2].v.s;
+    int osd_duration = mpctx->opts->osd_duration;
+    int osdl = cmd->msg_osd ? 1 : OSD_LEVEL_INVISIBLE;
+
+    struct m_option prop = {0};
+    if (mp_property_do(name, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Unknown option: '%s'", name);
+        cmd->success = false;
+        return;
+    }
+
+    const struct m_option_type *type = prop.type;
+    bool found = false;
+    for (int i = 0; type->actions && type->actions[i].name; i++) {
+        const struct m_option_action *action = &type->actions[i];
+        if (strcmp(action->name, op) == 0)
+            found = true;
+    }
+    if (!found) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Unknown action: '%s'", op);
+        cmd->success = false;
+        return;
+    }
+
+    union m_option_value val = m_option_value_default;
+    if (mp_property_do(name, M_PROPERTY_GET, &val, mpctx) <= 0) {
+        set_osd_msg(mpctx, osdl, osd_duration, "Could not read: '%s'", name);
+        cmd->success = false;
+        return;
+    }
+
+    char *optname = mp_tprintf(80, "%s-%s", name, op); // the dirty truth
+    int r = m_option_parse(mpctx->log, &prop, bstr0(optname), bstr0(value), &val);
+    if (r >= 0 && mp_property_do(name, M_PROPERTY_SET, &val, mpctx) <= 0)
+        r = -1;
+    m_option_free(&prop, &val);
+    if (r < 0) {
+        set_osd_msg(mpctx, osdl, osd_duration,
+                    "Failed setting option: '%s'", name);
+        cmd->success = false;
+        return;
+    }
+
+    show_property_osd(mpctx, name, cmd->on_osd);
+}
+
+static void cmd_add_cycle(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    bool is_cycle = !!cmd->priv;
+
+    char *property = cmd->args[0].v.s;
+    if (cmd->cmd->repeated && !check_property_autorepeat(property, mpctx) &&
+        !(cmd->cmd->flags & MP_ALLOW_REPEAT)  /* "repeatable" prefix */ )
+    {
+        MP_VERBOSE(mpctx, "Dropping command '%s' from auto-repeated key.\n",
+                   cmd->cmd->original);
+        return;
+    }
+
+    double scale = 1;
+    int scale_units = cmd->cmd->scale_units;
+    if (check_property_scalable(property, mpctx)) {
+        scale = cmd->cmd->scale;
+        scale_units = 1;
+    }
+
+    for (int i = 0; i < scale_units; i++) {
+        struct m_property_switch_arg s = {
+            .inc = cmd->args[1].v.d * scale,
+            .wrap = is_cycle,
+        };
+        change_property_cmd(cmd, property, M_PROPERTY_SWITCH, &s);
+        if (!cmd->success)
+            return;
+    }
+}
+
+static void cmd_multiply(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+
+    change_property_cmd(cmd, cmd->args[0].v.s,
+                        M_PROPERTY_MULTIPLY, &cmd->args[1].v.d);
+}
+
+static void cmd_frame_step(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    if (!mpctx->playback_initialized) {
+        cmd->success = false;
+        return;
+    }
+
+    if (cmd->cmd->is_up_down) {
+        if (cmd->cmd->is_up) {
+            if (mpctx->step_frames < 1)
+                set_pause_state(mpctx, true);
+        } else {
+            if (cmd->cmd->repeated) {
+                set_pause_state(mpctx, false);
+            } else {
+                add_step_frame(mpctx, 1);
+            }
+        }
+    } else {
+        add_step_frame(mpctx, 1);
+    }
+}
+
+static void cmd_frame_back_step(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    if (!mpctx->playback_initialized) {
+        cmd->success = false;
+        return;
+    }
+
+    add_step_frame(mpctx, -1);
+}
+
+static void cmd_quit(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    bool write_watch_later = *(bool *)cmd->priv;
+    if (write_watch_later || mpctx->opts->position_save_on_quit)
+        mp_write_watch_later_conf(mpctx);
+    mpctx->stop_play = PT_QUIT;
+    mpctx->quit_custom_rc = cmd->args[0].v.i;
+    mpctx->has_quit_custom_rc = true;
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_playlist_next_prev(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int dir = *(int *)cmd->priv;
+    int force = cmd->args[0].v.i;
+
+    struct playlist_entry *e = mp_next_file(mpctx, dir, force);
+    if (!e && !force) {
+        cmd->success = false;
+        return;
+    }
+
+    mp_set_playlist_entry(mpctx, e);
+    if (cmd->on_osd & MP_ON_OSD_MSG)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_CURRENT_FILE;
+}
+
+static void cmd_playlist_next_prev_playlist(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int direction = *(int *)cmd->priv;
+
+    struct playlist_entry *entry =
+        playlist_get_first_in_next_playlist(mpctx->playlist, direction);
+
+    if (!entry && mpctx->opts->loop_times != 1 && mpctx->playlist->current) {
+        entry = direction > 0 ? playlist_get_first(mpctx->playlist)
+                              : playlist_get_last(mpctx->playlist);
+
+        if (entry && entry->playlist_path &&
+            mpctx->playlist->current->playlist_path &&
+            strcmp(entry->playlist_path,
+                   mpctx->playlist->current->playlist_path) == 0)
+            entry = NULL;
+
+        if (direction > 0 && entry && mpctx->opts->loop_times > 1) {
+            mpctx->opts->loop_times--;
+            m_config_notify_change_opt_ptr(mpctx->mconfig,
+                                           &mpctx->opts->loop_times);
+        }
+
+        if (direction < 0)
+            entry = playlist_get_first_in_same_playlist(
+                        entry, mpctx->playlist->current->playlist_path);
+    }
+
+    if (!entry) {
+        cmd->success = false;
+        return;
+    }
+
+    mp_set_playlist_entry(mpctx, entry);
+    if (cmd->on_osd & MP_ON_OSD_MSG)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_CURRENT_FILE;
+}
+
+static void cmd_playlist_play_index(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    struct playlist *pl = mpctx->playlist;
+    int pos = cmd->args[0].v.i;
+
+    if (pos == -2)
+        pos = playlist_entry_to_index(pl, pl->current);
+
+    mp_set_playlist_entry(mpctx, playlist_entry_from_index(pl, pos));
+    if (cmd->on_osd & MP_ON_OSD_MSG)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_CURRENT_FILE;
+}
+
+static void cmd_sub_step_seek(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    bool step = *(bool *)cmd->priv;
+    int track_ind = cmd->args[1].v.i;
+
+    if (!mpctx->playback_initialized) {
+        cmd->success = false;
+        return;
+    }
+
+    struct track *track = mpctx->current_track[track_ind][STREAM_SUB];
+    struct dec_sub *sub = track ? track->d_sub : NULL;
+    double refpts = get_current_time(mpctx);
+    if (sub && refpts != MP_NOPTS_VALUE) {
+        double a[2];
+        a[0] = refpts;
+        a[1] = cmd->args[0].v.i;
+        if (sub_control(sub, SD_CTRL_SUB_STEP, a) > 0) {
+            if (step) {
+                mpctx->opts->subs_rend->sub_delay -= a[0] - refpts;
+                m_config_notify_change_opt_ptr_notify(mpctx->mconfig,
+                                               &mpctx->opts->subs_rend->sub_delay);
+                show_property_osd(mpctx, "sub-delay", cmd->on_osd);
+            } else {
+                // We can easily seek/step to the wrong subtitle line (because
+                // video frame PTS and sub PTS rarely match exactly). Add an
+                // arbitrary forward offset as a workaround.
+                a[0] += SUB_SEEK_OFFSET;
+                mark_seek(mpctx);
+                queue_seek(mpctx, MPSEEK_ABSOLUTE, a[0], MPSEEK_EXACT,
+                           MPSEEK_FLAG_DELAY);
+                set_osd_function(mpctx, (a[0] > refpts) ? OSD_FFW : OSD_REW);
+                if (cmd->seek_bar_osd)
+                    mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
+                if (cmd->seek_msg_osd)
+                    mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
+            }
+        }
+    }
+}
+
+static void cmd_print_text(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    MP_INFO(mpctx, "%s\n", cmd->args[0].v.s);
+}
+
+static void cmd_show_text(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int osd_duration = mpctx->opts->osd_duration;
+
+    // if no argument supplied use default osd_duration, else <arg> ms.
+    set_osd_msg(mpctx, cmd->args[2].v.i,
+                (cmd->args[1].v.i < 0 ? osd_duration : cmd->args[1].v.i),
+                "%s", cmd->args[0].v.s);
+}
+
+static void cmd_expand_text(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    cmd->result = (mpv_node){
+        .format = MPV_FORMAT_STRING,
+        .u.string = mp_property_expand_string(mpctx, cmd->args[0].v.s)
+    };
+}
+
+static void cmd_expand_path(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    cmd->result = (mpv_node){
+        .format = MPV_FORMAT_STRING,
+        .u.string = mp_get_user_path(NULL, mpctx->global, cmd->args[0].v.s)
+    };
+}
+
+static void cmd_loadfile(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    char *filename = cmd->args[0].v.s;
+    int append = cmd->args[1].v.i;
+
+    if (!append)
+        playlist_clear(mpctx->playlist);
+
+    struct playlist_entry *entry = playlist_entry_new(filename);
+    if (cmd->args[2].v.str_list) {
+        char **pairs = cmd->args[2].v.str_list;
+        for (int i = 0; pairs[i] && pairs[i + 1]; i += 2)
+            playlist_entry_add_param(entry, bstr0(pairs[i]), bstr0(pairs[i + 1]));
+    }
+    playlist_add(mpctx->playlist, entry);
+
+    struct mpv_node *res = &cmd->result;
+    node_init(res, MPV_FORMAT_NODE_MAP, NULL);
+    node_map_add_int64(res, "playlist_entry_id", entry->id);
+
+    if (!append || (append == 2 && !mpctx->playlist->current)) {
+        if (mpctx->opts->position_save_on_quit) // requested in issue #1148
+            mp_write_watch_later_conf(mpctx);
+        mp_set_playlist_entry(mpctx, entry);
+    }
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_loadlist(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    char *filename = cmd->args[0].v.s;
+    int append = cmd->args[1].v.i;
+
+    struct playlist *pl = playlist_parse_file(filename, cmd->abort->cancel,
+                                              mpctx->global);
+    if (pl) {
+        prepare_playlist(mpctx, pl);
+        struct playlist_entry *new = pl->current;
+        if (!append)
+            playlist_clear(mpctx->playlist);
+        struct playlist_entry *first = playlist_entry_from_index(pl, 0);
+        int num_entries = pl->num_entries;
+        playlist_append_entries(mpctx->playlist, pl);
+        talloc_free(pl);
+
+        if (!new)
+            new = playlist_get_first(mpctx->playlist);
+
+        if ((!append || (append == 2 && !mpctx->playlist->current)) && new)
+            mp_set_playlist_entry(mpctx, new);
+
+        struct mpv_node *res = &cmd->result;
+        node_init(res, MPV_FORMAT_NODE_MAP, NULL);
+        if (num_entries) {
+            node_map_add_int64(res, "playlist_entry_id", first->id);
+            node_map_add_int64(res, "num_entries", num_entries);
+        }
+
+        mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+        mp_wakeup_core(mpctx);
+    } else {
+        MP_ERR(mpctx, "Unable to load playlist %s.\n", filename);
+        cmd->success = false;
+    }
+}
+
+static void cmd_playlist_clear(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    // Supposed to clear the playlist, except the currently played item.
+    if (mpctx->playlist->current_was_replaced)
+        mpctx->playlist->current = NULL;
+    playlist_clear_except_current(mpctx->playlist);
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_playlist_remove(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    struct playlist_entry *e = playlist_entry_from_index(mpctx->playlist,
+                                                         cmd->args[0].v.i);
+    if (cmd->args[0].v.i < 0)
+        e = mpctx->playlist->current;
+    if (!e) {
+        cmd->success = false;
+        return;
+    }
+
+    // Can't play a removed entry
+    if (mpctx->playlist->current == e && !mpctx->stop_play)
+        mpctx->stop_play = PT_NEXT_ENTRY;
+    playlist_remove(mpctx->playlist, e);
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_playlist_move(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    struct playlist_entry *e1 = playlist_entry_from_index(mpctx->playlist,
+                                                          cmd->args[0].v.i);
+    struct playlist_entry *e2 = playlist_entry_from_index(mpctx->playlist,
+                                                          cmd->args[1].v.i);
+    if (!e1) {
+        cmd->success = false;
+        return;
+    }
+
+    playlist_move(mpctx->playlist, e1, e2);
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+}
+
+static void cmd_playlist_shuffle(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    playlist_shuffle(mpctx->playlist);
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+}
+
+static void cmd_playlist_unshuffle(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    playlist_unshuffle(mpctx->playlist);
+    mp_notify(mpctx, MP_EVENT_CHANGE_PLAYLIST, NULL);
+}
+
+static void cmd_stop(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int flags = cmd->args[0].v.i;
+
+    if (!(flags & 1))
+        playlist_clear(mpctx->playlist);
+
+    if (mpctx->opts->player_idle_mode < 2 &&
+        mpctx->opts->position_save_on_quit)
+    {
+        mp_write_watch_later_conf(mpctx);
+    }
+
+    if (mpctx->stop_play != PT_QUIT)
+        mpctx->stop_play = PT_STOP;
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_show_progress(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    mpctx->add_osd_seek_info |=
+            (cmd->msg_osd ? OSD_SEEK_INFO_TEXT : 0) |
+            (cmd->bar_osd ? OSD_SEEK_INFO_BAR : 0);
+
+    // If we got neither (i.e. no-osd) force both like osd-auto.
+    if (!mpctx->add_osd_seek_info)
+        mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT | OSD_SEEK_INFO_BAR;
+    mpctx->osd_force_update = true;
+    mp_wakeup_core(mpctx);
+}
+
+static void cmd_track_add(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int type = *(int *)cmd->priv;
+    bool is_albumart = type == STREAM_VIDEO &&
+                       cmd->args[4].v.b;
+
+    if (mpctx->stop_play) {
+        cmd->success = false;
+        return;
+    }
+
+    if (cmd->args[1].v.i == 2) {
+        struct track *t = find_track_with_url(mpctx, type, cmd->args[0].v.s);
+        if (t) {
+            if (mpctx->playback_initialized) {
+                mp_switch_track(mpctx, t->type, t, FLAG_MARK_SELECTION);
+                print_track_list(mpctx, "Track switched:");
+            } else {
+                mark_track_selection(mpctx, 0, t->type, t->user_tid);
+            }
+            return;
+        }
+    }
+    int first = mp_add_external_file(mpctx, cmd->args[0].v.s, type,
+                                     cmd->abort->cancel, is_albumart);
+    if (first < 0) {
+        cmd->success = false;
+        return;
+    }
+
+    for (int n = first; n < mpctx->num_tracks; n++) {
+        struct track *t = mpctx->tracks[n];
+        if (cmd->args[1].v.i == 1) {
+            t->no_default = true;
+        } else if (n == first) {
+            if (mpctx->playback_initialized) {
+                mp_switch_track(mpctx, t->type, t, FLAG_MARK_SELECTION);
+            } else {
+                mark_track_selection(mpctx, 0, t->type, t->user_tid);
+            }
+        }
+        char *title = cmd->args[2].v.s;
+        if (title && title[0])
+            t->title = talloc_strdup(t, title);
+        char *lang = cmd->args[3].v.s;
+        if (lang && lang[0])
+            t->lang = talloc_strdup(t, lang);
+    }
+
+    if (mpctx->playback_initialized)
+        print_track_list(mpctx, "Track added:");
+}
+
+static void cmd_track_remove(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int type = *(int *)cmd->priv;
+
+    struct track *t = mp_track_by_tid(mpctx, type, cmd->args[0].v.i);
+    if (!t) {
+        cmd->success = false;
+        return;
+    }
+
+    mp_remove_track(mpctx, t);
+    if (mpctx->playback_initialized)
+        print_track_list(mpctx, "Track removed:");
+}
+
+static void cmd_track_reload(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int type = *(int *)cmd->priv;
+
+    if (!mpctx->playback_initialized) {
+        MP_ERR(mpctx, "Cannot reload while not initialized.\n");
+        cmd->success = false;
+        return;
+    }
+
+    struct track *t = mp_track_by_tid(mpctx, type, cmd->args[0].v.i);
+    int nt_num = -1;
+
+    if (t && t->is_external && t->external_filename) {
+        char *filename = talloc_strdup(NULL, t->external_filename);
+        bool is_albumart = t->attached_picture;
+        mp_remove_track(mpctx, t);
+        nt_num = mp_add_external_file(mpctx, filename, type, cmd->abort->cancel,
+                                      is_albumart);
+        talloc_free(filename);
+    }
+
+    if (nt_num < 0) {
+        cmd->success = false;
+        return;
+    }
+
+    struct track *nt = mpctx->tracks[nt_num];
+    mp_switch_track(mpctx, nt->type, nt, 0);
+    print_track_list(mpctx, "Reloaded:");
+}
+
+static void cmd_rescan_external_files(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    if (mpctx->stop_play) {
+        cmd->success = false;
+        return;
+    }
+
+    autoload_external_files(mpctx, cmd->abort->cancel);
+    if (!cmd->args[0].v.i && mpctx->playback_initialized) {
+        // somewhat fuzzy and not ideal
+        struct track *a = select_default_track(mpctx, 0, STREAM_AUDIO);
+        if (a && a->is_external)
+            mp_switch_track(mpctx, STREAM_AUDIO, a, 0);
+        struct track *s = select_default_track(mpctx, 0, STREAM_SUB);
+        if (s && s->is_external)
+            mp_switch_track(mpctx, STREAM_SUB, s, 0);
+
+        print_track_list(mpctx, "Track list:");
+    }
+}
+
+static void cmd_run(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    char **args = talloc_zero_array(NULL, char *, cmd->num_args + 1);
+    for (int n = 0; n < cmd->num_args; n++)
+        args[n] = cmd->args[n].v.s;
+    mp_msg_flush_status_line(mpctx->log);
+    struct mp_subprocess_opts opts = {
+        .exe = args[0],
+        .args = args,
+        .fds = { {0, .src_fd = 0}, {1, .src_fd = 1}, {2, .src_fd = 2} },
+        .num_fds = 3,
+        .detach = true,
+    };
+    struct mp_subprocess_result res;
+    mp_subprocess2(&opts, &res);
+    if (res.error < 0) {
+        mp_err(mpctx->log, "Starting subprocess failed: %s\n",
+               mp_subprocess_err_str(res.error));
+    }
+    talloc_free(args);
+}
+
+struct subprocess_fd_ctx {
+    struct mp_log *log;
+    void* talloc_ctx;
+    int64_t max_size;
+    int msgl;
+    bool capture;
+    bstr output;
+};
+
+static void subprocess_read(void *p, char *data, size_t size)
+{
+    struct subprocess_fd_ctx *ctx = p;
+    if (ctx->capture) {
+        if (ctx->output.len < ctx->max_size)
+            bstr_xappend(ctx->talloc_ctx, &ctx->output, (bstr){data, size});
+    } else {
+        mp_msg(ctx->log, ctx->msgl, "%.*s", (int)size, data);
+    }
+}
+
+static void subprocess_write(void *p)
+{
+    // Unused; we write a full buffer.
+}
+
+static void cmd_subprocess(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    char **args = cmd->args[0].v.str_list;
+    bool playback_only = cmd->args[1].v.b;
+    bool detach = cmd->args[5].v.b;
+    char **env = cmd->args[6].v.str_list;
+    bstr stdin_data = bstr0(cmd->args[7].v.s);
+    bool passthrough_stdin = cmd->args[8].v.b;
+
+    if (env && !env[0])
+        env = NULL; // do not actually set an empty environment
+
+    if (!args || !args[0]) {
+        MP_ERR(mpctx, "program name missing\n");
+        cmd->success = false;
+        return;
+    }
+
+    if (stdin_data.len && passthrough_stdin) {
+        MP_ERR(mpctx, "both stdin_data and passthrough_stdin set\n");
+        cmd->success = false;
+        return;
+    }
+
+    void *tmp = talloc_new(NULL);
+
+    struct mp_log *fdlog = mp_log_new(tmp, mpctx->log, cmd->cmd->sender);
+    struct subprocess_fd_ctx fdctx[3];
+    for (int fd = 0; fd < 3; fd++) {
+        fdctx[fd] = (struct subprocess_fd_ctx) {
+            .log = fdlog,
+            .talloc_ctx = tmp,
+            .max_size = cmd->args[2].v.i,
+            .msgl = fd == 2 ? MSGL_ERR : MSGL_INFO,
+        };
+    }
+    fdctx[1].capture = cmd->args[3].v.b;
+    fdctx[2].capture = cmd->args[4].v.b;
+
+    mp_mutex_lock(&mpctx->abort_lock);
+    cmd->abort->coupled_to_playback = playback_only;
+    mp_abort_recheck_locked(mpctx, cmd->abort);
+    mp_mutex_unlock(&mpctx->abort_lock);
+
+    mp_core_unlock(mpctx);
+
+    struct mp_subprocess_opts opts = {
+        .exe = args[0],
+        .args = args,
+        .env = env,
+        .cancel = cmd->abort->cancel,
+        .detach = detach,
+        .fds = {
+            {
+                .fd = 0, // stdin
+                .src_fd = passthrough_stdin ? 0 : -1,
+            },
+        },
+        .num_fds = 1,
+    };
+
+    // stdout, stderr
+    for (int fd = 1; fd < 3; fd++) {
+        bool capture = fdctx[fd].capture || !detach;
+        opts.fds[opts.num_fds++] = (struct mp_subprocess_fd){
+            .fd = fd,
+            .src_fd = capture ? -1 : fd,
+            .on_read = capture ? subprocess_read : NULL,
+            .on_read_ctx = &fdctx[fd],
+        };
+    }
+    // stdin
+    if (stdin_data.len) {
+        opts.fds[0] = (struct mp_subprocess_fd){
+            .fd = 0,
+            .src_fd = -1,
+            .on_write = subprocess_write,
+            .on_write_ctx = &fdctx[0],
+            .write_buf = &stdin_data,
+        };
+    }
+
+    struct mp_subprocess_result sres;
+    mp_subprocess2(&opts, &sres);
+    int status = sres.exit_status;
+    char *error = NULL;
+    if (sres.error < 0) {
+        error = (char *)mp_subprocess_err_str(sres.error);
+        status = sres.error;
+    }
+
+    mp_core_lock(mpctx);
+
+    struct mpv_node *res = &cmd->result;
+    node_init(res, MPV_FORMAT_NODE_MAP, NULL);
+    node_map_add_int64(res, "status", status);
+    node_map_add_flag(res, "killed_by_us", status == MP_SUBPROCESS_EKILLED_BY_US);
+    node_map_add_string(res, "error_string", error ? error : "");
+    const char *sname[] = {NULL, "stdout", "stderr"};
+    for (int fd = 1; fd < 3; fd++) {
+        if (!fdctx[fd].capture)
+            continue;
+        struct mpv_byte_array *ba =
+            node_map_add(res, sname[fd], MPV_FORMAT_BYTE_ARRAY)->u.ba;
+        *ba = (struct mpv_byte_array){
+            .data = talloc_steal(ba, fdctx[fd].output.start),
+            .size = fdctx[fd].output.len,
+        };
+    }
+
+    talloc_free(tmp);
+}
+
+static void cmd_enable_input_section(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    mp_input_enable_section(mpctx->input, cmd->args[0].v.s, cmd->args[1].v.i);
+}
+
+static void cmd_disable_input_section(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    mp_input_disable_section(mpctx->input, cmd->args[0].v.s);
+}
+
+static void cmd_define_input_section(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    mp_input_define_section(mpctx->input, cmd->args[0].v.s, "<api>",
+                            cmd->args[1].v.s, !cmd->args[2].v.i,
+                            cmd->cmd->sender);
+}
+
+static void cmd_ab_loop(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int osd_duration = mpctx->opts->osd_duration;
+    int osdl = cmd->msg_osd ? 1 : OSD_LEVEL_INVISIBLE;
+
+    double now = get_current_time(mpctx);
+    if (mpctx->opts->ab_loop[0] == MP_NOPTS_VALUE) {
+        mp_property_do("ab-loop-a", M_PROPERTY_SET, &now, mpctx);
+        show_property_osd(mpctx, "ab-loop-a", cmd->on_osd);
+    } else if (mpctx->opts->ab_loop[1] == MP_NOPTS_VALUE) {
+        mp_property_do("ab-loop-b", M_PROPERTY_SET, &now, mpctx);
+        show_property_osd(mpctx, "ab-loop-b", cmd->on_osd);
+    } else {
+        now = MP_NOPTS_VALUE;
+        mp_property_do("ab-loop-a", M_PROPERTY_SET, &now, mpctx);
+        mp_property_do("ab-loop-b", M_PROPERTY_SET, &now, mpctx);
+        set_osd_msg(mpctx, osdl, osd_duration, "Clear A-B loop");
+    }
+}
+
+static void cmd_align_cache_ab(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    if (!mpctx->demuxer)
+        return;
+
+    double a = demux_probe_cache_dump_target(mpctx->demuxer,
+                                             mpctx->opts->ab_loop[0], false);
+    double b = demux_probe_cache_dump_target(mpctx->demuxer,
+                                             mpctx->opts->ab_loop[1], true);
+
+    mp_property_do("ab-loop-a", M_PROPERTY_SET, &a, mpctx);
+    mp_property_do("ab-loop-b", M_PROPERTY_SET, &b, mpctx);
+
+    // Happens to cover both properties.
+    show_property_osd(mpctx, "ab-loop-b", cmd->on_osd);
+}
+
+static void cmd_drop_buffers(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    reset_playback_state(mpctx);
+
+    if (mpctx->demuxer)
+        demux_flush(mpctx->demuxer);
+}
+
+static void cmd_ao_reload(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    reload_audio_output(mpctx);
+}
+
+static void cmd_filter(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int type = *(int *)cmd->priv;
+    cmd->success = edit_filters_osd(mpctx, type, cmd->args[0].v.s,
+                                    cmd->args[1].v.s, cmd->msg_osd) >= 0;
+}
+
+static void cmd_filter_command(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int type = *(int *)cmd->priv;
+
+    struct mp_output_chain *chain = NULL;
+    if (type == STREAM_VIDEO)
+        chain = mpctx->vo_chain ? mpctx->vo_chain->filter : NULL;
+    if (type == STREAM_AUDIO)
+        chain = mpctx->ao_chain ? mpctx->ao_chain->filter : NULL;
+    if (!chain) {
+        cmd->success = false;
+        return;
+    }
+    struct mp_filter_command filter_cmd = {
+        .type = MP_FILTER_COMMAND_TEXT,
+        .target = cmd->args[3].v.s,
+        .cmd = cmd->args[1].v.s,
+        .arg = cmd->args[2].v.s,
+    };
+    cmd->success = mp_output_chain_command(chain, cmd->args[0].v.s, &filter_cmd);
+}
+
+static void cmd_script_binding(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct mp_cmd *incmd = cmd->cmd;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    mpv_event_client_message event = {0};
+    char *name = cmd->args[0].v.s;
+    if (!name || !name[0]) {
+        cmd->success = false;
+        return;
+    }
+
+    char *sep = strchr(name, '/');
+    char *target = NULL;
+    char space[MAX_CLIENT_NAME];
+    if (sep) {
+        snprintf(space, sizeof(space), "%.*s", (int)(sep - name), name);
+        target = space;
+        name = sep + 1;
+    }
+    char state[3] = {'p', incmd->is_mouse_button ? 'm' : '-'};
+    if (incmd->is_up_down)
+        state[0] = incmd->repeated ? 'r' : (incmd->is_up ? 'u' : 'd');
+    event.num_args = 5;
+    event.args = (const char*[5]){"key-binding", name, state,
+                                  incmd->key_name ? incmd->key_name : "",
+                                  incmd->key_text ? incmd->key_text : ""};
+    if (mp_client_send_event_dup(mpctx, target,
+                                 MPV_EVENT_CLIENT_MESSAGE, &event) < 0)
+    {
+        MP_VERBOSE(mpctx, "Can't find script '%s' when handling input.\n",
+                    target ? target : "-");
+        cmd->success = false;
+    }
+}
+
+static void cmd_script_message_to(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    mpv_event_client_message *event = talloc_ptrtype(NULL, event);
+    *event = (mpv_event_client_message){0};
+    for (int n = 1; n < cmd->num_args; n++) {
+        MP_TARRAY_APPEND(event, event->args, event->num_args,
+                         talloc_strdup(event, cmd->args[n].v.s));
+    }
+    if (mp_client_send_event(mpctx, cmd->args[0].v.s, 0,
+                                MPV_EVENT_CLIENT_MESSAGE, event) < 0)
+    {
+        MP_VERBOSE(mpctx, "Can't find script '%s' to send message to.\n",
+                   cmd->args[0].v.s);
+        cmd->success = false;
+    }
+}
+
+static void cmd_script_message(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    const char **args = talloc_array(NULL, const char *, cmd->num_args);
+    mpv_event_client_message event = {.args = args};
+    for (int n = 0; n < cmd->num_args; n++)
+        event.args[event.num_args++] = cmd->args[n].v.s;
+    mp_client_broadcast_event(mpctx, MPV_EVENT_CLIENT_MESSAGE, &event);
+    talloc_free(args);
+}
+
+static void cmd_ignore(void *p)
+{
+}
+
+static void cmd_write_watch_later_config(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    mp_write_watch_later_conf(mpctx);
+}
+
+static void cmd_delete_watch_later_config(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    char *filename = cmd->args[0].v.s;
+    if (filename && !*filename)
+        filename = NULL;
+    mp_delete_watch_later_conf(mpctx, filename);
+}
+
+static void cmd_mouse(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int pre_key = 0;
+
+    const int x = cmd->args[0].v.i, y = cmd->args[1].v.i;
+    int button = cmd->args[2].v.i;
+
+    if (mpctx->video_out && mpctx->video_out->config_ok) {
+        int oldx, oldy, oldhover;
+        mp_input_get_mouse_pos(mpctx->input, &oldx, &oldy, &oldhover);
+        struct mp_osd_res vo_res = osd_get_vo_res(mpctx->osd);
+
+        // TODO: VOs don't send outside positions. should we abort if outside?
+        int hover = x >= 0 && y >= 0 && x < vo_res.w && y < vo_res.h;
+
+        if (vo_res.w && vo_res.h && hover != oldhover)
+            pre_key = hover ? MP_KEY_MOUSE_ENTER : MP_KEY_MOUSE_LEAVE;
+    }
+
+    if (button == -1) {// no button
+        if (pre_key)
+            mp_input_put_key_artificial(mpctx->input, pre_key);
+        mp_input_set_mouse_pos_artificial(mpctx->input, x, y);
+        return;
+    }
+    if (button < 0 || button >= MP_KEY_MOUSE_BTN_COUNT) {// invalid button
+        MP_ERR(mpctx, "%d is not a valid mouse button number.\n", button);
+        cmd->success = false;
+        return;
+    }
+    const bool dbc = cmd->args[3].v.i;
+    if (dbc && button > (MP_MBTN_RIGHT - MP_MBTN_BASE)) {
+        MP_ERR(mpctx, "%d is not a valid mouse button for double-clicks.\n",
+               button);
+        cmd->success = false;
+        return;
+    }
+    button += dbc ? MP_MBTN_DBL_BASE : MP_MBTN_BASE;
+    if (pre_key)
+        mp_input_put_key_artificial(mpctx->input, pre_key);
+    mp_input_set_mouse_pos_artificial(mpctx->input, x, y);
+    mp_input_put_key_artificial(mpctx->input, button);
+}
+
+static void cmd_key(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+    int action = *(int *)cmd->priv;
+
+    const char *key_name = cmd->args[0].v.s;
+    if (key_name[0] == '\0' && action == MP_KEY_STATE_UP) {
+        mp_input_put_key_artificial(mpctx->input, MP_INPUT_RELEASE_ALL);
+    } else {
+        int code = mp_input_get_key_from_name(key_name);
+        if (code < 0) {
+            MP_ERR(mpctx, "%s is not a valid input name.\n", key_name);
+            cmd->success = false;
+            return;
+        }
+        mp_input_put_key_artificial(mpctx->input, code | action);
+    }
+}
+
+static void cmd_key_bind(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    int code = mp_input_get_key_from_name(cmd->args[0].v.s);
+    if (code < 0) {
+        MP_ERR(mpctx, "%s is not a valid input name.\n", cmd->args[0].v.s);
+        cmd->success = false;
+        return;
+    }
+    const char *target_cmd = cmd->args[1].v.s;
+    mp_input_bind_key(mpctx->input, code, bstr0(target_cmd));
+}
+
+static void cmd_apply_profile(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    char *profile = cmd->args[0].v.s;
+    int mode = cmd->args[1].v.i;
+    if (mode == 0) {
+        cmd->success = m_config_set_profile(mpctx->mconfig, profile, 0) >= 0;
+    } else {
+        cmd->success = m_config_restore_profile(mpctx->mconfig, profile) >= 0;
+    }
+}
+
+static void cmd_load_script(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    char *script = cmd->args[0].v.s;
+    int64_t id = mp_load_user_script(mpctx, script);
+    if (id > 0) {
+        struct mpv_node *res = &cmd->result;
+        node_init(res, MPV_FORMAT_NODE_MAP, NULL);
+        node_map_add_int64(res, "client_id", id);
+    } else {
+        cmd->success = false;
+    }
+}
+
+static void cache_dump_poll(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+    struct mp_cmd_ctx *cmd = ctx->cache_dump_cmd;
+
+    if (!cmd)
+        return;
+
+    // Can't close demuxer without stopping dumping.
+    assert(mpctx->demuxer);
+
+    if (mp_cancel_test(cmd->abort->cancel)) {
+        // Synchronous abort. In particular, the dump command shall not report
+        // completion to the user before the dump target file was closed.
+        demux_cache_dump_set(mpctx->demuxer, 0, 0, NULL);
+        assert(demux_cache_dump_get_status(mpctx->demuxer) <= 0);
+    }
+
+    int status = demux_cache_dump_get_status(mpctx->demuxer);
+    if (status <= 0) {
+        if (status < 0) {
+            mp_cmd_msg(cmd, MSGL_ERR, "Cache dumping stopped due to error.");
+            cmd->success = false;
+        } else {
+            mp_cmd_msg(cmd, MSGL_INFO, "Cache dumping successfully ended.");
+            cmd->success = true;
+        }
+        ctx->cache_dump_cmd = NULL;
+        mp_cmd_ctx_complete(cmd);
+    }
+}
+
+void mp_abort_cache_dumping(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+
+    if (ctx->cache_dump_cmd)
+        mp_cancel_trigger(ctx->cache_dump_cmd->abort->cancel);
+    cache_dump_poll(mpctx);
+    assert(!ctx->cache_dump_cmd); // synchronous abort, must have worked
+}
+
+static void run_dump_cmd(struct mp_cmd_ctx *cmd, double start, double end,
+                         char *filename)
+{
+    struct MPContext *mpctx = cmd->mpctx;
+    struct command_ctx *ctx = mpctx->command_ctx;
+
+    mp_abort_cache_dumping(mpctx);
+
+    if (!mpctx->demuxer) {
+        mp_cmd_msg(cmd, MSGL_ERR, "No demuxer open.");
+        cmd->success = false;
+        mp_cmd_ctx_complete(cmd);
+        return;
+    }
+
+    mp_cmd_msg(cmd, MSGL_INFO, "Cache dumping started.");
+
+    if (!demux_cache_dump_set(mpctx->demuxer, start, end, filename)) {
+        mp_cmd_msg(cmd, MSGL_INFO, "Cache dumping stopped.");
+        mp_cmd_ctx_complete(cmd);
+        return;
+    }
+
+    ctx->cache_dump_cmd = cmd;
+    cache_dump_poll(mpctx);
+}
+
+static void cmd_dump_cache(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+
+    run_dump_cmd(cmd, cmd->args[0].v.d, cmd->args[1].v.d, cmd->args[2].v.s);
+}
+
+static void cmd_dump_cache_ab(void *p)
+{
+    struct mp_cmd_ctx *cmd = p;
+    struct MPContext *mpctx = cmd->mpctx;
+
+    run_dump_cmd(cmd, mpctx->opts->ab_loop[0], mpctx->opts->ab_loop[1],
+                 cmd->args[0].v.s);
+}
+
+/* This array defines all known commands.
+ * The first field the command name used in libmpv and input.conf.
+ * The second field is the handler function (see mp_cmd_def.handler and
+ * run_command()).
+ * Then comes the definition of each argument. They are defined like options,
+ * except that the result is parsed into mp_cmd.args[] (thus the option variable
+ * is a field in the mp_cmd_arg union field). Arguments are optional if either
+ * defval is set (usually via OPTDEF_ macros), or the MP_CMD_OPT_ARG flag is
+ * set, or if it's the last argument and .vararg is set. If .vararg is set, the
+ * command has an arbitrary number of arguments, all using the type indicated by
+ * the last argument (they are appended to mp_cmd.args[] starting at the last
+ * argument's index).
+ * Arguments have names, which can be used by named argument functions, e.g. in
+ * Lua with mp.command_native().
+ */
+
+// This does not specify the real destination of the command parameter values,
+// it just provides a dummy for the OPT_ macros. The real destination is an
+// array item  in mp_cmd.args[], using the index of the option definition.
+#define OPT_BASE_STRUCT struct mp_cmd_arg
+
+const struct mp_cmd_def mp_cmds[] = {
+    { "ignore", cmd_ignore, .is_ignore = true, .is_noisy = true, },
+
+    { "seek", cmd_seek,
+        {
+            {"target", OPT_TIME(v.d)},
+            {"flags", OPT_FLAGS(v.i,
+                {"relative", 4|0}, {"-", 4|0},
+                {"absolute-percent", 4|1},
+                {"absolute", 4|2},
+                {"relative-percent", 4|3},
+                {"keyframes", 32|8},
+                {"exact", 32|16}),
+                OPTDEF_INT(4|0)},
+            // backwards compatibility only
+            {"legacy", OPT_CHOICE(v.i,
+                {"unused", 0}, {"default-precise", 0},
+                {"keyframes", 32|8},
+                {"exact", 32|16}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .allow_auto_repeat = true,
+        .scalable = true,
+    },
+    { "revert-seek", cmd_revert_seek,
+        { {"flags", OPT_FLAGS(v.i, {"mark", 2|0}, {"mark-permanent", 2|1}),
+           .flags = MP_CMD_OPT_ARG} },
+    },
+    { "quit", cmd_quit, { {"code", OPT_INT(v.i), .flags = MP_CMD_OPT_ARG} },
+        .priv = &(const bool){0} },
+    { "quit-watch-later", cmd_quit, { {"code", OPT_INT(v.i),
+                                       .flags = MP_CMD_OPT_ARG} },
+        .priv = &(const bool){1} },
+    { "stop", cmd_stop,
+        { {"flags", OPT_FLAGS(v.i, {"keep-playlist", 1}), .flags = MP_CMD_OPT_ARG} }
+    },
+    { "frame-step", cmd_frame_step, .allow_auto_repeat = true,
+        .on_updown = true },
+    { "frame-back-step", cmd_frame_back_step, .allow_auto_repeat = true },
+    { "playlist-next", cmd_playlist_next_prev,
+        {
+            {"flags", OPT_CHOICE(v.i,
+                {"weak", 0},
+                {"force", 1}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){1},
+    },
+    { "playlist-prev", cmd_playlist_next_prev,
+        {
+            {"flags", OPT_CHOICE(v.i,
+                {"weak", 0},
+                {"force", 1}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){-1},
+    },
+    { "playlist-next-playlist", cmd_playlist_next_prev_playlist,
+        .priv = &(const int){1} },
+    { "playlist-prev-playlist", cmd_playlist_next_prev_playlist,
+        .priv = &(const int){-1} },
+    { "playlist-play-index", cmd_playlist_play_index,
+        {
+            {"index", OPT_CHOICE(v.i, {"current", -2}, {"none", -1}),
+                M_RANGE(-1, INT_MAX)},
+        }
+    },
+    { "playlist-shuffle", cmd_playlist_shuffle, },
+    { "playlist-unshuffle", cmd_playlist_unshuffle, },
+    { "sub-step", cmd_sub_step_seek,
+        {
+            {"skip", OPT_INT(v.i)},
+            {"flags", OPT_CHOICE(v.i,
+                {"primary", 0},
+                {"secondary", 1}),
+                OPTDEF_INT(0)},
+        },
+        .allow_auto_repeat = true,
+        .priv = &(const bool){true}
+    },
+    { "sub-seek", cmd_sub_step_seek,
+        {
+            {"skip", OPT_INT(v.i)},
+            {"flags", OPT_CHOICE(v.i,
+                {"primary", 0},
+                {"secondary", 1}),
+                OPTDEF_INT(0)},
+        },
+        .allow_auto_repeat = true,
+        .priv = &(const bool){false}
+    },
+    { "print-text", cmd_print_text, { {"text", OPT_STRING(v.s)} },
+        .is_noisy = true, .allow_auto_repeat = true },
+    { "show-text", cmd_show_text,
+        {
+            {"text", OPT_STRING(v.s)},
+            {"duration", OPT_INT(v.i), OPTDEF_INT(-1)},
+            {"level", OPT_INT(v.i), .flags = MP_CMD_OPT_ARG},
+        },
+        .is_noisy = true, .allow_auto_repeat = true},
+    { "expand-text", cmd_expand_text, { {"text", OPT_STRING(v.s)} },
+        .is_noisy = true },
+    { "expand-path", cmd_expand_path, { {"text", OPT_STRING(v.s)} },
+        .is_noisy = true },
+    { "show-progress", cmd_show_progress, .allow_auto_repeat = true,
+        .is_noisy = true },
+
+    { "sub-add", cmd_track_add,
+        {
+            {"url", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i,
+                {"select", 0}, {"auto", 1}, {"cached", 2}),
+                .flags = MP_CMD_OPT_ARG},
+            {"title", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+            {"lang", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){STREAM_SUB},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+    { "audio-add", cmd_track_add,
+        {
+            {"url", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i,
+                {"select", 0}, {"auto", 1}, {"cached", 2}),
+                .flags = MP_CMD_OPT_ARG},
+            {"title", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+            {"lang", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){STREAM_AUDIO},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+    { "video-add", cmd_track_add,
+        {
+            {"url", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i, {"select", 0}, {"auto", 1}, {"cached", 2}),
+                .flags = MP_CMD_OPT_ARG},
+            {"title", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+            {"lang", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+            {"albumart", OPT_BOOL(v.b), .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){STREAM_VIDEO},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+
+    { "sub-remove", cmd_track_remove, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_SUB}, },
+    { "audio-remove", cmd_track_remove, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_AUDIO}, },
+    { "video-remove", cmd_track_remove, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_VIDEO}, },
+
+    { "sub-reload", cmd_track_reload, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_SUB},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+    { "audio-reload", cmd_track_reload, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_AUDIO},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+    { "video-reload", cmd_track_reload, { {"id", OPT_INT(v.i), OPTDEF_INT(-1)} },
+        .priv = &(const int){STREAM_VIDEO},
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+
+    { "rescan-external-files", cmd_rescan_external_files,
+        {
+            {"flags", OPT_CHOICE(v.i,
+                {"keep-selection", 1},
+                {"reselect", 0}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .spawn_thread = true,
+        .can_abort = true,
+        .abort_on_playback_end = true,
+    },
+
+    { "screenshot", cmd_screenshot,
+        {
+            {"flags", OPT_FLAGS(v.i,
+                {"video", 4|0}, {"-", 4|0},
+                {"window", 4|1},
+                {"subtitles", 4|2},
+                {"each-frame", 8}),
+                OPTDEF_INT(4|2)},
+            // backwards compatibility
+            {"legacy", OPT_CHOICE(v.i,
+                {"unused", 0}, {"single", 0},
+                {"each-frame", 8}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .spawn_thread = true,
+    },
+    { "screenshot-to-file", cmd_screenshot_to_file,
+        {
+            {"filename", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i,
+                {"video", 0},
+                {"window", 1},
+                {"subtitles", 2}),
+                OPTDEF_INT(2)},
+        },
+        .spawn_thread = true,
+    },
+    { "screenshot-raw", cmd_screenshot_raw,
+        {
+            {"flags", OPT_CHOICE(v.i,
+                {"video", 0},
+                {"window", 1},
+                {"subtitles", 2}),
+                OPTDEF_INT(2)},
+        },
+    },
+    { "loadfile", cmd_loadfile,
+        {
+            {"url", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i,
+                {"replace", 0},
+                {"append", 1},
+                {"append-play", 2}),
+                .flags = MP_CMD_OPT_ARG},
+            {"options", OPT_KEYVALUELIST(v.str_list), .flags = MP_CMD_OPT_ARG},
+        },
+    },
+    { "loadlist", cmd_loadlist,
+        {
+            {"url", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i,
+                {"replace", 0},
+                {"append", 1},
+                {"append-play", 2}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .spawn_thread = true,
+        .can_abort = true,
+    },
+    { "playlist-clear", cmd_playlist_clear },
+    { "playlist-remove", cmd_playlist_remove, {
+        {"index", OPT_CHOICE(v.i, {"current", -1}),
+            .flags = MP_CMD_OPT_ARG, M_RANGE(0, INT_MAX)}, }},
+    { "playlist-move", cmd_playlist_move,  { {"index1", OPT_INT(v.i)},
+                                             {"index2", OPT_INT(v.i)}, }},
+    { "run", cmd_run, { {"command", OPT_STRING(v.s)},
+                        {"args", OPT_STRING(v.s)}, },
+        .vararg = true,
+    },
+    { "subprocess", cmd_subprocess,
+        {
+            {"args", OPT_STRINGLIST(v.str_list)},
+            {"playback_only", OPT_BOOL(v.b), OPTDEF_INT(1)},
+            {"capture_size", OPT_BYTE_SIZE(v.i64), M_RANGE(0, INT_MAX),
+                OPTDEF_INT64(64 * 1024 * 1024)},
+            {"capture_stdout", OPT_BOOL(v.b), .flags = MP_CMD_OPT_ARG},
+            {"capture_stderr", OPT_BOOL(v.b), .flags = MP_CMD_OPT_ARG},
+            {"detach", OPT_BOOL(v.b), .flags = MP_CMD_OPT_ARG},
+            {"env", OPT_STRINGLIST(v.str_list), .flags = MP_CMD_OPT_ARG},
+            {"stdin_data", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG},
+            {"passthrough_stdin", OPT_BOOL(v.b), .flags = MP_CMD_OPT_ARG},
+        },
+        .spawn_thread = true,
+        .can_abort = true,
+    },
+
+    { "set", cmd_set, {{"name", OPT_STRING(v.s)}, {"value", OPT_STRING(v.s)}}},
+    { "del", cmd_del, {{"name", OPT_STRING(v.s)}}},
+    { "change-list", cmd_change_list, { {"name", OPT_STRING(v.s)},
+                                        {"operation", OPT_STRING(v.s)},
+                                        {"value", OPT_STRING(v.s)} }},
+    { "add", cmd_add_cycle, { {"name", OPT_STRING(v.s)},
+                              {"value", OPT_DOUBLE(v.d), OPTDEF_DOUBLE(1)}, },
+        .allow_auto_repeat = true,
+        .scalable = true,
+    },
+    { "cycle", cmd_add_cycle, { {"name", OPT_STRING(v.s)},
+                                {"value", OPT_CYCLEDIR(v.d), OPTDEF_DOUBLE(1)}, },
+        .allow_auto_repeat = true,
+        .scalable = true,
+        .priv = "",
+    },
+    { "multiply", cmd_multiply, { {"name", OPT_STRING(v.s)},
+                                  {"value", OPT_DOUBLE(v.d)}},
+        .allow_auto_repeat = true},
+
+    { "cycle-values", cmd_cycle_values, { {"arg0", OPT_STRING(v.s)},
+                                          {"arg1", OPT_STRING(v.s)},
+                                          {"argN", OPT_STRING(v.s)}, },
+        .vararg = true},
+
+    { "enable-section", cmd_enable_input_section,
+        {
+            {"name", OPT_STRING(v.s)},
+            {"flags", OPT_FLAGS(v.i,
+                {"default", 0},
+                {"exclusive", MP_INPUT_EXCLUSIVE},
+                {"allow-hide-cursor", MP_INPUT_ALLOW_HIDE_CURSOR},
+                {"allow-vo-dragging", MP_INPUT_ALLOW_VO_DRAGGING}),
+                .flags = MP_CMD_OPT_ARG},
+        }
+    },
+    { "disable-section", cmd_disable_input_section,
+        {{"name", OPT_STRING(v.s)} }},
+    { "define-section", cmd_define_input_section,
+        {
+            {"name", OPT_STRING(v.s)},
+            {"contents", OPT_STRING(v.s)},
+            {"flags", OPT_CHOICE(v.i, {"default", 0}, {"force", 1}),
+                .flags = MP_CMD_OPT_ARG},
+        },
+    },
+
+    { "ab-loop", cmd_ab_loop },
+
+    { "drop-buffers", cmd_drop_buffers, },
+
+    { "af", cmd_filter, { {"operation", OPT_STRING(v.s)},
+                          {"value", OPT_STRING(v.s)}, },
+        .priv = &(const int){STREAM_AUDIO} },
+    { "vf", cmd_filter, { {"operation", OPT_STRING(v.s)},
+                          {"value", OPT_STRING(v.s)}, },
+        .priv = &(const int){STREAM_VIDEO} },
+
+    { "af-command", cmd_filter_command,
+        {
+            {"label", OPT_STRING(v.s)},
+            {"command", OPT_STRING(v.s)},
+            {"argument", OPT_STRING(v.s)},
+            {"target", OPT_STRING(v.s), OPTDEF_STR("all"),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){STREAM_AUDIO} },
+    { "vf-command", cmd_filter_command,
+        {
+            {"label", OPT_STRING(v.s)},
+            {"command", OPT_STRING(v.s)},
+            {"argument", OPT_STRING(v.s)},
+            {"target", OPT_STRING(v.s), OPTDEF_STR("all"),
+                .flags = MP_CMD_OPT_ARG},
+        },
+        .priv = &(const int){STREAM_VIDEO} },
+
+    { "ao-reload", cmd_ao_reload },
+
+    { "script-binding", cmd_script_binding, { {"name", OPT_STRING(v.s)} },
+        .allow_auto_repeat = true, .on_updown = true},
+
+    { "script-message", cmd_script_message, { {"args", OPT_STRING(v.s)} },
+        .vararg = true },
+    { "script-message-to", cmd_script_message_to, { {"target", OPT_STRING(v.s)},
+                                                    {"args", OPT_STRING(v.s)} },
+        .vararg = true },
+
+    { "overlay-add", cmd_overlay_add, { {"id", OPT_INT(v.i)},
+                                        {"x", OPT_INT(v.i)},
+                                        {"y", OPT_INT(v.i)},
+                                        {"file", OPT_STRING(v.s)},
+                                        {"offset", OPT_INT(v.i)},
+                                        {"fmt", OPT_STRING(v.s)},
+                                        {"w", OPT_INT(v.i)},
+                                        {"h", OPT_INT(v.i)},
+                                        {"stride", OPT_INT(v.i)}, }},
+    { "overlay-remove", cmd_overlay_remove, { {"id", OPT_INT(v.i)} } },
+
+    { "osd-overlay", cmd_osd_overlay,
+        {
+            {"id", OPT_INT64(v.i64)},
+            {"format", OPT_CHOICE(v.i, {"none", 0}, {"ass-events", 1})},
+            {"data", OPT_STRING(v.s)},
+            {"res_x", OPT_INT(v.i), OPTDEF_INT(0)},
+            {"res_y", OPT_INT(v.i), OPTDEF_INT(720)},
+            {"z", OPT_INT(v.i), OPTDEF_INT(0)},
+            {"hidden", OPT_BOOL(v.b), OPTDEF_INT(0)},
+            {"compute_bounds", OPT_BOOL(v.b), OPTDEF_INT(0)},
+        },
+        .is_noisy = true,
+    },
+
+    { "write-watch-later-config", cmd_write_watch_later_config },
+    { "delete-watch-later-config", cmd_delete_watch_later_config,
+        {{"filename", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG} }},
+
+    { "mouse", cmd_mouse, { {"x", OPT_INT(v.i)},
+                            {"y", OPT_INT(v.i)},
+                            {"button", OPT_INT(v.i), OPTDEF_INT(-1)},
+                            {"mode", OPT_CHOICE(v.i,
+                                {"single", 0}, {"double", 1}),
+                                .flags = MP_CMD_OPT_ARG}}},
+    { "keybind", cmd_key_bind, { {"name", OPT_STRING(v.s)},
+                                 {"cmd", OPT_STRING(v.s)} }},
+    { "keypress", cmd_key, { {"name", OPT_STRING(v.s)} },
+        .priv = &(const int){0}},
+    { "keydown", cmd_key, { {"name", OPT_STRING(v.s)} },
+        .priv = &(const int){MP_KEY_STATE_DOWN}},
+    { "keyup", cmd_key, { {"name", OPT_STRING(v.s), .flags = MP_CMD_OPT_ARG} },
+        .priv = &(const int){MP_KEY_STATE_UP}},
+
+    { "apply-profile", cmd_apply_profile, {
+        {"name", OPT_STRING(v.s)},
+        {"mode", OPT_CHOICE(v.i, {"apply", 0}, {"restore", 1}),
+            .flags = MP_CMD_OPT_ARG}, }
+    },
+
+    { "load-script", cmd_load_script, {{"filename", OPT_STRING(v.s)}} },
+
+    { "dump-cache", cmd_dump_cache, { {"start", OPT_TIME(v.d),
+                                        .flags = M_OPT_ALLOW_NO},
+                                      {"end", OPT_TIME(v.d),
+                                        .flags = M_OPT_ALLOW_NO},
+                                      {"filename", OPT_STRING(v.s)} },
+        .exec_async = true,
+        .can_abort = true,
+    },
+
+    { "ab-loop-dump-cache", cmd_dump_cache_ab, { {"filename", OPT_STRING(v.s)} },
+        .exec_async = true,
+        .can_abort = true,
+    },
+
+    { "ab-loop-align-cache", cmd_align_cache_ab },
+
+    {0}
+};
+
+#undef OPT_BASE_STRUCT
+#undef ARG
+
+void command_uninit(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+
+    assert(!ctx->cache_dump_cmd); // closing the demuxer must have aborted it
+
+    overlay_uninit(mpctx);
+    ao_hotplug_destroy(ctx->hotplug);
+
+    m_option_free(&script_props_type, &ctx->script_props);
+
+    talloc_free(mpctx->command_ctx);
+    mpctx->command_ctx = NULL;
+}
+
+void command_init(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = talloc(NULL, struct command_ctx);
+    *ctx = (struct command_ctx){
+        .last_seek_pts = MP_NOPTS_VALUE,
+    };
+    mpctx->command_ctx = ctx;
+
+    int num_base = MP_ARRAY_SIZE(mp_properties_base);
+    int num_opts = m_config_get_co_count(mpctx->mconfig);
+    ctx->properties =
+        talloc_zero_array(ctx, struct m_property, num_base + num_opts + 1);
+    memcpy(ctx->properties, mp_properties_base, sizeof(mp_properties_base));
+
+    int count = num_base;
+    for (int n = 0; n < num_opts; n++) {
+        struct m_config_option *co = m_config_get_co_index(mpctx->mconfig, n);
+        assert(co->name[0]);
+        if (co->opt->flags & M_OPT_NOPROP)
+            continue;
+
+        struct m_property prop = {
+            .name = co->name,
+            .call = mp_property_generic_option,
+            .is_option = true,
+        };
+
+        if (co->opt->type == &m_option_type_alias) {
+            prop.priv = co->opt->priv;
+
+            prop.call = co->opt->deprecation_message ?
+                            mp_property_deprecated_alias : mp_property_alias;
+
+            // Check whether this eventually arrives at a real option. If not,
+            // it's some CLI special handling thing. For example, "nosound" is
+            // mapped to "no-audio", which has CLI special-handling, and cannot
+            // be set as property.
+            struct m_config_option *co2 = co;
+            while (co2 && co2->opt->type == &m_option_type_alias) {
+                const char *alias = (const char *)co2->opt->priv;
+                co2 = m_config_get_co_raw(mpctx->mconfig, bstr0(alias));
+            }
+            if (!co2)
+                continue;
+        }
+
+        // The option might be covered by a manual property already.
+        if (m_property_list_find(ctx->properties, prop.name))
+            continue;
+
+        ctx->properties[count++] = prop;
+    }
+
+    node_init(&ctx->udata, MPV_FORMAT_NODE_MAP, NULL);
+    talloc_steal(ctx, ctx->udata.u.list);
+}
+
+static void command_event(struct MPContext *mpctx, int event, void *arg)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+
+    if (event == MPV_EVENT_START_FILE) {
+        ctx->last_seek_pts = MP_NOPTS_VALUE;
+        ctx->marked_pts = MP_NOPTS_VALUE;
+        ctx->marked_permanent = false;
+    }
+
+    if (event == MPV_EVENT_PLAYBACK_RESTART)
+        ctx->last_seek_time = mp_time_sec();
+
+    if (event == MPV_EVENT_END_FILE || event == MPV_EVENT_FILE_LOADED) {
+        // Update chapters - does nothing if something else is visible.
+        set_osd_bar_chapters(mpctx, OSD_BAR_SEEK);
+    }
+    if (event == MP_EVENT_WIN_STATE2)
+        ctx->cached_window_scale = 0;
+
+    if (event == MP_EVENT_METADATA_UPDATE) {
+        struct playlist_entry *const pe = mpctx->playing;
+        if (pe && !pe->title) {
+            const char *const name = find_non_filename_media_title(mpctx);
+            if (name && name[0]) {
+                pe->title = talloc_strdup(pe, name);
+                mp_notify_property(mpctx, "playlist");
+            }
+        }
+    }
+}
+
+void handle_command_updates(struct MPContext *mpctx)
+{
+    struct command_ctx *ctx = mpctx->command_ctx;
+
+    // This is a bit messy: ao_hotplug wakes up the player, and then we have
+    // to recheck the state. Then the client(s) will read the property.
+    if (ctx->hotplug && ao_hotplug_check_update(ctx->hotplug))
+        mp_notify_property(mpctx, "audio-device-list");
+
+    // Depends on polling demuxer wakeup callback notifications.
+    cache_dump_poll(mpctx);
+}
+
+void mp_notify(struct MPContext *mpctx, int event, void *arg)
+{
+    // The OSD can implicitly reference some properties.
+    mpctx->osd_idle_update = true;
+
+    command_event(mpctx, event, arg);
+
+    mp_client_broadcast_event(mpctx, event, arg);
+}
+
+static void update_priority(struct MPContext *mpctx)
+{
+#if HAVE_WIN32_DESKTOP
+    struct MPOpts *opts = mpctx->opts;
+    if (opts->w32_priority > 0)
+        SetPriorityClass(GetCurrentProcess(), opts->w32_priority);
+#endif
+}
+
+static void update_track_switch(struct MPContext *mpctx, int order, int type)
+{
+    if (!mpctx->playback_initialized)
+        return;
+
+    int tid = mpctx->opts->stream_id[order][type];
+    struct track *track;
+    if (tid == -1) {
+        // If "auto" reset to default track selection
+        track = select_default_track(mpctx, order, type);
+        mark_track_selection(mpctx, order, type, -1);
+    } else {
+        track = mp_track_by_tid(mpctx, type, tid);
+    }
+    mp_switch_track_n(mpctx, order, type, track, (tid == -1) ? 0 : FLAG_MARK_SELECTION);
+    print_track_list(mpctx, "Track switched:");
+    mp_wakeup_core(mpctx);
+}
+
+void mp_option_change_callback(void *ctx, struct m_config_option *co, int flags,
+                               bool self_update)
+{
+    struct MPContext *mpctx = ctx;
+    struct MPOpts *opts = mpctx->opts;
+    bool init = !co;
+    void *opt_ptr = init ? NULL : co->data; // NULL on start
+
+    if (co)
+        mp_notify_property(mpctx, co->name);
+    if (opt_ptr == &opts->media_title)
+        mp_notify(mpctx, MP_EVENT_METADATA_UPDATE, NULL);
+
+    if (self_update)
+        return;
+
+    if (flags & UPDATE_TERM)
+        mp_update_logging(mpctx, false);
+
+    if (flags & (UPDATE_OSD | UPDATE_SUB_FILT | UPDATE_SUB_HARD)) {
+        for (int n = 0; n < num_ptracks[STREAM_SUB]; n++) {
+            struct track *track = mpctx->current_track[n][STREAM_SUB];
+            struct dec_sub *sub = track ? track->d_sub : NULL;
+            if (sub) {
+                int ret = sub_control(sub, SD_CTRL_UPDATE_OPTS,
+                                      (void *)(uintptr_t)flags);
+                if (ret == CONTROL_OK && flags & (UPDATE_SUB_FILT | UPDATE_SUB_HARD))
+                    sub_redecode_cached_packets(sub);
+            }
+        }
+        osd_changed(mpctx->osd);
+    }
+
+    if (flags & UPDATE_BUILTIN_SCRIPTS)
+        mp_load_builtin_scripts(mpctx);
+
+    if (flags & UPDATE_IMGPAR) {
+        struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+        if (track && track->dec) {
+            mp_decoder_wrapper_reset_params(track->dec);
+            mp_force_video_refresh(mpctx);
+        }
+    }
+
+    if (flags & UPDATE_INPUT)
+        mp_input_update_opts(mpctx->input);
+
+    if (flags & UPDATE_SUB_EXTS)
+        mp_update_subtitle_exts(mpctx->opts);
+
+    if (init || opt_ptr == &opts->ipc_path || opt_ptr == &opts->ipc_client) {
+        mp_uninit_ipc(mpctx->ipc_ctx);
+        mpctx->ipc_ctx = mp_init_ipc(mpctx->clients, mpctx->global);
+    }
+
+    if (opt_ptr == &opts->vo->video_driver_list) {
+        struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+        uninit_video_out(mpctx);
+        handle_force_window(mpctx, true);
+        reinit_video_chain(mpctx);
+        if (track)
+            reselect_demux_stream(mpctx, track, true);
+
+        mp_wakeup_core(mpctx);
+    }
+
+    if (flags & UPDATE_AUDIO)
+        reload_audio_output(mpctx);
+
+    if (flags & UPDATE_PRIORITY)
+        update_priority(mpctx);
+
+    if (flags & UPDATE_SCREENSAVER)
+        update_screensaver_state(mpctx);
+
+    if (flags & UPDATE_VOL)
+        audio_update_volume(mpctx);
+
+    if (flags & UPDATE_LAVFI_COMPLEX)
+        update_lavfi_complex(mpctx);
+
+    if (opt_ptr == &opts->vo->android_surface_size) {
+        if (mpctx->video_out)
+            vo_control(mpctx->video_out, VOCTRL_EXTERNAL_RESIZE, NULL);
+    }
+
+    if (opt_ptr == &opts->playback_speed) {
+        update_playback_speed(mpctx);
+        mp_wakeup_core(mpctx);
+    }
+
+    if (opt_ptr == &opts->play_dir) {
+        if (mpctx->play_dir != opts->play_dir) {
+            // Some weird things for play_dir if we're at EOF.
+            // 1. The option must be set before we seek.
+            // 2. queue_seek can change the stop_play value; always keep the old one.
+            int old_stop_play = mpctx->stop_play;
+            if (old_stop_play == AT_END_OF_FILE)
+                mpctx->play_dir = opts->play_dir;
+            queue_seek(mpctx, MPSEEK_ABSOLUTE, get_current_time(mpctx),
+                       MPSEEK_EXACT, 0);
+            if (old_stop_play == AT_END_OF_FILE)
+                mpctx->stop_play = old_stop_play;
+        }
+    }
+
+    if (opt_ptr == &opts->edition_id) {
+        struct demuxer *demuxer = mpctx->demuxer;
+        if (mpctx->playback_initialized && demuxer && demuxer->num_editions > 0) {
+            if (opts->edition_id != demuxer->edition) {
+                if (!mpctx->stop_play)
+                    mpctx->stop_play = PT_CURRENT_ENTRY;
+                mp_wakeup_core(mpctx);
+            }
+        }
+    }
+
+    if (opt_ptr == &opts->pause)
+        set_pause_state(mpctx, opts->pause);
+
+    if (opt_ptr == &opts->audio_delay) {
+        if (mpctx->ao_chain) {
+            mpctx->delay += mpctx->opts->audio_delay - mpctx->ao_chain->delay;
+            mpctx->ao_chain->delay = mpctx->opts->audio_delay;
+        }
+        mp_wakeup_core(mpctx);
+    }
+
+    if (flags & UPDATE_HWDEC) {
+        struct track *track = mpctx->current_track[0][STREAM_VIDEO];
+        struct mp_decoder_wrapper *dec = track ? track->dec : NULL;
+        if (dec) {
+            mp_decoder_wrapper_control(dec, VDCTRL_REINIT, NULL);
+            double last_pts = mpctx->video_pts;
+            if (last_pts != MP_NOPTS_VALUE)
+                queue_seek(mpctx, MPSEEK_ABSOLUTE, last_pts, MPSEEK_EXACT, 0);
+        }
+    }
+
+    if (opt_ptr == &opts->vo->window_scale)
+        update_window_scale(mpctx);
+
+    if (opt_ptr == &opts->cursor_autohide_delay)
+        mpctx->mouse_timer = 0;
+
+    if (flags & UPDATE_DVB_PROG) {
+        if (!mpctx->stop_play)
+            mpctx->stop_play = PT_CURRENT_ENTRY;
+    }
+
+    if (opt_ptr == &opts->ab_loop[0] || opt_ptr == &opts->ab_loop[1]) {
+        update_ab_loop_clip(mpctx);
+        // Update if visible
+        set_osd_bar_chapters(mpctx, OSD_BAR_SEEK);
+        mp_wakeup_core(mpctx);
+    }
+
+    if (opt_ptr == &opts->vf_settings)
+        set_filters(mpctx, STREAM_VIDEO, opts->vf_settings);
+
+    if (opt_ptr == &opts->af_settings)
+        set_filters(mpctx, STREAM_AUDIO, opts->af_settings);
+
+    for (int type = 0; type < STREAM_TYPE_COUNT; type++) {
+        for (int order = 0; order < num_ptracks[type]; order++) {
+            if (opt_ptr == &opts->stream_id[order][type])
+                update_track_switch(mpctx, order, type);
+        }
+    }
+
+    if (opt_ptr == &opts->vo->fullscreen && !opts->vo->fullscreen)
+        mpctx->mouse_event_ts--; // Show mouse cursor
+
+    if (opt_ptr == &opts->vo->taskbar_progress)
+        update_vo_playback_state(mpctx);
+
+    if (opt_ptr == &opts->image_display_duration && mpctx->vo_chain
+        && mpctx->vo_chain->is_sparse && !mpctx->ao_chain
+        && mpctx->video_status == STATUS_DRAINING)
+        mpctx->time_frame = opts->image_display_duration;
+}
+
+void mp_notify_property(struct MPContext *mpctx, const char *property)
+{
+    mp_client_property_change(mpctx, property);
+}