mirror of
https://github.com/mpv-player/mpv
synced 2025-01-05 06:30:06 +00:00
96e75d234a
This solves the issue where we would not receive any frame events. The difference to my earlier tests is that now it looks like eglSwapBuffers uses it's own event queue or something similiar along the lines. Becaues the performance is the same as without any redraw callback.
254 lines
8.4 KiB
C
254 lines
8.4 KiB
C
/*
|
|
* This file is part of mpv video player.
|
|
* Copyright © 2013 Alexander Preisinger <alexander.preisinger@gmail.com>
|
|
*
|
|
* mpv is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with mpv. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "wayland_common.h"
|
|
#include "gl_common.h"
|
|
|
|
static void egl_resize(struct vo_wayland_state *wl)
|
|
{
|
|
int32_t x = wl->window.sh_x;
|
|
int32_t y = wl->window.sh_y;
|
|
int32_t width = wl->window.sh_width;
|
|
int32_t height = wl->window.sh_height;
|
|
|
|
// get the real size of the window
|
|
// this improves moving the window while resizing it
|
|
wl_egl_window_get_attached_size(wl->egl_context.egl_window,
|
|
&wl->window.width,
|
|
&wl->window.height);
|
|
|
|
MP_VERBOSE(wl, "resizing %dx%d -> %dx%d\n", wl->window.width,
|
|
wl->window.height,
|
|
width,
|
|
height);
|
|
|
|
if (x != 0)
|
|
x = wl->window.width - width;
|
|
|
|
if (y != 0)
|
|
y = wl->window.height - height;
|
|
|
|
wl_egl_window_resize(wl->egl_context.egl_window, width, height, x, y);
|
|
|
|
wl->window.width = width;
|
|
wl->window.height = height;
|
|
|
|
/* set size for mplayer */
|
|
wl->vo->dwidth = wl->window.width;
|
|
wl->vo->dheight = wl->window.height;
|
|
|
|
wl->vo->want_redraw = true;
|
|
wl->window.events = 0;
|
|
}
|
|
|
|
static bool egl_create_context(struct vo_wayland_state *wl,
|
|
MPGLContext *ctx,
|
|
bool enable_alpha)
|
|
{
|
|
EGLint major, minor, n;
|
|
|
|
GL *gl = ctx->gl;
|
|
const char *eglstr = "";
|
|
|
|
if (!(wl->egl_context.egl.dpy = eglGetDisplay(wl->display.display)))
|
|
return false;
|
|
|
|
EGLint config_attribs[] = {
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
|
|
EGL_RED_SIZE, 1,
|
|
EGL_GREEN_SIZE, 1,
|
|
EGL_BLUE_SIZE, 1,
|
|
EGL_ALPHA_SIZE, enable_alpha,
|
|
EGL_DEPTH_SIZE, 1,
|
|
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
|
|
EGL_NONE
|
|
};
|
|
|
|
/* major and minor here returns the supported EGL version (e.g.: 1.4) */
|
|
if (eglInitialize(wl->egl_context.egl.dpy, &major, &minor) != EGL_TRUE)
|
|
return false;
|
|
|
|
MP_VERBOSE(wl, "EGL version %d.%d\n", major, minor);
|
|
|
|
EGLint context_attribs[] = {
|
|
EGL_CONTEXT_MAJOR_VERSION_KHR,
|
|
MPGL_VER_GET_MAJOR(ctx->requested_gl_version),
|
|
EGL_NONE
|
|
};
|
|
|
|
if (eglBindAPI(EGL_OPENGL_API) != EGL_TRUE)
|
|
return false;
|
|
|
|
eglChooseConfig(wl->egl_context.egl.dpy, config_attribs,
|
|
&wl->egl_context.egl.conf, 1, &n);
|
|
|
|
wl->egl_context.egl.ctx = eglCreateContext(wl->egl_context.egl.dpy,
|
|
wl->egl_context.egl.conf,
|
|
EGL_NO_CONTEXT,
|
|
context_attribs);
|
|
if (!wl->egl_context.egl.ctx) {
|
|
/* fallback to any GL version */
|
|
MP_WARN(wl, "can't create context for requested OpenGL version: "
|
|
"fall back to any version available");
|
|
context_attribs[0] = EGL_NONE;
|
|
wl->egl_context.egl.ctx = eglCreateContext(wl->egl_context.egl.dpy,
|
|
wl->egl_context.egl.conf,
|
|
EGL_NO_CONTEXT,
|
|
context_attribs);
|
|
|
|
if (!wl->egl_context.egl.ctx)
|
|
return false;
|
|
}
|
|
|
|
eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, wl->egl_context.egl.ctx);
|
|
|
|
eglstr = eglQueryString(wl->egl_context.egl.dpy, EGL_EXTENSIONS);
|
|
|
|
mpgl_load_functions(gl, (void*(*)(const GLubyte*))eglGetProcAddress, eglstr,
|
|
wl->log);
|
|
if (!gl->BindProgram)
|
|
mpgl_load_functions(gl, NULL, eglstr, wl->log);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void egl_create_window(struct vo_wayland_state *wl,
|
|
uint32_t width,
|
|
uint32_t height)
|
|
{
|
|
wl->egl_context.egl_window = wl_egl_window_create(wl->window.surface,
|
|
wl->window.width,
|
|
wl->window.height);
|
|
|
|
wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
|
|
wl->egl_context.egl.conf,
|
|
wl->egl_context.egl_window,
|
|
NULL);
|
|
|
|
eglMakeCurrent(wl->egl_context.egl.dpy,
|
|
wl->egl_context.egl_surface,
|
|
wl->egl_context.egl_surface,
|
|
wl->egl_context.egl.ctx);
|
|
|
|
wl_display_dispatch_pending(wl->display.display);
|
|
}
|
|
|
|
static bool config_window_wayland(struct MPGLContext *ctx,
|
|
uint32_t d_width,
|
|
uint32_t d_height,
|
|
uint32_t flags)
|
|
{
|
|
struct vo_wayland_state * wl = ctx->vo->wayland;
|
|
bool enable_alpha = !!(flags & VOFLAG_ALPHA);
|
|
bool ret = false;
|
|
|
|
if (!vo_wayland_config(ctx->vo, d_width, d_height, flags))
|
|
return false;
|
|
|
|
if (!wl->egl_context.egl.ctx) {
|
|
/* Create OpenGL context */
|
|
ret = egl_create_context(wl, ctx, enable_alpha);
|
|
|
|
/* If successfully created the context and we don't want to hide the
|
|
* window than also create the window immediately */
|
|
if (ret && !(VOFLAG_HIDDEN & flags))
|
|
egl_create_window(wl, d_width, d_height);
|
|
|
|
return ret;
|
|
}
|
|
else {
|
|
if (!wl->egl_context.egl_window) {
|
|
/* If the context exists and the hidden flag is unset then
|
|
* create the window */
|
|
if (!(VOFLAG_HIDDEN & flags))
|
|
egl_create_window(wl, d_width, d_height);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static void releaseGlContext_wayland(MPGLContext *ctx)
|
|
{
|
|
GL *gl = ctx->gl;
|
|
struct vo_wayland_state *wl = ctx->vo->wayland;
|
|
|
|
gl->Finish();
|
|
eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, EGL_NO_CONTEXT);
|
|
eglDestroyContext(wl->egl_context.egl.dpy, wl->egl_context.egl.ctx);
|
|
eglTerminate(wl->egl_context.egl.dpy);
|
|
eglReleaseThread();
|
|
wl_egl_window_destroy(wl->egl_context.egl_window);
|
|
wl->egl_context.egl.ctx = NULL;
|
|
}
|
|
|
|
static const struct wl_callback_listener frame_listener;
|
|
|
|
static void frame_handle_redraw(void *data,
|
|
struct wl_callback *callback,
|
|
uint32_t time)
|
|
|
|
{
|
|
MPGLContext *ctx = data;
|
|
struct vo_wayland_state *wl = ctx->vo->wayland;
|
|
|
|
if (callback)
|
|
wl_callback_destroy(callback);
|
|
|
|
//struct wl_callback *tmp = wl_surface_frame(wl->window.surface);
|
|
//wl_callback_add_listener(tmp, &frame_listener, ctx);
|
|
wl->egl_context.redraw_callback = wl_surface_frame(wl->window.surface);
|
|
wl_callback_add_listener(wl->egl_context.redraw_callback, &frame_listener, ctx);
|
|
|
|
eglSwapBuffers(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
|
|
}
|
|
|
|
static const struct wl_callback_listener frame_listener = {
|
|
frame_handle_redraw
|
|
};
|
|
|
|
static void swapGlBuffers_wayland(MPGLContext *ctx)
|
|
{
|
|
struct vo_wayland_state *wl = ctx->vo->wayland;
|
|
// eglSwapBuffers(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
|
|
|
|
if (!wl->egl_context.redraw_callback)
|
|
frame_handle_redraw(ctx, NULL, 0);
|
|
}
|
|
|
|
static int control(struct vo *vo, int *events, int request, void *data)
|
|
{
|
|
struct vo_wayland_state *wl = vo->wayland;
|
|
int r = vo_wayland_control(vo, events, request, data);
|
|
|
|
// NOTE: VO_EVENT_EXPOSE is never returned by the wayland backend
|
|
if (*events & VO_EVENT_RESIZE)
|
|
egl_resize(wl);
|
|
|
|
return r;
|
|
}
|
|
|
|
void mpgl_set_backend_wayland(MPGLContext *ctx)
|
|
{
|
|
ctx->config_window = config_window_wayland;
|
|
ctx->releaseGlContext = releaseGlContext_wayland;
|
|
ctx->swapGlBuffers = swapGlBuffers_wayland;
|
|
ctx->vo_control = control;
|
|
ctx->vo_init = vo_wayland_init;
|
|
ctx->vo_uninit = vo_wayland_uninit;
|
|
}
|