From b03712143012f08591de59d09675fdd3a0eaeed8 Mon Sep 17 00:00:00 2001 From: wm4 Date: Tue, 20 Feb 2018 13:30:18 +0100 Subject: 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. --- video/out/gpu/libmpv_gpu.c | 182 +++++++++++++ video/out/gpu/libmpv_gpu.h | 38 +++ video/out/libmpv.h | 72 ++++++ video/out/opengl/libmpv_gl.c | 113 +++++++++ video/out/vo.c | 9 +- video/out/vo.h | 1 - video/out/vo_libmpv.c | 538 +++++++++++++++++++++++++++++++++++++++ video/out/vo_opengl_cb.c | 591 ------------------------------------------- 8 files changed, 947 insertions(+), 597 deletions(-) create mode 100644 video/out/gpu/libmpv_gpu.c create mode 100644 video/out/gpu/libmpv_gpu.h create mode 100644 video/out/libmpv.h create mode 100644 video/out/opengl/libmpv_gl.c create mode 100644 video/out/vo_libmpv.c delete mode 100644 video/out/vo_opengl_cb.c (limited to 'video/out') diff --git a/video/out/gpu/libmpv_gpu.c b/video/out/gpu/libmpv_gpu.c new file mode 100644 index 0000000000..bd597c302a --- /dev/null +++ b/video/out/gpu/libmpv_gpu.c @@ -0,0 +1,182 @@ +#include "config.h" +#include "hwdec.h" +#include "libmpv_gpu.h" +#include "video.h" +#include "video/out/libmpv.h" + +static const struct libmpv_gpu_context_fns *context_backends[] = { +#if HAVE_GL + &libmpv_gpu_context_gl, +#endif + NULL +}; + +struct priv { + struct libmpv_gpu_context *context; + + struct gl_video *renderer; +}; + +static int init(struct render_backend *ctx, mpv_render_param *params) +{ + ctx->priv = talloc_zero(NULL, struct priv); + struct priv *p = ctx->priv; + + char *api = get_mpv_render_param(params, MPV_RENDER_PARAM_API_TYPE, NULL); + if (!api) + return MPV_ERROR_INVALID_PARAMETER; + + for (int n = 0; context_backends[n]; n++) { + const struct libmpv_gpu_context_fns *backend = context_backends[n]; + if (strcmp(backend->api_name, api) == 0) { + p->context = talloc_zero(NULL, struct libmpv_gpu_context); + *p->context = (struct libmpv_gpu_context){ + .global = ctx->global, + .log = ctx->log, + .fns = backend, + }; + break; + } + } + + if (!p->context) + return MPV_ERROR_INVALID_PARAMETER; + + int err = p->context->fns->init(p->context, params); + if (err < 0) + return err; + + p->renderer = gl_video_init(p->context->ra, ctx->log, ctx->global); + + ctx->hwdec_devs = hwdec_devices_create(); + gl_video_load_hwdecs(p->renderer, ctx->hwdec_devs, true); + ctx->driver_caps = VO_CAP_ROTATE90; + return 0; +} + +static bool check_format(struct render_backend *ctx, int imgfmt) +{ + struct priv *p = ctx->priv; + + return gl_video_check_format(p->renderer, imgfmt); +} + +static int set_parameter(struct render_backend *ctx, mpv_render_param param) +{ + struct priv *p = ctx->priv; + + switch (param.type) { + case MPV_RENDER_PARAM_ICC_PROFILE: { + mpv_byte_array *data = param.data; + gl_video_set_icc_profile(p->renderer, (bstr){data->data, data->size}); + return 0; + } + case MPV_RENDER_PARAM_AMBIENT_LIGHT: { + int lux = *(int *)param.data; + gl_video_set_ambient_lux(p->renderer, lux); + return 0; + } + default: + return MPV_ERROR_NOT_IMPLEMENTED; + } +} + +static void reconfig(struct render_backend *ctx, struct mp_image_params *params) +{ + struct priv *p = ctx->priv; + + gl_video_config(p->renderer, params); +} + +static void reset(struct render_backend *ctx) +{ + struct priv *p = ctx->priv; + + gl_video_reset(p->renderer); +} + +static void update_external(struct render_backend *ctx, struct vo *vo) +{ + struct priv *p = ctx->priv; + + gl_video_set_osd_source(p->renderer, vo ? vo->osd : NULL); + if (vo) + gl_video_configure_queue(p->renderer, vo); +} + +static void resize(struct render_backend *ctx, struct mp_rect *src, + struct mp_rect *dst, struct mp_osd_res *osd) +{ + struct priv *p = ctx->priv; + + gl_video_resize(p->renderer, src, dst, osd); +} + +static int get_target_size(struct render_backend *ctx, mpv_render_param *params, + int *out_w, int *out_h) +{ + struct priv *p = ctx->priv; + + // Mapping the surface is cheap, better than adding new backend entrypoints. + struct ra_tex *tex; + int err = p->context->fns->wrap_fbo(p->context, params, &tex); + if (err < 0) + return err; + *out_w = tex->params.w; + *out_h = tex->params.h; + return 0; +} + +static int render(struct render_backend *ctx, mpv_render_param *params, + struct vo_frame *frame) +{ + struct priv *p = ctx->priv; + + // Mapping the surface is cheap, better than adding new backend entrypoints. + struct ra_tex *tex; + int err = p->context->fns->wrap_fbo(p->context, params, &tex); + if (err < 0) + return err; + + int depth = *(int *)get_mpv_render_param(params, MPV_RENDER_PARAM_DEPTH, + &(int){0}); + gl_video_set_fb_depth(p->renderer, depth); + + bool flip = *(int *)get_mpv_render_param(params, MPV_RENDER_PARAM_FLIP_Y, + &(int){0}); + + struct ra_fbo target = {.tex = tex, .flip = flip}; + gl_video_render_frame(p->renderer, frame, target, RENDER_FRAME_DEF); + p->context->fns->done_frame(p->context, frame->display_synced); + + return 0; +} + +static void destroy(struct render_backend *ctx) +{ + struct priv *p = ctx->priv; + + if (p->renderer) + gl_video_uninit(p->renderer); + + hwdec_devices_destroy(ctx->hwdec_devs); + + if (p->context) { + p->context->fns->destroy(p->context); + talloc_free(p->context->priv); + talloc_free(p->context); + } +} + +const struct render_backend_fns render_backend_gpu = { + .init = init, + .check_format = check_format, + .set_parameter = set_parameter, + .reconfig = reconfig, + .reset = reset, + .update_external = update_external, + .resize = resize, + .get_target_size = get_target_size, + .render = render, + .destroy = destroy, +}; diff --git a/video/out/gpu/libmpv_gpu.h b/video/out/gpu/libmpv_gpu.h new file mode 100644 index 0000000000..5b41116f14 --- /dev/null +++ b/video/out/gpu/libmpv_gpu.h @@ -0,0 +1,38 @@ +#pragma once + +#include "video/out/libmpv.h" + +struct libmpv_gpu_context { + struct mpv_global *global; + struct mp_log *log; + const struct libmpv_gpu_context_fns *fns; + + struct ra *ra; + void *priv; +}; + +// Manage backend specific interaction between libmpv and ra backend, that can't +// be managed by ra itself (initialization and passing FBOs). +struct libmpv_gpu_context_fns { + // The libmpv API type name, see MPV_RENDER_PARAM_API_TYPE. + const char *api_name; + // Pretty much works like render_backend_fns.init, except that the + // API type is already checked by the caller. + // Successful init must set ctx->ra. + int (*init)(struct libmpv_gpu_context *ctx, mpv_render_param *params); + // Wrap the surface passed to mpv_render_context_render() (via the params + // array) into a ra_tex and return it. Returns a libmpv error code, and sets + // *out to a temporary object on success. The returned object is valid until + // another wrap_fbo() or done_frame() is called. + // This does not need to care about generic attributes, like flipping. + int (*wrap_fbo)(struct libmpv_gpu_context *ctx, mpv_render_param *params, + struct ra_tex **out); + // Signal that the ra_tex object obtained with wrap_fbo is no longer used. + // For certain backends, this might also be used to signal the end of + // rendering (like OpenGL doing weird crap). + void (*done_frame)(struct libmpv_gpu_context *ctx, bool ds); + // Free all data in ctx->priv. + void (*destroy)(struct libmpv_gpu_context *ctx); +}; + +extern const struct libmpv_gpu_context_fns libmpv_gpu_context_gl; 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 +#include +#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; diff --git a/video/out/opengl/libmpv_gl.c b/video/out/opengl/libmpv_gl.c new file mode 100644 index 0000000000..fc22c67053 --- /dev/null +++ b/video/out/opengl/libmpv_gl.c @@ -0,0 +1,113 @@ +#include "common.h" +#include "context.h" +#include "ra_gl.h" +#include "options/m_config.h" +#include "libmpv/render_gl.h" +#include "video/out/gpu/libmpv_gpu.h" +#include "video/out/gpu/ra.h" + +struct priv { + GL *gl; + struct ra_ctx *ra_ctx; +}; + +static int init(struct libmpv_gpu_context *ctx, mpv_render_param *params) +{ + ctx->priv = talloc_zero(NULL, struct priv); + struct priv *p = ctx->priv; + + mpv_opengl_init_params *init_params = + get_mpv_render_param(params, MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, NULL); + if (!init_params) + return MPV_ERROR_INVALID_PARAMETER; + + p->gl = talloc_zero(p, GL); + + mpgl_load_functions2(p->gl, init_params->get_proc_address, + init_params->get_proc_address_ctx, + init_params->extra_exts, ctx->log); + if (!p->gl->version && !p->gl->es) { + MP_FATAL(ctx, "OpenGL not initialized.\n"); + return MPV_ERROR_UNSUPPORTED; + } + + // initialize a blank ra_ctx to reuse ra_gl_ctx + p->ra_ctx = talloc_zero(p, struct ra_ctx); + p->ra_ctx->log = ctx->log; + p->ra_ctx->global = ctx->global; + p->ra_ctx->opts = (struct ra_ctx_opts) { + .probing = false, + .allow_sw = true, + }; + + static const struct ra_swapchain_fns empty_swapchain_fns = {0}; + struct ra_gl_ctx_params gl_params = { + // vo_opengl_cb is essentially like a gigantic external swapchain where + // the user is in charge of presentation / swapping etc. But we don't + // actually need to provide any of these functions, since we can just + // not call them to begin with - so just set it to an empty object to + // signal to ra_gl_p that we don't care about its latency emulation + // functionality + .external_swapchain = &empty_swapchain_fns + }; + + p->gl->SwapInterval = NULL; // we shouldn't randomly change this, so lock it + if (!ra_gl_ctx_init(p->ra_ctx, p->gl, gl_params)) + return MPV_ERROR_UNSUPPORTED; + + int debug; + mp_read_option_raw(ctx->global, "gpu-debug", &m_option_type_flag, &debug); + p->ra_ctx->opts.debug = debug; + p->gl->debug_context = debug; + ra_gl_set_debug(p->ra_ctx->ra, debug); + + ctx->ra = p->ra_ctx->ra; + return 0; +} + +static int wrap_fbo(struct libmpv_gpu_context *ctx, mpv_render_param *params, + struct ra_tex **out) +{ + struct priv *p = ctx->priv; + + mpv_opengl_fbo *fbo = + get_mpv_render_param(params, MPV_RENDER_PARAM_OPENGL_FBO, NULL); + if (!fbo) + return MPV_ERROR_INVALID_PARAMETER; + + if (fbo->fbo && !(p->gl->mpgl_caps & MPGL_CAP_FB)) { + MP_FATAL(ctx, "Rendering to FBO requested, but no FBO extension found!\n"); + return MPV_ERROR_UNSUPPORTED; + } + + struct ra_swapchain *sw = p->ra_ctx->swapchain; + struct ra_fbo target; + ra_gl_ctx_resize(sw, fbo->w, fbo->h, fbo->fbo); + ra_gl_ctx_start_frame(sw, &target); + *out = target.tex; + return 0; +} + +static void done_frame(struct libmpv_gpu_context *ctx, bool ds) +{ + struct priv *p = ctx->priv; + + struct ra_swapchain *sw = p->ra_ctx->swapchain; + struct vo_frame dummy = {.display_synced = ds}; + ra_gl_ctx_submit_frame(sw, &dummy); +} + +static void destroy(struct libmpv_gpu_context *ctx) +{ + struct priv *p = ctx->priv; + + ra_gl_ctx_uninit(p->ra_ctx); +} + +const struct libmpv_gpu_context_fns libmpv_gpu_context_gl = { + .api_name = MPV_RENDER_API_TYPE_OPENGL, + .init = init, + .wrap_fbo = wrap_fbo, + .done_frame = done_frame, + .destroy = destroy, +}; diff --git a/video/out/vo.c b/video/out/vo.c index 6586ebc63e..af4f0fb163 100644 --- a/video/out/vo.c +++ b/video/out/vo.c @@ -52,7 +52,7 @@ extern const struct vo_driver video_out_x11; extern const struct vo_driver video_out_vdpau; extern const struct vo_driver video_out_xv; extern const struct vo_driver video_out_gpu; -extern const struct vo_driver video_out_opengl_cb; +extern const struct vo_driver video_out_libmpv; extern const struct vo_driver video_out_null; extern const struct vo_driver video_out_image; extern const struct vo_driver video_out_lavc; @@ -66,9 +66,7 @@ extern const struct vo_driver video_out_tct; const struct vo_driver *const video_out_drivers[] = { -#if HAVE_GL - &video_out_opengl_cb, -#endif + &video_out_libmpv, #if HAVE_ANDROID &video_out_mediacodec_embed, #endif @@ -185,7 +183,7 @@ static bool get_desc(struct m_obj_desc *dst, int index) .options = vo->options, .options_prefix = vo->options_prefix, .global_opts = vo->global_opts, - .hidden = vo->encode || !strcmp(vo->name, "opengl-cb"), + .hidden = vo->encode, .p = vo, }; return true; @@ -199,6 +197,7 @@ const struct m_obj_list vo_obj_list = { {"gl", "gpu"}, {"direct3d_shaders", "direct3d"}, {"opengl", "gpu"}, + {"opengl-cb", "libmpv"}, {0} }, .allow_unknown_entries = true, diff --git a/video/out/vo.h b/video/out/vo.h index 90b1d9a61d..4e21221c74 100644 --- a/video/out/vo.h +++ b/video/out/vo.h @@ -205,7 +205,6 @@ struct vo_extra { struct input_ctx *input_ctx; struct osd_state *osd; struct encode_lavc_context *encode_lavc_ctx; - struct mpv_opengl_cb_context *opengl_cb_context; void (*wakeup_cb)(void *ctx); void *wakeup_ctx; }; diff --git a/video/out/vo_libmpv.c b/video/out/vo_libmpv.c new file mode 100644 index 0000000000..61f73aee07 --- /dev/null +++ b/video/out/vo_libmpv.c @@ -0,0 +1,538 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config.h" + +#include "mpv_talloc.h" +#include "common/common.h" +#include "misc/bstr.h" +#include "common/msg.h" +#include "options/m_config.h" +#include "options/options.h" +#include "aspect.h" +#include "vo.h" +#include "video/mp_image.h" +#include "sub/osd.h" +#include "osdep/atomic.h" +#include "osdep/timer.h" + +#include "common/global.h" +#include "player/client.h" + +#include "libmpv.h" + +/* + * mpv_render_context is managed by the host application - the host application + * can access it any time, even if the VO is destroyed (or not created yet). + * + * - the libmpv user can mix render API and normal API; thus render API + * functions can wait on the core, but not the reverse + * - the core does blocking calls into the VO thread, thus the VO functions + * can't wait on the user calling the API functions + * - to make video timing work like it should, the VO thread waits on the + * render API user anyway, and the (unlikely) deadlock is avoided with + * a timeout + * + * So: mpv core > VO > mpv_render_context > mp_client_api.lock (locking) + * And: render thread > VO (wait for present) + * VO > render thread (wait for present done, via timeout) + */ + +struct vo_priv { + struct mpv_render_context *ctx; +}; + +struct mpv_render_context { + struct mp_log *log; + struct mpv_global *global; + struct mp_client_api *client_api; + + atomic_bool in_use; + + pthread_mutex_t control_lock; + mp_render_cb_control_fn control_cb; + void *control_cb_ctx; + + pthread_mutex_t lock; + pthread_cond_t wakeup; + + // --- Protected by lock + mpv_render_update_fn update_cb; + void *update_cb_ctx; + struct vo_frame *next_frame; // next frame to draw + int64_t present_count; // incremented when next frame can be shown + int64_t expected_flip_count; // next vsync event for next_frame + bool redrawing; // next_frame was a redraw request + int64_t flip_count; + struct vo_frame *cur_frame; + struct mp_image_params img_params; + int vp_w, vp_h; + bool flip; + bool imgfmt_supported[IMGFMT_END - IMGFMT_START]; + bool need_reconfig; + bool need_resize; + bool need_reset; + bool need_update_external; + struct vo *vo; + + // --- Mostly immutable after init. + struct mp_hwdec_devices *hwdec_devs; + + // --- All of these can only be accessed from mpv_render_*() API, for + // which the user makes sure they're called synchronized. + struct render_backend *renderer; + struct m_config_cache *vo_opts_cache; + struct mp_vo_opts *vo_opts; +}; + +static void update(struct mpv_render_context *ctx); + +const struct render_backend_fns *render_backends[] = { + &render_backend_gpu, + NULL +}; + +void *get_mpv_render_param(mpv_render_param *params, mpv_render_param_type type, + void *def) +{ + for (int n = 0; params && params[n].type; n++) { + if (params[n].type == type) + return params[n].data; + } + return def; +} + +static void forget_frames(struct mpv_render_context *ctx, bool all) +{ + pthread_cond_broadcast(&ctx->wakeup); + if (all) { + talloc_free(ctx->cur_frame); + ctx->cur_frame = NULL; + } +} + +int mpv_render_context_create(mpv_render_context **res, mpv_handle *mpv, + mpv_render_param *params) +{ + mpv_render_context *ctx = talloc_zero(NULL, mpv_render_context); + pthread_mutex_init(&ctx->control_lock, NULL); + pthread_mutex_init(&ctx->lock, NULL); + pthread_cond_init(&ctx->wakeup, NULL); + + ctx->global = mp_client_get_global(mpv); + ctx->client_api = ctx->global->client_api; + ctx->log = mp_log_new(ctx, ctx->global->log, "libmpv_render"); + + ctx->vo_opts_cache = m_config_cache_alloc(ctx, ctx->global, &vo_sub_opts); + ctx->vo_opts = ctx->vo_opts_cache->opts; + + int err = MPV_ERROR_NOT_IMPLEMENTED; + for (int n = 0; render_backends[n]; n++) { + ctx->renderer = talloc_zero(NULL, struct render_backend); + *ctx->renderer = (struct render_backend){ + .global = ctx->global, + .log = ctx->log, + .fns = render_backends[n], + }; + err = ctx->renderer->fns->init(ctx->renderer, params); + if (err >= 0) + break; + ctx->renderer->fns->destroy(ctx->renderer); + talloc_free(ctx->renderer->priv); + TA_FREEP(&ctx->renderer); + if (err != MPV_ERROR_NOT_IMPLEMENTED) + break; + } + + if (err < 0) { + mpv_render_context_free(ctx); + return err; + } + + ctx->hwdec_devs = ctx->renderer->hwdec_devs; + + for (int n = IMGFMT_START; n < IMGFMT_END; n++) { + ctx->imgfmt_supported[n - IMGFMT_START] = + ctx->renderer->fns->check_format(ctx->renderer, n); + } + + if (!mp_set_main_render_context(ctx->client_api, ctx, true)) { + MP_ERR(ctx, "There is already a mpv_render_context set.\n"); + mpv_render_context_free(ctx); + return MPV_ERROR_GENERIC; + } + + *res = ctx; + return 0; +} + +void mpv_render_context_set_update_callback(mpv_render_context *ctx, + mpv_render_update_fn callback, + void *callback_ctx) +{ + pthread_mutex_lock(&ctx->lock); + ctx->update_cb = callback; + ctx->update_cb_ctx = callback_ctx; + pthread_mutex_unlock(&ctx->lock); +} + +void mp_render_context_set_control_callback(mpv_render_context *ctx, + mp_render_cb_control_fn callback, + void *callback_ctx) +{ + pthread_mutex_lock(&ctx->control_lock); + ctx->control_cb = callback; + ctx->control_cb_ctx = callback_ctx; + pthread_mutex_unlock(&ctx->control_lock); +} + +void mpv_render_context_free(mpv_render_context *ctx) +{ + if (!ctx) + return; + + // From here on, ctx becomes invisible and cannot be newly acquired. Only + // a VO could still hold a reference. + mp_set_main_render_context(ctx->client_api, ctx, false); + + // If it's still in use, a VO using it must be active. Destroy the VO, and + // also bring down the decoder etc., which still might be using the hwdec + // context. The above removal guarantees it can't come back (so ctx->vo + // can't change to non-NULL). + if (atomic_load(&ctx->in_use)) + kill_video(ctx->client_api); + + assert(!atomic_load(&ctx->in_use)); + assert(!ctx->vo); + + forget_frames(ctx, true); + + ctx->renderer->fns->destroy(ctx->renderer); + talloc_free(ctx->renderer->priv); + talloc_free(ctx->renderer); + + pthread_cond_destroy(&ctx->wakeup); + pthread_mutex_destroy(&ctx->lock); + pthread_mutex_destroy(&ctx->control_lock); + + talloc_free(ctx); +} + +// Try to mark the context as "in exclusive use" (e.g. by a VO). +// Note: the function must not acquire any locks, because it's called with an +// external leaf lock held. +bool mp_render_context_acquire(mpv_render_context *ctx) +{ + bool prev = false; + return atomic_compare_exchange_strong(&ctx->in_use, &prev, true); +} + +int mpv_render_context_render(mpv_render_context *ctx, mpv_render_param *params) +{ + int vp_w, vp_h; + int err = ctx->renderer->fns->get_target_size(ctx->renderer, params, + &vp_w, &vp_h); + if (err < 0) + return err; + + pthread_mutex_lock(&ctx->lock); + + struct vo *vo = ctx->vo; + + if (vo && (ctx->vp_w != vp_w || ctx->vp_h != vp_h || ctx->need_resize)) { + ctx->vp_w = vp_w; + ctx->vp_h = vp_h; + + m_config_cache_update(ctx->vo_opts_cache); + + struct mp_rect src, dst; + struct mp_osd_res osd; + mp_get_src_dst_rects(ctx->log, ctx->vo_opts, vo->driver->caps, + &ctx->img_params, vp_w, abs(vp_h), + 1.0, &src, &dst, &osd); + + ctx->renderer->fns->resize(ctx->renderer, &src, &dst, &osd); + } + ctx->need_resize = false; + + if (ctx->need_reconfig) + ctx->renderer->fns->reconfig(ctx->renderer, &ctx->img_params); + ctx->need_reconfig = false; + + if (ctx->need_update_external) + ctx->renderer->fns->update_external(ctx->renderer, vo); + ctx->need_update_external = false; + + if (ctx->need_reset) { + ctx->renderer->fns->reset(ctx->renderer); + if (ctx->cur_frame) + ctx->cur_frame->still = true; + } + ctx->need_reset = false; + + struct vo_frame *frame = ctx->next_frame; + int64_t wait_present_count = ctx->present_count; + if (frame) { + ctx->next_frame = NULL; + if (!(frame->redraw || !frame->current)) + wait_present_count += 1; + pthread_cond_signal(&ctx->wakeup); + talloc_free(ctx->cur_frame); + ctx->cur_frame = vo_frame_ref(frame); + } else { + frame = vo_frame_ref(ctx->cur_frame); + if (frame) + frame->redraw = true; + MP_STATS(ctx, "glcb-noframe"); + } + struct vo_frame dummy = {0}; + if (!frame) + frame = &dummy; + + pthread_mutex_unlock(&ctx->lock); + + MP_STATS(ctx, "glcb-render"); + + err = ctx->renderer->fns->render(ctx->renderer, params, frame); + + if (frame != &dummy) + talloc_free(frame); + + pthread_mutex_lock(&ctx->lock); + while (wait_present_count > ctx->present_count) + pthread_cond_wait(&ctx->wakeup, &ctx->lock); + pthread_mutex_unlock(&ctx->lock); + + return err; +} + +void mpv_render_context_report_swap(mpv_render_context *ctx) +{ + MP_STATS(ctx, "glcb-reportflip"); + + pthread_mutex_lock(&ctx->lock); + ctx->flip_count += 1; + pthread_cond_signal(&ctx->wakeup); + pthread_mutex_unlock(&ctx->lock); +} + +int mpv_render_context_set_parameter(mpv_render_context *ctx, + mpv_render_param param) +{ + int err = ctx->renderer->fns->set_parameter(ctx->renderer, param); + if (err >= 0) { + // Might need to redraw. + pthread_mutex_lock(&ctx->lock); + if (ctx->vo) + update(ctx); + pthread_mutex_unlock(&ctx->lock); + } + return err; +} + +// Called locked. +static void update(struct mpv_render_context *ctx) +{ + if (ctx->update_cb) + ctx->update_cb(ctx->update_cb_ctx); +} + +static void draw_frame(struct vo *vo, struct vo_frame *frame) +{ + struct vo_priv *p = vo->priv; + + pthread_mutex_lock(&p->ctx->lock); + assert(!p->ctx->next_frame); + p->ctx->next_frame = vo_frame_ref(frame); + p->ctx->expected_flip_count = p->ctx->flip_count + 1; + p->ctx->redrawing = frame->redraw || !frame->current; + update(p->ctx); + pthread_mutex_unlock(&p->ctx->lock); +} + +static void flip_page(struct vo *vo) +{ + struct vo_priv *p = vo->priv; + struct timespec ts = mp_rel_time_to_timespec(0.2); + + pthread_mutex_lock(&p->ctx->lock); + + // Wait until frame was rendered + while (p->ctx->next_frame) { + if (pthread_cond_timedwait(&p->ctx->wakeup, &p->ctx->lock, &ts)) { + if (p->ctx->next_frame) { + MP_VERBOSE(vo, "mpv_render_context_render() not being called " + "or stuck.\n"); + goto done; + } + } + } + + // Unblock mpv_render_context_render(). + p->ctx->present_count += 1; + pthread_cond_signal(&p->ctx->wakeup); + + if (p->ctx->redrawing) + goto done; // do not block for redrawing + + // Wait until frame was presented + while (p->ctx->expected_flip_count > p->ctx->flip_count) { + // mpv_render_report_swap() is declared as optional API. + // Assume the user calls it consistently _if_ it's called at all. + if (!p->ctx->flip_count) + break; + if (pthread_cond_timedwait(&p->ctx->wakeup, &p->ctx->lock, &ts)) { + MP_VERBOSE(vo, "mpv_render_report_swap() not being called.\n"); + goto done; + } + } + +done: + + // Cleanup after the API user is not reacting, or is being unusually slow. + if (p->ctx->next_frame) { + talloc_free(p->ctx->cur_frame); + p->ctx->cur_frame = p->ctx->next_frame; + p->ctx->next_frame = NULL; + p->ctx->present_count += 2; + pthread_cond_signal(&p->ctx->wakeup); + vo_increment_drop_count(vo, 1); + } + + pthread_mutex_unlock(&p->ctx->lock); +} + +static int query_format(struct vo *vo, int format) +{ + struct vo_priv *p = vo->priv; + + bool ok = false; + pthread_mutex_lock(&p->ctx->lock); + if (format >= IMGFMT_START && format < IMGFMT_END) + ok = p->ctx->imgfmt_supported[format - IMGFMT_START]; + pthread_mutex_unlock(&p->ctx->lock); + return ok; +} + +static int control(struct vo *vo, uint32_t request, void *data) +{ + struct vo_priv *p = vo->priv; + + switch (request) { + case VOCTRL_RESET: + pthread_mutex_lock(&p->ctx->lock); + forget_frames(p->ctx, false); + p->ctx->need_reset = true; + update(p->ctx); + pthread_mutex_unlock(&p->ctx->lock); + return VO_TRUE; + case VOCTRL_PAUSE: + vo->want_redraw = true; + return VO_TRUE; + case VOCTRL_SET_EQUALIZER: + vo->want_redraw = true; + return VO_TRUE; + case VOCTRL_SET_PANSCAN: + pthread_mutex_lock(&p->ctx->lock); + p->ctx->need_resize = true; + update(p->ctx); + pthread_mutex_unlock(&p->ctx->lock); + return VO_TRUE; + case VOCTRL_UPDATE_RENDER_OPTS: + pthread_mutex_lock(&p->ctx->lock); + p->ctx->need_update_external = true; + update(p->ctx); + pthread_mutex_unlock(&p->ctx->lock); + return VO_TRUE; + } + + int r = VO_NOTIMPL; + pthread_mutex_lock(&p->ctx->control_lock); + if (p->ctx->control_cb) { + int events = 0; + r = p->ctx->control_cb(p->ctx->control_cb_ctx, &events, request, data); + vo_event(vo, events); + } + pthread_mutex_unlock(&p->ctx->control_lock); + + return r; +} + +static int reconfig(struct vo *vo, struct mp_image_params *params) +{ + struct vo_priv *p = vo->priv; + + pthread_mutex_lock(&p->ctx->lock); + forget_frames(p->ctx, true); + p->ctx->img_params = *params; + p->ctx->need_reconfig = true; + p->ctx->need_resize = true; + pthread_mutex_unlock(&p->ctx->lock); + control(vo, VOCTRL_RECONFIG, NULL); + + return 0; +} + +static void uninit(struct vo *vo) +{ + struct vo_priv *p = vo->priv; + + control(vo, VOCTRL_UNINIT, NULL); + pthread_mutex_lock(&p->ctx->lock); + forget_frames(p->ctx, true); + p->ctx->img_params = (struct mp_image_params){0}; + p->ctx->need_reconfig = true; + p->ctx->need_resize = true; + p->ctx->need_update_external = true; + p->ctx->need_reset = true; + p->ctx->vo = NULL; + update(p->ctx); + pthread_mutex_unlock(&p->ctx->lock); + + bool state = atomic_exchange(&p->ctx->in_use, false); + assert(state); // obviously must have been set +} + +static int preinit(struct vo *vo) +{ + struct vo_priv *p = vo->priv; + + p->ctx = mp_client_api_acquire_render_context(vo->global->client_api); + + if (!p->ctx) { + if (!vo->probing) + MP_FATAL(vo, "No render context set.\n"); + return -1; + } + + pthread_mutex_lock(&p->ctx->lock); + p->ctx->vo = vo; + p->ctx->need_resize = true; + p->ctx->need_update_external = true; + pthread_mutex_unlock(&p->ctx->lock); + + vo->hwdec_devs = p->ctx->hwdec_devs; + control(vo, VOCTRL_PREINIT, NULL); + + return 0; +} + +const struct vo_driver video_out_libmpv = { + .description = "render API for libmpv", + .name = "libmpv", + .caps = VO_CAP_ROTATE90, + .preinit = preinit, + .query_format = query_format, + .reconfig = reconfig, + .control = control, + .draw_frame = draw_frame, + .flip_page = flip_page, + .uninit = uninit, + .priv_size = sizeof(struct vo_priv), +}; diff --git a/video/out/vo_opengl_cb.c b/video/out/vo_opengl_cb.c deleted file mode 100644 index 40dcb035ca..0000000000 --- a/video/out/vo_opengl_cb.c +++ /dev/null @@ -1,591 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include - -#include "config.h" - -#include "mpv_talloc.h" -#include "common/common.h" -#include "misc/bstr.h" -#include "common/msg.h" -#include "options/m_config.h" -#include "options/options.h" -#include "aspect.h" -#include "vo.h" -#include "video/mp_image.h" -#include "sub/osd.h" -#include "osdep/timer.h" - -#include "common/global.h" -#include "player/client.h" - -#include "gpu/video.h" -#include "gpu/hwdec.h" -#include "opengl/common.h" -#include "opengl/context.h" -#include "opengl/ra_gl.h" - -#include "libmpv/opengl_cb.h" - -/* - * mpv_opengl_cb_context is created by the host application - the host application - * can access it any time, even if the VO is destroyed (or not created yet). - * The OpenGL object allows initializing the renderer etc. The VO object is only - * here to transfer the video frames somehow. - * - * Locking hierarchy: - * - the libmpv user can mix openglcb and normal API; thus openglcb API - * functions can wait on the core, but not the reverse - * - the core does blocking calls into the VO thread, thus the VO functions - * can't wait on the user calling the API functions - * - to make video timing work like it should, the VO thread waits on the - * openglcb API user anyway, and the (unlikely) deadlock is avoided with - * a timeout - */ - -struct vo_priv { - struct mpv_opengl_cb_context *ctx; -}; - -struct mpv_opengl_cb_context { - struct mp_log *log; - struct mpv_global *global; - struct mp_client_api *client_api; - - pthread_mutex_t control_lock; - mpv_opengl_cb_control_fn control_cb; - void *control_cb_ctx; - - pthread_mutex_t lock; - pthread_cond_t wakeup; - - // --- Protected by lock - bool initialized; - mpv_opengl_cb_update_fn update_cb; - void *update_cb_ctx; - struct vo_frame *next_frame; // next frame to draw - int64_t present_count; // incremented when next frame can be shown - int64_t expected_flip_count; // next vsync event for next_frame - bool redrawing; // next_frame was a redraw request - int64_t flip_count; - struct vo_frame *cur_frame; - struct mp_image_params img_params; - bool reconfigured, reset; - int vp_w, vp_h; - bool flip; - bool force_update; - bool imgfmt_supported[IMGFMT_END - IMGFMT_START]; - bool update_new_opts; - struct vo *active; - bool icc_was_set; - - // --- This is only mutable while initialized=false, during which nothing - // except the OpenGL context manager is allowed to access it. - struct mp_hwdec_devices *hwdec_devs; - - // --- All of these can only be accessed from the thread where the host - // application's OpenGL context is current - i.e. only while the - // host application is calling certain mpv_opengl_cb_* APIs. - GL *gl; - struct ra_ctx *ra_ctx; - struct gl_video *renderer; - struct m_config_cache *vo_opts_cache; - struct mp_vo_opts *vo_opts; -}; - -static void update(struct mpv_opengl_cb_context *ctx); - -static void forget_frames(struct mpv_opengl_cb_context *ctx, bool all) -{ - pthread_cond_broadcast(&ctx->wakeup); - if (all) { - talloc_free(ctx->cur_frame); - ctx->cur_frame = NULL; - } -} - -static void free_ctx(void *ptr) -{ - mpv_opengl_cb_context *ctx = ptr; - - // This can trigger if the client API user doesn't call - // mpv_opengl_cb_uninit_gl() properly. - assert(!ctx->initialized); - - pthread_cond_destroy(&ctx->wakeup); - pthread_mutex_destroy(&ctx->lock); - pthread_mutex_destroy(&ctx->control_lock); -} - -struct mpv_opengl_cb_context *mp_opengl_create(struct mpv_global *g, - struct mp_client_api *client_api) -{ - mpv_opengl_cb_context *ctx = talloc_zero(NULL, mpv_opengl_cb_context); - talloc_set_destructor(ctx, free_ctx); - pthread_mutex_init(&ctx->control_lock, NULL); - pthread_mutex_init(&ctx->lock, NULL); - pthread_cond_init(&ctx->wakeup, NULL); - - ctx->global = g; - ctx->log = mp_log_new(ctx, g->log, "opengl-cb"); - ctx->client_api = client_api; - - ctx->vo_opts_cache = m_config_cache_alloc(ctx, ctx->global, &vo_sub_opts); - ctx->vo_opts = ctx->vo_opts_cache->opts; - - return ctx; -} - -void mpv_opengl_cb_set_update_callback(struct mpv_opengl_cb_context *ctx, - mpv_opengl_cb_update_fn callback, - void *callback_ctx) -{ - pthread_mutex_lock(&ctx->lock); - ctx->update_cb = callback; - ctx->update_cb_ctx = callback_ctx; - pthread_mutex_unlock(&ctx->lock); -} - - -void mp_client_set_control_callback(struct mpv_opengl_cb_context *ctx, - mpv_opengl_cb_control_fn callback, - void *callback_ctx) -{ - pthread_mutex_lock(&ctx->control_lock); - ctx->control_cb = callback; - ctx->control_cb_ctx = callback_ctx; - pthread_mutex_unlock(&ctx->control_lock); -} - -// Reset some GL attributes the user might clobber. For mid-term compatibility -// only - we expect both user code and our code to do this correctly. -static void reset_gl_state(GL *gl) -{ - gl->ActiveTexture(GL_TEXTURE0); - if (gl->mpgl_caps & MPGL_CAP_ROW_LENGTH) - gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0); - gl->PixelStorei(GL_UNPACK_ALIGNMENT, 4); -} - -int mpv_opengl_cb_init_gl(struct mpv_opengl_cb_context *ctx, const char *exts, - mpv_opengl_cb_get_proc_address_fn get_proc_address, - void *get_proc_address_ctx) -{ - if (ctx->renderer) - return MPV_ERROR_INVALID_PARAMETER; - - talloc_free(ctx->gl); - ctx->gl = talloc_zero(ctx, GL); - - mpgl_load_functions2(ctx->gl, get_proc_address, get_proc_address_ctx, - exts, ctx->log); - if (!ctx->gl->version && !ctx->gl->es) { - MP_FATAL(ctx, "OpenGL not initialized.\n"); - return MPV_ERROR_UNSUPPORTED; - } - - // initialize a blank ra_ctx to reuse ra_gl_ctx - ctx->ra_ctx = talloc_zero(ctx, struct ra_ctx); - ctx->ra_ctx->log = ctx->log; - ctx->ra_ctx->global = ctx->global; - ctx->ra_ctx->opts = (struct ra_ctx_opts) { - .probing = false, - .allow_sw = true, - }; - - static const struct ra_swapchain_fns empty_swapchain_fns = {0}; - struct ra_gl_ctx_params gl_params = { - // vo_opengl_cb is essentially like a gigantic external swapchain where - // the user is in charge of presentation / swapping etc. But we don't - // actually need to provide any of these functions, since we can just - // not call them to begin with - so just set it to an empty object to - // signal to ra_gl_ctx that we don't care about its latency emulation - // functionality - .external_swapchain = &empty_swapchain_fns - }; - - ctx->gl->SwapInterval = NULL; // we shouldn't randomly change this, so lock it - if (!ra_gl_ctx_init(ctx->ra_ctx, ctx->gl, gl_params)) - return MPV_ERROR_UNSUPPORTED; - - ctx->renderer = gl_video_init(ctx->ra_ctx->ra, ctx->log, ctx->global); - - ctx->hwdec_devs = hwdec_devices_create(); - gl_video_load_hwdecs(ctx->renderer, ctx->hwdec_devs, true); - - pthread_mutex_lock(&ctx->lock); - for (int n = IMGFMT_START; n < IMGFMT_END; n++) { - ctx->imgfmt_supported[n - IMGFMT_START] = - gl_video_check_format(ctx->renderer, n); - } - ctx->initialized = true; - pthread_mutex_unlock(&ctx->lock); - - reset_gl_state(ctx->gl); - return 0; -} - -int mpv_opengl_cb_uninit_gl(struct mpv_opengl_cb_context *ctx) -{ - if (!ctx) - return 0; - - // Bring down the decoder etc., which still might be using the hwdec - // context. Setting initialized=false guarantees it can't come back. - - pthread_mutex_lock(&ctx->lock); - forget_frames(ctx, true); - ctx->initialized = false; - bool was_active = ctx->active ? true : false; - pthread_mutex_unlock(&ctx->lock); - - if (was_active) - kill_video(ctx->client_api); - - pthread_mutex_lock(&ctx->lock); - assert(!ctx->active); - pthread_mutex_unlock(&ctx->lock); - - gl_video_uninit(ctx->renderer); - ctx->renderer = NULL; - hwdec_devices_destroy(ctx->hwdec_devs); - ctx->hwdec_devs = NULL; - ra_gl_ctx_uninit(ctx->ra_ctx); - talloc_free(ctx->ra_ctx); - talloc_free(ctx->gl); - ctx->ra_ctx = NULL; - ctx->gl = NULL; - return 0; -} - -int mpv_opengl_cb_draw(mpv_opengl_cb_context *ctx, int fbo, int vp_w, int vp_h) -{ - assert(ctx->renderer); - - if (fbo && !(ctx->gl->mpgl_caps & MPGL_CAP_FB)) { - MP_FATAL(ctx, "Rendering to FBO requested, but no FBO extension found!\n"); - return MPV_ERROR_UNSUPPORTED; - } - - reset_gl_state(ctx->gl); - - pthread_mutex_lock(&ctx->lock); - - struct vo *vo = ctx->active; - - ctx->force_update |= ctx->reconfigured; - - if (ctx->vp_w != vp_w || ctx->vp_h != vp_h) - ctx->force_update = true; - - if (ctx->force_update && vo) { - ctx->force_update = false; - ctx->vp_w = vp_w; - ctx->vp_h = vp_h; - - m_config_cache_update(ctx->vo_opts_cache); - - struct mp_rect src, dst; - struct mp_osd_res osd; - mp_get_src_dst_rects(ctx->log, ctx->vo_opts, vo->driver->caps, - &ctx->img_params, vp_w, abs(vp_h), - 1.0, &src, &dst, &osd); - - gl_video_resize(ctx->renderer, &src, &dst, &osd); - } - - if (ctx->reconfigured) { - gl_video_set_osd_source(ctx->renderer, vo ? vo->osd : NULL); - gl_video_config(ctx->renderer, &ctx->img_params); - } - if (ctx->update_new_opts) { - if (vo) - gl_video_configure_queue(ctx->renderer, vo); - int debug; - mp_read_option_raw(ctx->global, "gpu-debug", &m_option_type_flag, - &debug); - ctx->gl->debug_context = debug; - ra_gl_set_debug(ctx->ra_ctx->ra, debug); - if (!ctx->icc_was_set && gl_video_icc_auto_enabled(ctx->renderer)) - MP_ERR(ctx, "icc-profile-auto is not available with opengl-cb\n"); - } - ctx->reconfigured = false; - ctx->update_new_opts = false; - - if (ctx->reset) { - gl_video_reset(ctx->renderer); - ctx->reset = false; - if (ctx->cur_frame) - ctx->cur_frame->still = true; - } - - struct vo_frame *frame = ctx->next_frame; - int64_t wait_present_count = ctx->present_count; - if (frame) { - ctx->next_frame = NULL; - if (!(frame->redraw || !frame->current)) - wait_present_count += 1; - pthread_cond_signal(&ctx->wakeup); - talloc_free(ctx->cur_frame); - ctx->cur_frame = vo_frame_ref(frame); - } else { - frame = vo_frame_ref(ctx->cur_frame); - if (frame) - frame->redraw = true; - MP_STATS(ctx, "glcb-noframe"); - } - struct vo_frame dummy = {0}; - if (!frame) - frame = &dummy; - - pthread_mutex_unlock(&ctx->lock); - - MP_STATS(ctx, "glcb-render"); - struct ra_swapchain *sw = ctx->ra_ctx->swapchain; - struct ra_fbo target; - ra_gl_ctx_resize(sw, vp_w, abs(vp_h), fbo); - ra_gl_ctx_start_frame(sw, &target); - target.flip = vp_h < 0; - gl_video_render_frame(ctx->renderer, frame, target, RENDER_FRAME_DEF); - ra_gl_ctx_submit_frame(sw, frame); - - reset_gl_state(ctx->gl); - - if (frame != &dummy) - talloc_free(frame); - - pthread_mutex_lock(&ctx->lock); - while (wait_present_count > ctx->present_count) - pthread_cond_wait(&ctx->wakeup, &ctx->lock); - pthread_mutex_unlock(&ctx->lock); - - return 0; -} - -int mpv_opengl_cb_report_flip(mpv_opengl_cb_context *ctx, int64_t time) -{ - MP_STATS(ctx, "glcb-reportflip"); - - pthread_mutex_lock(&ctx->lock); - ctx->flip_count += 1; - pthread_cond_signal(&ctx->wakeup); - pthread_mutex_unlock(&ctx->lock); - - return 0; -} - -// Called locked. -static void update(struct mpv_opengl_cb_context *ctx) -{ - if (ctx->update_cb) - ctx->update_cb(ctx->update_cb_ctx); -} - -static void draw_frame(struct vo *vo, struct vo_frame *frame) -{ - struct vo_priv *p = vo->priv; - - pthread_mutex_lock(&p->ctx->lock); - assert(!p->ctx->next_frame); - p->ctx->next_frame = vo_frame_ref(frame); - p->ctx->expected_flip_count = p->ctx->flip_count + 1; - p->ctx->redrawing = frame->redraw || !frame->current; - update(p->ctx); - pthread_mutex_unlock(&p->ctx->lock); -} - -static void flip_page(struct vo *vo) -{ - struct vo_priv *p = vo->priv; - struct timespec ts = mp_rel_time_to_timespec(0.2); - - pthread_mutex_lock(&p->ctx->lock); - - // Wait until frame was rendered - while (p->ctx->next_frame) { - if (pthread_cond_timedwait(&p->ctx->wakeup, &p->ctx->lock, &ts)) { - if (p->ctx->next_frame) { - MP_VERBOSE(vo, "mpv_opengl_cb_draw() not being called or stuck.\n"); - goto done; - } - } - } - - // Unblock mpv_opengl_cb_draw(). - p->ctx->present_count += 1; - pthread_cond_signal(&p->ctx->wakeup); - - if (p->ctx->redrawing) - goto done; // do not block for redrawing - - // Wait until frame was presented - while (p->ctx->expected_flip_count > p->ctx->flip_count) { - // mpv_opengl_cb_report_flip() is declared as optional API. - // Assume the user calls it consistently _if_ it's called at all. - if (!p->ctx->flip_count) - break; - if (pthread_cond_timedwait(&p->ctx->wakeup, &p->ctx->lock, &ts)) { - MP_VERBOSE(vo, "mpv_opengl_cb_report_flip() not being called.\n"); - goto done; - } - } - -done: - - // Cleanup after the API user is not reacting, or is being unusually slow. - if (p->ctx->next_frame) { - talloc_free(p->ctx->cur_frame); - p->ctx->cur_frame = p->ctx->next_frame; - p->ctx->next_frame = NULL; - p->ctx->present_count += 2; - pthread_cond_signal(&p->ctx->wakeup); - vo_increment_drop_count(vo, 1); - } - - pthread_mutex_unlock(&p->ctx->lock); -} - -static int query_format(struct vo *vo, int format) -{ - struct vo_priv *p = vo->priv; - - bool ok = false; - pthread_mutex_lock(&p->ctx->lock); - if (format >= IMGFMT_START && format < IMGFMT_END) - ok = p->ctx->imgfmt_supported[format - IMGFMT_START]; - pthread_mutex_unlock(&p->ctx->lock); - return ok; -} - -// Can only be called from the GL thread -void mp_client_set_icc_profile(struct mpv_opengl_cb_context *ctx, bstr icc_data) -{ - gl_video_set_icc_profile(ctx->renderer, icc_data); - pthread_mutex_lock(&ctx->lock); - ctx->icc_was_set = true; - if (ctx->active) - update(ctx); - pthread_mutex_unlock(&ctx->lock); -} - -void mp_client_set_ambient_lux(struct mpv_opengl_cb_context *ctx, int lux) -{ - gl_video_set_ambient_lux(ctx->renderer, lux); -} - -static int control(struct vo *vo, uint32_t request, void *data) -{ - struct vo_priv *p = vo->priv; - - switch (request) { - case VOCTRL_RESET: - pthread_mutex_lock(&p->ctx->lock); - forget_frames(p->ctx, false); - p->ctx->reset = true; - pthread_mutex_unlock(&p->ctx->lock); - return VO_TRUE; - case VOCTRL_PAUSE: - vo->want_redraw = true; - return VO_TRUE; - case VOCTRL_SET_EQUALIZER: - vo->want_redraw = true; - return VO_TRUE; - case VOCTRL_SET_PANSCAN: - pthread_mutex_lock(&p->ctx->lock); - p->ctx->force_update = true; - update(p->ctx); - pthread_mutex_unlock(&p->ctx->lock); - return VO_TRUE; - case VOCTRL_UPDATE_RENDER_OPTS: - pthread_mutex_lock(&p->ctx->lock); - p->ctx->update_new_opts = true; - update(p->ctx); - pthread_mutex_unlock(&p->ctx->lock); - return VO_TRUE; - } - - int r = VO_NOTIMPL; - pthread_mutex_lock(&p->ctx->control_lock); - if (p->ctx->control_cb) { - int events = 0; - r = p->ctx->control_cb(p->ctx->control_cb_ctx, &events, request, data); - vo_event(vo, events); - } - pthread_mutex_unlock(&p->ctx->control_lock); - - return r; -} - -static int reconfig(struct vo *vo, struct mp_image_params *params) -{ - struct vo_priv *p = vo->priv; - - pthread_mutex_lock(&p->ctx->lock); - forget_frames(p->ctx, true); - p->ctx->img_params = *params; - p->ctx->reconfigured = true; - pthread_mutex_unlock(&p->ctx->lock); - control(vo, VOCTRL_RECONFIG, NULL); - - return 0; -} - -static void uninit(struct vo *vo) -{ - struct vo_priv *p = vo->priv; - - control(vo, VOCTRL_UNINIT, NULL); - pthread_mutex_lock(&p->ctx->lock); - forget_frames(p->ctx, true); - p->ctx->img_params = (struct mp_image_params){0}; - p->ctx->reconfigured = true; - p->ctx->active = NULL; - update(p->ctx); - pthread_mutex_unlock(&p->ctx->lock); -} - -static int preinit(struct vo *vo) -{ - struct vo_priv *p = vo->priv; - p->ctx = vo->extra.opengl_cb_context; - if (!p->ctx) { - if (!vo->probing) - MP_FATAL(vo, "No context set.\n"); - return -1; - } - - pthread_mutex_lock(&p->ctx->lock); - if (!p->ctx->initialized) { - MP_FATAL(vo, "OpenGL context not initialized.\n"); - pthread_mutex_unlock(&p->ctx->lock); - return -1; - } - p->ctx->active = vo; - p->ctx->reconfigured = true; - p->ctx->update_new_opts = true; - pthread_mutex_unlock(&p->ctx->lock); - - vo->hwdec_devs = p->ctx->hwdec_devs; - control(vo, VOCTRL_PREINIT, NULL); - - return 0; -} - -const struct vo_driver video_out_opengl_cb = { - .description = "OpenGL Callbacks for libmpv", - .name = "opengl-cb", - .caps = VO_CAP_ROTATE90, - .preinit = preinit, - .query_format = query_format, - .reconfig = reconfig, - .control = control, - .draw_frame = draw_frame, - .flip_page = flip_page, - .uninit = uninit, - .priv_size = sizeof(struct vo_priv), -}; -- cgit v1.2.3