vanfanel
commented
2 years ago This piece of code DOES wait for actual buffer swap event:
struct wl_callback *callback;
int frame_done;
frame_done = 0;
callback = wl_surface_frame(wl->surface);
if (callback == NULL)
return;
// Issue buffer swap.
egl_swap_buffers(&wl->egl);
// The callback will set frame_done to true when receiving event.
wl_callback_add_listener(callback, &frame_listener, &frame_done);
// Stay in loop until the issued buffer swap is actually done.
while (!frame_done && wl_display_dispatch(wl->input.dpy) == 0) {}...and this is the callback function implementation, which should go before trying to pass it to wl_callback_add_listener(), obviously.
static void
frame_callback(void *data, struct wl_callback *callback, uint32_t serial)
{
int *done = data;
*done = 1;
wl_callback_destroy(callback);
}
static const struct wl_callback_listener frame_listener = {
frame_callback
};Whether improves input latency on Wayland + OpenGL is something I cannot be totally sure about.
It should work with VSYNC=OFF since this needs non-blocking eglSwapBuffers(). because we are explicitly waiting for the buffer swapping completion event.
nfp0
gouchi
Description
Currently, RetroArch will show noticeable input lag when using the OpenGL backend on the Wayland context (the max_swapchain setting is not available on Wayland + OpenGL).
Buffer swapping is done here for Wayland: https://github.com/libretro/RetroArch/blob/911308327dc1f06531575f9f606b21a0a25ac38a/gfx/drivers_context/wayland_ctx.c#L518 ...but it lacks a mean to block until
eglSwapBuffers()completes.eglSwapBuffers()is by default a synchronous/blocking function: in theory it doesn't return until the requested buffer swap is done. This behavior can be changed witheglSwapInterval(1), which make subsequenteglSwapBuffers()calls return immediately.However, blocking eglSwapBuffers() as things go internally on Wayland means "you can send a new frame", not "the issued buffer swap is complete and the new contents are on screen". That's why waiting for the buffer swap event "manually" after eglSwapBuffers() can be a good idea.
In the KMS/DRM backend of SDL2, I use events to be notified on the buffer swap completion: https://github.com/libsdl-org/SDL/blob/5b2884cb0203cc63bf9753f8b55ea4c6c6f19cfb/src/video/kmsdrm/SDL_kmsdrmvideo.c#L391
So, any idea on what would be the equivalent in Wayland for explicitly blocking until the requested buffer swap is completed?
Expected behavior
RetroArch on Wayland using OpenGL should have less input lag.
Actual behavior
RetroArch on Wayland using OpenGL has noticeable input lag.
Steps to reproduce the bug
Bisect Results
Has always happened.
Version/Commit
Every version or RetroArch has this problem: as of today, there's no mechanism implemented to explicitly wait for vsync after the egl_swap_buffers() call here: https://github.com/libretro/RetroArch/blob/911308327dc1f06531575f9f606b21a0a25ac38a/gfx/drivers_context/wayland_ctx.c#L514
Environment information
@Themaister Can you please give me some input here? Are there Wayland-specific mechanisms to force wait for completion after an
eglSwapBuffers()call?