vo_opengl: refactor into vo_gpu

This is done in several steps:

1. refactor MPGLContext -> struct ra_ctx
2. move GL-specific stuff in vo_opengl into opengl/context.c
3. generalize context creation to support other APIs, and add --gpu-api
4. rename all of the --opengl- options that are no longer opengl-specific
5. move all of the stuff from opengl/* that isn't GL-specific into gpu/
   (note: opengl/gl_utils.h became opengl/utils.h)
6. rename vo_opengl to vo_gpu
7. to handle window screenshots, the short-term approach was to just add
   it to ra_swchain_fns. Long term (and for vulkan) this has to be moved to
   ra itself (and vo_gpu altered to compensate), but this was a stop-gap
   measure to prevent this commit from getting too big
8. move ra->fns->flush to ra_gl_ctx instead
9. some other minor changes that I've probably already forgotten

Note: This is one half of a major refactor, the other half of which is
provided by rossy's following commit. This commit enables support for
all linux platforms, while his version enables support for all non-linux
platforms.

Note 2: vo_opengl_cb.c also re-uses ra_gl_ctx so it benefits from the
--opengl- options like --opengl-early-flush, --opengl-finish etc. Should
be a strict superset of the old functionality.

Disclaimer: Since I have no way of compiling mpv on all platforms, some
of these ports were done blindly. Specifically, the blind ports included
context_mali_fbdev.c and context_rpi.c. Since they're both based on
egl_helpers, the port should have gone smoothly without any major
changes required. But if somebody complains about a compile error on
those platforms (assuming anybody actually uses them), you know where to
complain.

20 files changed, 9414 insertions, 0 deletions

diff --git a/video/out/gpu/context.c b/video/out/gpu/context.c
new file mode 100644
index 0000000000..dbabba8b3b
--- /dev/null
+++ b/video/out/gpu/context.c
@@ -0,0 +1,186 @@
+/*
+ * 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 <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <math.h>
+#include <assert.h>
+
+#include "config.h"
+#include "common/common.h"
+#include "common/msg.h"
+#include "options/options.h"
+#include "options/m_option.h"
+#include "video/out/vo.h"
+
+#include "context.h"
+
+extern const struct ra_ctx_fns ra_ctx_glx;
+extern const struct ra_ctx_fns ra_ctx_glx_probe;
+extern const struct ra_ctx_fns ra_ctx_x11_egl;
+extern const struct ra_ctx_fns ra_ctx_drm_egl;
+extern const struct ra_ctx_fns ra_ctx_cocoa;
+extern const struct ra_ctx_fns ra_ctx_wayland_egl;
+extern const struct ra_ctx_fns ra_ctx_wgl;
+extern const struct ra_ctx_fns ra_ctx_angle;
+extern const struct ra_ctx_fns ra_ctx_dxinterop;
+extern const struct ra_ctx_fns ra_ctx_rpi;
+extern const struct ra_ctx_fns ra_ctx_mali;
+extern const struct ra_ctx_fns ra_ctx_vdpauglx;
+
+static const struct ra_ctx_fns *contexts[] = {
+// OpenGL contexts:
+#if HAVE_RPI
+    &ra_ctx_rpi,
+#endif
+/*
+#if HAVE_GL_COCOA
+    &ra_ctx_cocoa,
+#endif
+#if HAVE_EGL_ANGLE_WIN32
+    &ra_ctx_angle,
+#endif
+#if HAVE_GL_WIN32
+    &ra_ctx_wgl,
+#endif
+#if HAVE_GL_DXINTEROP
+    &ra_ctx_dxinterop,
+#endif
+*/
+#if HAVE_GL_X11
+    &ra_ctx_glx_probe,
+#endif
+#if HAVE_EGL_X11
+    &ra_ctx_x11_egl,
+#endif
+#if HAVE_GL_X11
+    &ra_ctx_glx,
+#endif
+#if HAVE_GL_WAYLAND
+    &ra_ctx_wayland_egl,
+#endif
+#if HAVE_EGL_DRM
+    &ra_ctx_drm_egl,
+#endif
+#if HAVE_MALI_FBDEV
+    &ra_ctx_mali,
+#endif
+#if HAVE_VDPAU_GL_X11
+    &ra_ctx_vdpauglx,
+#endif
+};
+
+static bool get_help(struct mp_log *log, struct bstr param)
+{
+    if (bstr_equals0(param, "help")) {
+        mp_info(log, "GPU contexts / APIs:\n");
+        mp_info(log, "    auto (autodetect)\n");
+        for (int n = 0; n < MP_ARRAY_SIZE(contexts); n++)
+            mp_info(log, "    %s (%s)\n", contexts[n]->name, contexts[n]->type);
+        return true;
+    }
+
+    return false;
+}
+
+int ra_ctx_validate_api(struct mp_log *log, const struct m_option *opt,
+                        struct bstr name, struct bstr param)
+{
+    if (get_help(log, param))
+        return M_OPT_EXIT;
+    if (bstr_equals0(param, "auto"))
+        return 1;
+    for (int i = 0; i < MP_ARRAY_SIZE(contexts); i++) {
+        if (bstr_equals0(param, contexts[i]->type))
+            return 1;
+    }
+    return M_OPT_INVALID;
+}
+
+int ra_ctx_validate_context(struct mp_log *log, const struct m_option *opt,
+                            struct bstr name, struct bstr param)
+{
+    if (get_help(log, param))
+        return M_OPT_EXIT;
+    if (bstr_equals0(param, "auto"))
+        return 1;
+    for (int i = 0; i < MP_ARRAY_SIZE(contexts); i++) {
+        if (bstr_equals0(param, contexts[i]->name))
+            return 1;
+    }
+    return M_OPT_INVALID;
+}
+
+// Create a VO window and create a RA context on it.
+//  vo_flags: passed to the backend's create window function
+struct ra_ctx *ra_ctx_create(struct vo *vo, const char *context_type,
+                             const char *context_name, struct ra_ctx_opts opts)
+{
+    bool api_auto = !context_type || strcmp(context_type, "auto") == 0;
+    bool ctx_auto = !context_name || strcmp(context_name, "auto") == 0;
+
+    if (ctx_auto) {
+        MP_VERBOSE(vo, "Probing for best GPU context.\n");
+        opts.probing = true;
+    }
+
+    // Hack to silence backend (X11/Wayland/etc.) errors. Kill it once backends
+    // are separate from `struct vo`
+    bool old_probing = vo->probing;
+    vo->probing = opts.probing;
+
+    for (int i = 0; i < MP_ARRAY_SIZE(contexts); i++) {
+        if (!opts.probing && strcmp(contexts[i]->name, context_name) != 0)
+            continue;
+        if (!api_auto && strcmp(contexts[i]->type, context_type) != 0)
+            continue;
+
+        struct ra_ctx *ctx = talloc_ptrtype(NULL, ctx);
+        *ctx = (struct ra_ctx) {
+            .vo = vo,
+            .global = vo->global,
+            .log = mp_log_new(ctx, vo->log, contexts[i]->type),
+            .opts = opts,
+            .fns = contexts[i],
+        };
+
+        MP_VERBOSE(ctx, "Initializing GPU context '%s'\n", ctx->fns->name);
+        if (contexts[i]->init(ctx)) {
+            vo->probing = old_probing;
+            return ctx;
+        }
+
+        talloc_free(ctx);
+    }
+
+    // If we've reached this point, then none of the contexts matched the name
+    // requested, or the backend creation failed for all of them.
+    MP_ERR(vo, "Failed initializing any suitable GPU context!\n");
+    vo->probing = old_probing;
+    return NULL;
+}
+
+void ra_ctx_destroy(struct ra_ctx **ctx)
+{
+    if (*ctx)
+        (*ctx)->fns->uninit(*ctx);
+    talloc_free(*ctx);
+    *ctx = NULL;
+}
diff --git a/video/out/gpu/context.h b/video/out/gpu/context.h
new file mode 100644
index 0000000000..42de59b75f
--- /dev/null
+++ b/video/out/gpu/context.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "video/out/vo.h"
+
+#include "config.h"
+#include "ra.h"
+
+struct ra_ctx_opts {
+    int allow_sw;        // allow software renderers
+    int want_alpha;      // create an alpha framebuffer if possible
+    int debug;           // enable debugging layers/callbacks etc.
+    bool probing;        // the backend was auto-probed
+    int swapchain_depth; // max number of images to render ahead
+};
+
+struct ra_ctx {
+    struct vo *vo;
+    struct ra *ra;
+    struct mpv_global *global;
+    struct mp_log *log;
+
+    struct ra_ctx_opts opts;
+    const struct ra_ctx_fns *fns;
+    struct ra_swapchain *swapchain;
+
+    void *priv;
+};
+
+// The functions that make up a ra_ctx.
+struct ra_ctx_fns {
+    const char *type; // API type (for --gpu-api)
+    const char *name; // name (for --gpu-context)
+
+    // Resize the window, or create a new window if there isn't one yet.
+    // Currently, there is an unfortunate interaction with ctx->vo, and
+    // display size etc. are determined by it.
+    bool (*reconfig)(struct ra_ctx *ctx);
+
+    // This behaves exactly like vo_driver.control().
+    int (*control)(struct ra_ctx *ctx, int *events, int request, void *arg);
+
+    // These behave exactly like vo_driver.wakeup/wait_events. They are
+    // optional.
+    void (*wakeup)(struct ra_ctx *ctx);
+    void (*wait_events)(struct ra_ctx *ctx, int64_t until_time_us);
+
+    // Initialize/destroy the 'struct ra' and possibly the underlying VO backend.
+    // Not normally called by the user of the ra_ctx.
+    bool (*init)(struct ra_ctx *ctx);
+    void (*uninit)(struct ra_ctx *ctx);
+};
+
+// Extra struct for the swapchain-related functions so they can be easily
+// inherited from helpers.
+struct ra_swapchain {
+    struct ra_ctx *ctx;
+    struct priv *priv;
+    const struct ra_swapchain_fns *fns;
+
+    bool flip_v; // flip the rendered image vertically (set by the swapchain)
+};
+
+struct ra_swapchain_fns {
+    // Gets the current framebuffer depth in bits (0 if unknown). Optional.
+    int (*color_depth)(struct ra_swapchain *sw);
+
+    // Retrieves a screenshot of the framebuffer. These are always the right
+    // side up, regardless of ra_swapchain->flip_v. Optional.
+    struct mp_image *(*screenshot)(struct ra_swapchain *sw);
+
+    // Called when rendering starts. Returns NULL on failure. This must be
+    // followed by submit_frame, to submit the rendered frame.
+    struct ra_tex *(*start_frame)(struct ra_swapchain *sw);
+
+    // Present the frame. Issued in lockstep with start_frame, with rendering
+    // commands in between. The `frame` is just there for timing data, for
+    // swapchains smart enough to do something with it.
+    bool (*submit_frame)(struct ra_swapchain *sw, const struct vo_frame *frame);
+
+    // Performs a buffer swap. This blocks for as long as necessary to meet
+    // params.swapchain_depth, or until the next vblank (for vsynced contexts)
+    void (*swap_buffers)(struct ra_swapchain *sw);
+};
+
+// Create and destroy a ra_ctx. This also takes care of creating and destroying
+// the underlying `struct ra`, and perhaps the underlying VO backend.
+struct ra_ctx *ra_ctx_create(struct vo *vo, const char *context_type,
+                             const char *context_name, struct ra_ctx_opts opts);
+void ra_ctx_destroy(struct ra_ctx **ctx);
+
+struct m_option;
+int ra_ctx_validate_api(struct mp_log *log, const struct m_option *opt,
+                        struct bstr name, struct bstr param);
+int ra_ctx_validate_context(struct mp_log *log, const struct m_option *opt,
+                            struct bstr name, struct bstr param);
diff --git a/video/out/gpu/hwdec.c b/video/out/gpu/hwdec.c
new file mode 100644
index 0000000000..5fbc1aa4a9
--- /dev/null
+++ b/video/out/gpu/hwdec.c
@@ -0,0 +1,239 @@
+/*
+ * 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 <stddef.h>
+#include <string.h>
+
+#include "config.h"
+
+#include "common/common.h"
+#include "common/msg.h"
+#include "options/m_config.h"
+#include "hwdec.h"
+
+extern const struct ra_hwdec_driver ra_hwdec_vaegl;
+extern const struct ra_hwdec_driver ra_hwdec_vaglx;
+extern const struct ra_hwdec_driver ra_hwdec_videotoolbox;
+extern const struct ra_hwdec_driver ra_hwdec_vdpau;
+extern const struct ra_hwdec_driver ra_hwdec_dxva2egl;
+extern const struct ra_hwdec_driver ra_hwdec_d3d11egl;
+extern const struct ra_hwdec_driver ra_hwdec_d3d11eglrgb;
+extern const struct ra_hwdec_driver ra_hwdec_dxva2gldx;
+extern const struct ra_hwdec_driver ra_hwdec_dxva2;
+extern const struct ra_hwdec_driver ra_hwdec_cuda;
+extern const struct ra_hwdec_driver ra_hwdec_rpi_overlay;
+
+static const struct ra_hwdec_driver *const mpgl_hwdec_drivers[] = {
+#if HAVE_VAAPI_EGL
+    &ra_hwdec_vaegl,
+#endif
+#if HAVE_VAAPI_GLX
+    &ra_hwdec_vaglx,
+#endif
+#if HAVE_VDPAU_GL_X11
+    &ra_hwdec_vdpau,
+#endif
+#if HAVE_VIDEOTOOLBOX_GL || HAVE_IOS_GL
+    &ra_hwdec_videotoolbox,
+#endif
+#if HAVE_D3D_HWACCEL
+    &ra_hwdec_d3d11egl,
+    &ra_hwdec_d3d11eglrgb,
+ #if HAVE_D3D9_HWACCEL
+    &ra_hwdec_dxva2egl,
+ #endif
+#endif
+#if HAVE_GL_DXINTEROP_D3D9
+    &ra_hwdec_dxva2gldx,
+#endif
+#if HAVE_CUDA_HWACCEL
+    &ra_hwdec_cuda,
+#endif
+#if HAVE_RPI
+    &ra_hwdec_rpi_overlay,
+#endif
+    NULL
+};
+
+static struct ra_hwdec *load_hwdec_driver(struct mp_log *log, struct ra *ra,
+                                          struct mpv_global *global,
+                                          struct mp_hwdec_devices *devs,
+                                          const struct ra_hwdec_driver *drv,
+                                          bool is_auto)
+{
+    struct ra_hwdec *hwdec = talloc(NULL, struct ra_hwdec);
+    *hwdec = (struct ra_hwdec) {
+        .driver = drv,
+        .log = mp_log_new(hwdec, log, drv->name),
+        .global = global,
+        .ra = ra,
+        .devs = devs,
+        .probing = is_auto,
+        .priv = talloc_zero_size(hwdec, drv->priv_size),
+    };
+    mp_verbose(log, "Loading hwdec driver '%s'\n", drv->name);
+    if (hwdec->driver->init(hwdec) < 0) {
+        ra_hwdec_uninit(hwdec);
+        mp_verbose(log, "Loading failed.\n");
+        return NULL;
+    }
+    return hwdec;
+}
+
+struct ra_hwdec *ra_hwdec_load_api(struct mp_log *log, struct ra *ra,
+                                   struct mpv_global *g,
+                                   struct mp_hwdec_devices *devs,
+                                   enum hwdec_type api)
+{
+    bool is_auto = HWDEC_IS_AUTO(api);
+    for (int n = 0; mpgl_hwdec_drivers[n]; n++) {
+        const struct ra_hwdec_driver *drv = mpgl_hwdec_drivers[n];
+        if ((is_auto || api == drv->api) && !drv->testing_only) {
+            struct ra_hwdec *r = load_hwdec_driver(log, ra, g, devs, drv, is_auto);
+            if (r)
+                return r;
+        }
+    }
+    return NULL;
+}
+
+// Load by option name.
+struct ra_hwdec *ra_hwdec_load(struct mp_log *log, struct ra *ra,
+                               struct mpv_global *g,
+                               struct mp_hwdec_devices *devs,
+                               const char *name)
+{
+    int g_hwdec_api;
+    mp_read_option_raw(g, "hwdec", &m_option_type_choice, &g_hwdec_api);
+    if (!name || !name[0])
+        name = m_opt_choice_str(mp_hwdec_names, g_hwdec_api);
+
+    int api_id = HWDEC_NONE;
+    for (int n = 0; mp_hwdec_names[n].name; n++) {
+        if (name && strcmp(mp_hwdec_names[n].name, name) == 0)
+            api_id = mp_hwdec_names[n].value;
+    }
+
+    for (int n = 0; mpgl_hwdec_drivers[n]; n++) {
+        const struct ra_hwdec_driver *drv = mpgl_hwdec_drivers[n];
+        if (name && strcmp(drv->name, name) == 0) {
+            struct ra_hwdec *r = load_hwdec_driver(log, ra, g, devs, drv, false);
+            if (r)
+                return r;
+        }
+    }
+
+    return ra_hwdec_load_api(log, ra, g, devs, api_id);
+}
+
+int ra_hwdec_validate_opt(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param)
+{
+    bool help = bstr_equals0(param, "help");
+    if (help)
+        mp_info(log, "Available hwdecs:\n");
+    for (int n = 0; mpgl_hwdec_drivers[n]; n++) {
+        const struct ra_hwdec_driver *drv = mpgl_hwdec_drivers[n];
+        const char *api_name = m_opt_choice_str(mp_hwdec_names, drv->api);
+        if (help) {
+            mp_info(log, "    %s [%s]\n", drv->name, api_name);
+        } else if (bstr_equals0(param, drv->name) ||
+                   bstr_equals0(param, api_name))
+        {
+            return 1;
+        }
+    }
+    if (help) {
+        mp_info(log, "    auto (loads best)\n"
+                     "    (other --hwdec values)\n"
+                     "Setting an empty string means use --hwdec.\n");
+        return M_OPT_EXIT;
+    }
+    if (!param.len)
+        return 1; // "" is treated specially
+    for (int n = 0; mp_hwdec_names[n].name; n++) {
+        if (bstr_equals0(param, mp_hwdec_names[n].name))
+            return 1;
+    }
+    mp_fatal(log, "No hwdec backend named '%.*s' found!\n", BSTR_P(param));
+    return M_OPT_INVALID;
+}
+
+void ra_hwdec_uninit(struct ra_hwdec *hwdec)
+{
+    if (hwdec)
+        hwdec->driver->uninit(hwdec);
+    talloc_free(hwdec);
+}
+
+bool ra_hwdec_test_format(struct ra_hwdec *hwdec, int imgfmt)
+{
+    for (int n = 0; hwdec->driver->imgfmts[n]; n++) {
+        if (hwdec->driver->imgfmts[n] == imgfmt)
+            return true;
+    }
+    return false;
+}
+
+struct ra_hwdec_mapper *ra_hwdec_mapper_create(struct ra_hwdec *hwdec,
+                                               struct mp_image_params *params)
+{
+    assert(ra_hwdec_test_format(hwdec, params->imgfmt));
+
+    struct ra_hwdec_mapper *mapper = talloc_ptrtype(NULL, mapper);
+    *mapper = (struct ra_hwdec_mapper){
+        .owner = hwdec,
+        .driver = hwdec->driver->mapper,
+        .log = hwdec->log,
+        .ra = hwdec->ra,
+        .priv = talloc_zero_size(mapper, hwdec->driver->mapper->priv_size),
+        .src_params = *params,
+        .dst_params = *params,
+    };
+    if (mapper->driver->init(mapper) < 0)
+        ra_hwdec_mapper_free(&mapper);
+    return mapper;
+}
+
+void ra_hwdec_mapper_free(struct ra_hwdec_mapper **mapper)
+{
+    struct ra_hwdec_mapper *p = *mapper;
+    if (p) {
+        ra_hwdec_mapper_unmap(p);
+        p->driver->uninit(p);
+        talloc_free(p);
+    }
+    *mapper = NULL;
+}
+
+void ra_hwdec_mapper_unmap(struct ra_hwdec_mapper *mapper)
+{
+    if (mapper->driver->unmap)
+        mapper->driver->unmap(mapper);
+    mp_image_unrefp(&mapper->src);
+}
+
+int ra_hwdec_mapper_map(struct ra_hwdec_mapper *mapper, struct mp_image *img)
+{
+    ra_hwdec_mapper_unmap(mapper);
+    mp_image_setrefp(&mapper->src, img);
+    if (mapper->driver->map(mapper) < 0) {
+        ra_hwdec_mapper_unmap(mapper);
+        return -1;
+    }
+    return 0;
+}
diff --git a/video/out/gpu/hwdec.h b/video/out/gpu/hwdec.h
new file mode 100644
index 0000000000..20bbaae9eb
--- /dev/null
+++ b/video/out/gpu/hwdec.h
@@ -0,0 +1,130 @@
+#ifndef MPGL_HWDEC_H_
+#define MPGL_HWDEC_H_
+
+#include "video/mp_image.h"
+#include "ra.h"
+#include "video/hwdec.h"
+
+struct ra_hwdec {
+    const struct ra_hwdec_driver *driver;
+    struct mp_log *log;
+    struct mpv_global *global;
+    struct ra *ra;
+    struct mp_hwdec_devices *devs;
+    // GLSL extensions required to sample textures from this.
+    const char **glsl_extensions;
+    // For free use by hwdec driver
+    void *priv;
+    // For working around the vdpau vs. vaapi mess.
+    bool probing;
+    // Used in overlay mode only.
+    float overlay_colorkey[4];
+};
+
+struct ra_hwdec_mapper {
+    const struct ra_hwdec_mapper_driver *driver;
+    struct mp_log *log;
+    struct ra *ra;
+    void *priv;
+    struct ra_hwdec *owner;
+    // Input frame parameters. (Set before init(), immutable.)
+    struct mp_image_params src_params;
+    // Output frame parameters (represents the format the textures return). Must
+    // be set by init(), immutable afterwards,
+    struct mp_image_params dst_params;
+
+    // The currently mapped source image (or the image about to be mapped in
+    // ->map()). NULL if unmapped. The mapper can also clear this reference if
+    // the mapped textures contain a full copy.
+    struct mp_image *src;
+
+    // The mapped textures and metadata about them. These fields change if a
+    // new frame is mapped (or unmapped), but otherwise remain constant.
+    // The common code won't mess with these, so you can e.g. set them in the
+    // .init() callback.
+    struct ra_tex *tex[4];
+    bool vdpau_fields;
+};
+
+// This can be used to map frames of a specific hw format as GL textures.
+struct ra_hwdec_mapper_driver {
+    // Used to create ra_hwdec_mapper.priv.
+    size_t priv_size;
+
+    // Init the mapper implementation. At this point, the field src_params,
+    // fns, devs, priv are initialized.
+    int (*init)(struct ra_hwdec_mapper *mapper);
+    // Destroy the mapper. unmap is called before this.
+    void (*uninit)(struct ra_hwdec_mapper *mapper);
+
+    // Map mapper->src as texture, and set mapper->frame to textures using it.
+    // It is expected that that the textures remain valid until the next unmap
+    // or uninit call.
+    // The function is allowed to unref mapper->src if it's not needed (i.e.
+    // this function creates a copy).
+    // The underlying format can change, so you might need to do some form
+    // of change detection. You also must reject unsupported formats with an
+    // error.
+    // On error, returns negative value on error and remains unmapped.
+    int (*map)(struct ra_hwdec_mapper *mapper);
+    // Unmap the frame. Does nothing if already unmapped. Optional.
+    void (*unmap)(struct ra_hwdec_mapper *mapper);
+};
+
+struct ra_hwdec_driver {
+    // Name of the interop backend. This is used for informational purposes only.
+    const char *name;
+    // Used to create ra_hwdec.priv.
+    size_t priv_size;
+    // Used to explicitly request a specific API.
+    enum hwdec_type api;
+    // One of the hardware surface IMGFMT_ that must be passed to map_image later.
+    // Terminated with a 0 entry. (Extend the array size as needed.)
+    const int imgfmts[3];
+    // Dosn't load this unless requested by name.
+    bool testing_only;
+
+    // Create the hwdec device. It must add it to hw->devs, if applicable.
+    int (*init)(struct ra_hwdec *hw);
+    void (*uninit)(struct ra_hwdec *hw);
+
+    // This will be used to create a ra_hwdec_mapper from ra_hwdec.
+    const struct ra_hwdec_mapper_driver *mapper;
+
+    // The following function provides an alternative API. Each ra_hwdec_driver
+    // must have either provide a mapper or overlay_frame (not both or none), and
+    // if overlay_frame is set, it operates in overlay mode. In this mode,
+    // OSD etc. is rendered via OpenGL, but the video is rendered as a separate
+    // layer below it.
+    // Non-overlay mode is strictly preferred, so try not to use overlay mode.
+    // Set the given frame as overlay, replacing the previous one. This can also
+    // just change the position of the overlay.
+    // hw_image==src==dst==NULL is passed to clear the overlay.
+    int (*overlay_frame)(struct ra_hwdec *hw, struct mp_image *hw_image,
+                         struct mp_rect *src, struct mp_rect *dst, bool newframe);
+};
+
+struct ra_hwdec *ra_hwdec_load_api(struct mp_log *log, struct ra *ra,
+                                   struct mpv_global *g,
+                                   struct mp_hwdec_devices *devs,
+                                   enum hwdec_type api);
+
+struct ra_hwdec *ra_hwdec_load(struct mp_log *log, struct ra *ra,
+                               struct mpv_global *g,
+                               struct mp_hwdec_devices *devs,
+                               const char *name);
+
+int ra_hwdec_validate_opt(struct mp_log *log, const m_option_t *opt,
+                          struct bstr name, struct bstr param);
+
+void ra_hwdec_uninit(struct ra_hwdec *hwdec);
+
+bool ra_hwdec_test_format(struct ra_hwdec *hwdec, int imgfmt);
+
+struct ra_hwdec_mapper *ra_hwdec_mapper_create(struct ra_hwdec *hwdec,
+                                               struct mp_image_params *params);
+void ra_hwdec_mapper_free(struct ra_hwdec_mapper **mapper);
+void ra_hwdec_mapper_unmap(struct ra_hwdec_mapper *mapper);
+int ra_hwdec_mapper_map(struct ra_hwdec_mapper *mapper, struct mp_image *img);
+
+#endif
diff --git a/video/out/gpu/lcms.c b/video/out/gpu/lcms.c
new file mode 100644
index 0000000000..8747ae6aa6
--- /dev/null
+++ b/video/out/gpu/lcms.c
@@ -0,0 +1,531 @@
+/*
+ * 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 <string.h>
+#include <math.h>
+
+#include "mpv_talloc.h"
+
+#include "config.h"
+
+#include "stream/stream.h"
+#include "common/common.h"
+#include "misc/bstr.h"
+#include "common/msg.h"
+#include "options/m_option.h"
+#include "options/path.h"
+#include "video/csputils.h"
+#include "lcms.h"
+
+#include "osdep/io.h"
+
+#if HAVE_LCMS2
+
+#include <lcms2.h>
+#include <libavutil/sha.h>
+#include <libavutil/mem.h>
+
+struct gl_lcms {
+    void *icc_data;
+    size_t icc_size;
+    struct AVBufferRef *vid_profile;
+    char *current_profile;
+    bool using_memory_profile;
+    bool changed;
+    enum mp_csp_prim current_prim;
+    enum mp_csp_trc current_trc;
+
+    struct mp_log *log;
+    struct mpv_global *global;
+    struct mp_icc_opts *opts;
+};
+
+static bool parse_3dlut_size(const char *arg, int *p1, int *p2, int *p3)
+{
+    if (sscanf(arg, "%dx%dx%d", p1, p2, p3) != 3)
+        return false;
+    for (int n = 0; n < 3; n++) {
+        int s = ((int[]) { *p1, *p2, *p3 })[n];
+        if (s < 2 || s > 512)
+            return false;
+    }
+    return true;
+}
+
+static int validate_3dlut_size_opt(struct mp_log *log, const m_option_t *opt,
+                                   struct bstr name, struct bstr param)
+{
+    int p1, p2, p3;
+    char s[20];
+    snprintf(s, sizeof(s), "%.*s", BSTR_P(param));
+    return parse_3dlut_size(s, &p1, &p2, &p3);
+}
+
+#define OPT_BASE_STRUCT struct mp_icc_opts
+const struct m_sub_options mp_icc_conf = {
+    .opts = (const m_option_t[]) {
+        OPT_FLAG("use-embedded-icc-profile", use_embedded, 0),
+        OPT_STRING("icc-profile", profile, M_OPT_FILE),
+        OPT_FLAG("icc-profile-auto", profile_auto, 0),
+        OPT_STRING("icc-cache-dir", cache_dir, M_OPT_FILE),
+        OPT_INT("icc-intent", intent, 0),
+        OPT_INTRANGE("icc-contrast", contrast, 0, 0, 100000),
+        OPT_STRING_VALIDATE("icc-3dlut-size", size_str, 0, validate_3dlut_size_opt),
+
+        OPT_REPLACED("3dlut-size", "icc-3dlut-size"),
+        OPT_REMOVED("icc-cache", "see icc-cache-dir"),
+        {0}
+    },
+    .size = sizeof(struct mp_icc_opts),
+    .defaults = &(const struct mp_icc_opts) {
+        .size_str = "64x64x64",
+        .intent = INTENT_RELATIVE_COLORIMETRIC,
+        .use_embedded = true,
+    },
+};
+
+static void lcms2_error_handler(cmsContext ctx, cmsUInt32Number code,
+                                const char *msg)
+{
+    struct gl_lcms *p = cmsGetContextUserData(ctx);
+    MP_ERR(p, "lcms2: %s\n", msg);
+}
+
+static void load_profile(struct gl_lcms *p)
+{
+    talloc_free(p->icc_data);
+    p->icc_data = NULL;
+    p->icc_size = 0;
+    p->using_memory_profile = false;
+    talloc_free(p->current_profile);
+    p->current_profile = NULL;
+
+    if (!p->opts->profile || !p->opts->profile[0])
+        return;
+
+    char *fname = mp_get_user_path(NULL, p->global, p->opts->profile);
+    MP_VERBOSE(p, "Opening ICC profile '%s'\n", fname);
+    struct bstr iccdata = stream_read_file(fname, p, p->global,
+                                           100000000); // 100 MB
+    talloc_free(fname);
+    if (!iccdata.len)
+        return;
+
+    talloc_free(p->icc_data);
+
+    p->icc_data = iccdata.start;
+    p->icc_size = iccdata.len;
+    p->current_profile = talloc_strdup(p, p->opts->profile);
+}
+
+static void gl_lcms_destructor(void *ptr)
+{
+    struct gl_lcms *p = ptr;
+    av_buffer_unref(&p->vid_profile);
+}
+
+struct gl_lcms *gl_lcms_init(void *talloc_ctx, struct mp_log *log,
+                             struct mpv_global *global,
+                             struct mp_icc_opts *opts)
+{
+    struct gl_lcms *p = talloc_ptrtype(talloc_ctx, p);
+    talloc_set_destructor(p, gl_lcms_destructor);
+    *p = (struct gl_lcms) {
+        .global = global,
+        .log = log,
+        .opts = opts,
+    };
+    gl_lcms_update_options(p);
+    return p;
+}
+
+void gl_lcms_update_options(struct gl_lcms *p)
+{
+    if ((p->using_memory_profile && !p->opts->profile_auto) ||
+        !bstr_equals(bstr0(p->opts->profile), bstr0(p->current_profile)))
+    {
+        load_profile(p);
+    }
+
+    p->changed = true; // probably
+}
+
+// Warning: profile.start must point to a ta allocation, and the function
+//          takes over ownership.
+// Returns whether the internal profile was changed.
+bool gl_lcms_set_memory_profile(struct gl_lcms *p, bstr profile)
+{
+    if (!p->opts->profile_auto || (p->opts->profile && p->opts->profile[0])) {