client API: deprecate opengl-cb API and introduce a replacement API

The purpose of the new API is to make it useable with other APIs than
OpenGL, especially D3D11 and vulkan. In theory it's now possible to
support other vo_gpu backends, as well as backends that don't use the
vo_gpu code at all.

This also aims to get rid of the dumb mpv_get_sub_api() function. The
life cycle of the new mpv_render_context is a bit different from
mpv_opengl_cb_context, and you explicitly create/destroy the new
context, instead of calling init/uninit on an object returned by
mpv_get_sub_api().

In other to make the render API generic, it's annoyingly EGL style, and
requires you to pass in API-specific objects to generic functions. This
is to avoid explicit objects like the internal ra API has, because that
sounds more complicated and annoying for an API that's supposed to never
change.

The opengl_cb API will continue to exist for a bit longer, but
internally there are already a few tradeoffs, like reduced
thread-safety.

Mostly untested. Seems to work fine with mpc-qt.

1 files changed, 72 insertions, 0 deletions

diff --git a/video/out/libmpv.h b/video/out/libmpv.h
new file mode 100644
index 0000000000..8b99587984
--- /dev/null
+++ b/video/out/libmpv.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "libmpv/render.h"
+#include "vo.h"
+
+// Helper for finding a parameter value. It returns the direct pointer to the
+// value, and if not present, just returns the def argument. In particular, if
+// def is not NULL, this never returns NULL (unless a param value is defined
+// as accepting NULL, or the libmpv API user is triggering UB).
+void *get_mpv_render_param(mpv_render_param *params, mpv_render_param_type type,
+                           void *def);
+
+typedef int (*mp_render_cb_control_fn)(void *cb_ctx, int *events,
+                                       uint32_t request, void *data);
+void mp_render_context_set_control_callback(mpv_render_context *ctx,
+                                            mp_render_cb_control_fn callback,
+                                            void *callback_ctx);
+bool mp_render_context_acquire(mpv_render_context *ctx);
+
+struct render_backend {
+    struct mpv_global *global;
+    struct mp_log *log;
+    const struct render_backend_fns *fns;
+
+    // Set on init, immutable afterwards.
+    int driver_caps;
+    struct mp_hwdec_devices *hwdec_devs;
+
+    void *priv;
+};
+
+// Generic backend for rendering via libmpv. This corresponds to vo/vo_driver,
+// except for rendering via the mpv_render_*() API. (As a consequence it's as
+// generic as the VO API.) Like with VOs, one backend can support multiple
+// underlying GPU APIs.
+struct render_backend_fns {
+    // Returns libmpv error code. In particular, this function has to check for
+    // MPV_RENDER_PARAM_API_TYPE, and silently return MPV_ERROR_NOT_IMPLEMENTED
+    // if the API is not included in this backend.
+    // If this fails, ->destroy() will be called.
+    int (*init)(struct render_backend *ctx, mpv_render_param *params);
+    // Check if the passed IMGFMT_ is supported.
+    bool (*check_format)(struct render_backend *ctx, int imgfmt);
+    // Implementation of mpv_render_context_set_parameter(). Optional.
+    int (*set_parameter)(struct render_backend *ctx, mpv_render_param param);
+    // Like vo_driver.reconfig().
+    void (*reconfig)(struct render_backend *ctx, struct mp_image_params *params);
+    // Like VOCTRL_RESET.
+    void (*reset)(struct render_backend *ctx);
+    // This has two purposes: 1. set queue attributes on VO, 2. update the
+    // renderer's OSD pointer. Keep in mind that as soon as the caller releases
+    // the renderer lock, the VO pointer can become invalid. The OSD pointer
+    // will technically remain valid (even though it's a vo field), until it's
+    // unset with this function.
+    // Will be called if vo changes, or if renderer options change.
+    void (*update_external)(struct render_backend *ctx, struct vo *vo);
+    // Update screen area.
+    void (*resize)(struct render_backend *ctx, struct mp_rect *src,
+                   struct mp_rect *dst, struct mp_osd_res *osd);
+    // Get target surface size from mpv_render_context_render() arguments.
+    int (*get_target_size)(struct render_backend *ctx, mpv_render_param *params,
+                           int *out_w, int *out_h);
+    // Implementation of mpv_render_context_render().
+    int (*render)(struct render_backend *ctx, mpv_render_param *params,
+                  struct vo_frame *frame);
+    // Free all data in ctx->priv.
+    void (*destroy)(struct render_backend *ctx);
+};
+
+extern const struct render_backend_fns render_backend_gpu;