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, 143 insertions, 21 deletions

diff --git a/player/client.c b/player/client.c
index 1df7e659d8..45af55bee9 100644
--- a/player/client.c
+++ b/player/client.c
@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <locale.h>
+#include <math.h>
 #include <assert.h>
 
 #include "common/common.h"
@@ -46,8 +47,6 @@
 #include "core.h"
 #include "client.h"
 
-#include "config.h"
-
 /*
  * Locking hierarchy:
  *
@@ -74,6 +73,9 @@ struct mp_client_api {
 
     struct mp_custom_protocol *custom_protocols;
     int num_custom_protocols;
+
+    struct mpv_render_context *render_context;
+    struct mpv_opengl_cb_context *gl_cb_ctx;
 };
 
 struct observe_property {
@@ -156,6 +158,16 @@ void mp_clients_destroy(struct MPContext *mpctx)
     if (!mpctx->clients)
         return;
     assert(mpctx->clients->num_clients == 0);
+
+    TA_FREEP(&mpctx->clients->gl_cb_ctx);
+
+    // The API user is supposed to call mpv_render_context_free(). It's simply
+    // not allowed not to do this.
+    if (mpctx->clients->render_context) {
+        MP_FATAL(mpctx, "Broken API use: mpv_render_context_free() not called.\n");
+        abort();
+    }
+
     pthread_mutex_destroy(&mpctx->clients->lock);
     talloc_free(mpctx->clients);
     mpctx->clients = NULL;
@@ -279,6 +291,11 @@ struct mp_log *mp_client_get_log(struct mpv_handle *ctx)
     return ctx->log;
 }
 
+struct mpv_global *mp_client_get_global(struct mpv_handle *ctx)
+{
+    return ctx->mpctx->global;
+}
+
 struct MPContext *mp_client_get_core(struct mpv_handle *ctx)
 {
     return ctx->mpctx;
@@ -1672,7 +1689,9 @@ int64_t mpv_get_time_us(mpv_handle *ctx)
     return mp_time_us();
 }
 
-// Used by vo_opengl_cb to synchronously uninitialize video.
+#include "video/out/libmpv.h"
+
+// Used by vo_libmpv to synchronously uninitialize video.
 void kill_video(struct mp_client_api *client_api)
 {
     struct MPContext *mpctx = client_api->mpctx;
@@ -1686,58 +1705,163 @@ void kill_video(struct mp_client_api *client_api)
     mp_dispatch_unlock(mpctx->dispatch);
 }
 
+// Used by vo_libmpv to set the current render context.
+bool mp_set_main_render_context(struct mp_client_api *client_api,
+                                struct mpv_render_context *ctx, bool active)
+{
+    assert(ctx);
+
+    pthread_mutex_lock(&client_api->lock);
+    bool is_set = !!client_api->render_context;
+    bool is_same = client_api->render_context == ctx;
+    // Can set if it doesn't remove another existing ctx.
+    bool res = is_same || !is_set;
+    if (res)
+        client_api->render_context = active ? ctx : NULL;
+    pthread_mutex_unlock(&client_api->lock);
+    return res;
+}
+
+// Used by vo_libmpv. Relies on guarantees by mp_render_context_acquire().
+struct mpv_render_context *
+mp_client_api_acquire_render_context(struct mp_client_api *ca)
+{
+    struct mpv_render_context *res = NULL;
+    pthread_mutex_lock(&ca->lock);
+    if (ca->render_context && mp_render_context_acquire(ca->render_context))
+        res = ca->render_context;
+    pthread_mutex_unlock(&ca->lock);
+    return res;
+}
+
+// Emulation of old opengl_cb API.
+
 #include "libmpv/opengl_cb.h"
+#include "libmpv/render_gl.h"
+
+struct mpv_opengl_cb_context {
+    struct mp_client_api *client_api;
+    mpv_opengl_cb_update_fn callback;
+    void *callback_ctx;
+};
 
-#if HAVE_GL
 static mpv_opengl_cb_context *opengl_cb_get_context(mpv_handle *ctx)
 {
-    mpv_opengl_cb_context *cb = ctx->mpctx->gl_cb_ctx;
+    pthread_mutex_lock(&ctx->clients->lock);
+    mpv_opengl_cb_context *cb = ctx->clients->gl_cb_ctx;
     if (!cb) {
-        cb = mp_opengl_create(ctx->mpctx->global, ctx->clients);
-        ctx->mpctx->gl_cb_ctx = cb;
+        cb = talloc_zero(NULL, struct mpv_opengl_cb_context);
+        cb->client_api = ctx->clients;
+        cb->client_api->gl_cb_ctx = cb;
     }
+    pthread_mutex_unlock(&ctx->clients->lock);
     return cb;
 }
-#else
-static mpv_opengl_cb_context *opengl_cb_get_context(mpv_handle *ctx)
-{
-    return NULL;
-}
+
 void mpv_opengl_cb_set_update_callback(mpv_opengl_cb_context *ctx,
                                        mpv_opengl_cb_update_fn callback,
                                        void *callback_ctx)
 {
+    // This was probably supposed to be thread-safe, but we don't care. It's
+    // compatibility code, and if you have problems, use the new API.
+    if (ctx->client_api->render_context) {
+        mpv_render_context_set_update_callback(ctx->client_api->render_context,
+                                               callback, callback_ctx);
+    }
+    // Nasty thing: could set this even while not initialized, so we need to
+    // preserve it.
+    ctx->callback = callback;
+    ctx->callback_ctx = callback_ctx;
 }
+
 int mpv_opengl_cb_init_gl(mpv_opengl_cb_context *ctx, const char *exts,
                           mpv_opengl_cb_get_proc_address_fn get_proc_address,
                           void *get_proc_address_ctx)
 {
-    return MPV_ERROR_NOT_IMPLEMENTED;
+    if (ctx->client_api->render_context)
+        return MPV_ERROR_INVALID_PARAMETER;
+
+    // mpv_render_context_create() only calls mp_client_get_global() on it.
+    mpv_handle dummy = {.mpctx = ctx->client_api->mpctx};
+
+    mpv_render_param params[] = {
+        {MPV_RENDER_PARAM_API_TYPE, MPV_RENDER_API_TYPE_OPENGL},
+        {MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &(mpv_opengl_init_params){
+            .get_proc_address = get_proc_address,
+            .get_proc_address_ctx = get_proc_address_ctx,
+            .extra_exts = exts,
+        }},
+        {0}
+    };
+    int err = mpv_render_context_create(&ctx->client_api->render_context,
+                                        &dummy, params);
+    if (err >= 0) {
+        mpv_render_context_set_update_callback(ctx->client_api->render_context,
+                                               ctx->callback, ctx->callback_ctx);
+    }
+    return err;
 }
+
 int mpv_opengl_cb_draw(mpv_opengl_cb_context *ctx, int fbo, int w, int h)
 {
-    return MPV_ERROR_NOT_IMPLEMENTED;
+    if (!ctx->client_api->render_context)
+        return MPV_ERROR_INVALID_PARAMETER;
+
+    mpv_render_param params[] = {
+        {MPV_RENDER_PARAM_OPENGL_FBO, &(mpv_opengl_fbo){
+            .fbo = fbo,
+            .w = w,
+            .h = abs(h),
+        }},
+        {MPV_RENDER_PARAM_FLIP_Y, &(int){h < 0}},
+        {0}
+    };
+    return mpv_render_context_render(ctx->client_api->render_context, params);
 }
+
 int mpv_opengl_cb_report_flip(mpv_opengl_cb_context *ctx, int64_t time)
 {
-    return MPV_ERROR_NOT_IMPLEMENTED;
+    if (!ctx->client_api->render_context)
+        return MPV_ERROR_INVALID_PARAMETER;
+
+    mpv_render_context_report_swap(ctx->client_api->render_context);
+    return 0;
 }
+
 int mpv_opengl_cb_uninit_gl(mpv_opengl_cb_context *ctx)
 {
-    return MPV_ERROR_NOT_IMPLEMENTED;
+    if (ctx->client_api->render_context)
+        mpv_render_context_free(ctx->client_api->render_context);
+    ctx->client_api->render_context = NULL;
+    return 0;
 }
+
 void mp_client_set_control_callback(struct mpv_opengl_cb_context *ctx,
                                            mpv_opengl_cb_control_fn callback,
                                            void *callback_ctx)
 {
+    if (ctx->client_api->render_context) {
+        mp_render_context_set_control_callback(ctx->client_api->render_context,
+                                               callback, callback_ctx);
+    }
 }
+
 void mp_client_set_icc_profile(struct mpv_opengl_cb_context *ctx, bstr icc_data)
 {
+    if (!ctx->client_api->render_context)
+        return;
+    mpv_render_param param = {MPV_RENDER_PARAM_ICC_PROFILE,
+            &(mpv_byte_array){icc_data.start, icc_data.len}};
+    mpv_render_context_set_parameter(ctx->client_api->render_context, param);
 }
+
 void mp_client_set_ambient_lux(struct mpv_opengl_cb_context *ctx, int lux)
 {
+    if (!ctx->client_api->render_context)
+        return;
+    mpv_render_param param = {MPV_RENDER_PARAM_AMBIENT_LIGHT, &(int){lux}};
+    mpv_render_context_set_parameter(ctx->client_api->render_context, param);
 }
-#endif
 
 int mpv_opengl_cb_render(mpv_opengl_cb_context *ctx, int fbo, int vp[4])
 {
@@ -1749,16 +1873,12 @@ void *mp_get_sub_api2(mpv_handle *ctx, mpv_sub_api sub_api, bool lock)
     if (!ctx->mpctx->initialized)
         return NULL;
     void *res = NULL;
-    if (lock)
-        lock_core(ctx);
     switch (sub_api) {
     case MPV_SUB_API_OPENGL_CB:
         res = opengl_cb_get_context(ctx);
         break;
     default:;
     }
-    if (lock)
-        unlock_core(ctx);
     return res;
 }
 
@@ -1767,6 +1887,8 @@ void *mpv_get_sub_api(mpv_handle *ctx, mpv_sub_api sub_api)
     return mp_get_sub_api2(ctx, sub_api, true);
 }
 
+// stream_cb
+
 struct mp_custom_protocol {
     char *protocol;
     void *user_data;