From 08501362d16e12242b9457422146152fca06e8cc Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Sat, 7 Nov 2026 14:31:48 +0530 Subject: [PATCH] macOS: Fix a few issues with the new render logic 1. Stuck display link when screen is off 2. Blank frames during live resize --- glfw/cocoa_displaylink.m | 14 ++++++++++++-- kitty/child-monitor.c | 36 +++++++++++++++++++++++++++--------- kitty/glfw.c | 11 ++++++++--- kitty/state.h | 2 +- 4 files changed, 48 insertions(+), 15 deletions(-) diff --git a/glfw/cocoa_displaylink.m b/glfw/cocoa_displaylink.m index 1b15af695..e9ccb16f4 100644 --- a/glfw/cocoa_displaylink.m +++ b/glfw/cocoa_displaylink.m @@ -19,6 +19,8 @@ typedef struct _GLFWDisplayLinkNS { CADisplayLink *displayLink; CGDirectDisplayID displayID; monotonic_t lastRenderFrameRequestedAt, first_unserviced_render_frame_request_at; + // Whether the link being stuck has been reported since it last delivered a frame + bool stuck_reported; } _GLFWDisplayLinkNS; static struct { @@ -185,7 +187,12 @@ _glfwRequestRenderFrame(_GLFWwindow *w) { destroy_display_link(dl); create_display_link(dl); if (dl->displayLink) link_start(dl->displayLink); - _glfwInputError(GLFW_PLATFORM_ERROR, "Display link stuck possibly because of sleep/screensaver + Apple's incompetence, recreating."); + // The link is recreated every second while stuck, which can be for long + // periods, for example, while the display is asleep, so report it only once + if (!dl->stuck_reported) { + dl->stuck_reported = true; + _glfwInputError(GLFW_PLATFORM_ERROR, "Display link stuck possibly because of sleep/screensaver + Apple's incompetence, recreating."); + } } } } else if (dl->displayLink && dl->lastRenderFrameRequestedAt && now - dl->lastRenderFrameRequestedAt >= DISPLAY_LINK_SHUTDOWN_CHECK_INTERVAL) { @@ -218,7 +225,10 @@ _glfwDispatchRenderFrame(CGDirectDisplayID displayID) { // Reset before calling the callbacks so that any render frame requests // they make are tracked as unserviced. for (size_t i = 0; i < displayLinks.count; i++) { - if (displayLinks.entries[i].displayID == displayID) displayLinks.entries[i].first_unserviced_render_frame_request_at = 0; + if (displayLinks.entries[i].displayID == displayID) { + displayLinks.entries[i].first_unserviced_render_frame_request_at = 0; + displayLinks.entries[i].stuck_reported = false; + } } for (_GLFWwindow *w = _glfw.windowListHead; w; w = w->next) { if (w->ns.renderFrameRequested && displayID == displayIDForWindow(w)) { diff --git a/kitty/child-monitor.c b/kitty/child-monitor.c index 777d20eb3..c6d266b3b 100644 --- a/kitty/child-monitor.c +++ b/kitty/child-monitor.c @@ -133,6 +133,9 @@ set_maximum_wait(monotonic_t val) { // The minimum interval between renders of an OS Window that are not paced by // render frames, as happens soon after a resize on Wayland (120 FPS) #define POST_RESIZE_MIN_RENDER_INTERVAL (MONOTONIC_T_1e9 / 120) +// The minimum interval between renders of an OS Window on macOS when the +// display link has stopped delivering render frames (60 FPS) +#define STALLED_RENDER_FRAMES_MIN_RENDER_INTERVAL (MONOTONIC_T_1e9 / 60) // How often to retry rendering an OS Window whose buffers could not be swapped #define SWAP_RETRY_INTERVAL (10 * MONOTONIC_T_1e6) // The minimum interval between redraws used when syncing to the monitor @@ -198,7 +201,7 @@ no_render_frame_received_recently(OSWindow *w, monotonic_t now, monotonic_t max_ if (global_state.is_wayland) { log_error("No render frame received in %.2f seconds", monotonic_t_to_s_double(max_wait)); } else { - log_error("No render frame received in %.2f seconds, re-requesting", monotonic_t_to_s_double(max_wait)); + log_error("No render frame received in %.2f seconds, rendering without them", monotonic_t_to_s_double(max_wait)); } } return ans; @@ -244,12 +247,27 @@ is_render_deferred_by_frame_pacing(OSWindow *w, monotonic_t now) { // for hidden windows, see https://github.com/kovidgoyal/kitty/issues/10597 if (w->render_state == RENDER_FRAME_NOT_REQUESTED) request_frame_render(w); else (void)no_render_frame_received_recently(w, now, RENDER_FRAME_STALL_TIMEOUT); + } else if (w->render_state == RENDER_FRAME_NOT_REQUESTED) { + request_frame_render(w); } else { - if (w->render_state == RENDER_FRAME_NOT_REQUESTED || - (now - w->render_frame_requested_at > RENDER_FRAME_STALL_TIMEOUT && no_render_frame_received_recently(w, now, RENDER_FRAME_STALL_TIMEOUT))) - request_frame_render(w); - // Ensure the main loop wakes up to re-request the frame if it is lost - set_maximum_wait(RENDER_FRAME_STALL_TIMEOUT); + // Only reached on macOS, as frames are requested lazily on X11. Here + // render_frame_requested_at is the time of the oldest unanswered request, + // see request_frame_render() + const monotonic_t stalled_at = w->render_frame_requested_at + RENDER_FRAME_STALL_TIMEOUT; + if (now >= stalled_at) { + // The display link has stopped delivering frames, for example, while the display + // is asleep. Render without waiting for them, at a limited rate. Frames are + // re-requested after every render, which lets glfw recreate a stuck display link. + // No wakeup is scheduled here, so an idle window does not cause periodic wakeups. + (void)no_render_frame_received_recently(w, now, RENDER_FRAME_STALL_TIMEOUT); + if (is_thumbnail) return false; + const monotonic_t since_last_render = now - w->last_rendered_at; + if (since_last_render >= STALLED_RENDER_FRAMES_MIN_RENDER_INTERVAL) return false; + set_maximum_wait(STALLED_RENDER_FRAMES_MIN_RENDER_INTERVAL - since_last_render); + return true; + } + // Ensure the main loop wakes up to render if the frame never arrives + set_maximum_wait(stalled_at - now); } if (is_thumbnail) return false; // dont respect render frames soon after a resize on Wayland as they cause flicker because @@ -1311,14 +1329,14 @@ render_prepared_os_window( } bool -render_os_window(OSWindow *w, monotonic_t now, bool scan_for_animated_images) { +render_os_window(OSWindow *w, monotonic_t now, bool scan_for_animated_images, bool ignore_frame_pacing) { if (!w->num_tabs) return false; if (!should_os_window_be_rendered(w) && global_state.thumbnail_callback.os_window != w->id) { update_os_window_title(w); if (w->is_focused) change_menubar_title(w->window_title); return false; } - if (is_render_deferred_by_frame_pacing(w, now)) return false; + if (!ignore_frame_pacing && is_render_deferred_by_frame_pacing(w, now)) return false; w->render_calls++; make_os_window_context_current(w); bool needs_render = w->redraw_count > 0 || w->live_resize.in_progress || global_state.thumbnail_callback.os_window == w->id; @@ -1372,7 +1390,7 @@ render(monotonic_t now) { // rendering is done in cocoa_os_window_resized() if (w->live_resize.in_progress) continue; #endif - if (!render_os_window(w, now, scan_for_animated_images)) { + if (!render_os_window(w, now, scan_for_animated_images, false)) { // since we didn't scan the window for animations, force a rescan on next wakeup/render frame if (scan_for_animated_images) global_state.check_for_active_animated_images = true; } diff --git a/kitty/glfw.c b/kitty/glfw.c index 018eeab62..9a2c6f3e6 100644 --- a/kitty/glfw.c +++ b/kitty/glfw.c @@ -430,8 +430,10 @@ cocoa_out_of_sequence_render(OSWindow *window) { bool rendered = false; if (window->fonts_data->sprite_map) { window->needs_render = true; - window->render_state = RENDER_FRAME_READY; - rendered = render_os_window(window, monotonic(), true); + // The window must be drawn now, as the OS expects its contents to be + // updated synchronously, for example, during a live resize, otherwise + // it is blanked below. Ignore both render frames and render_interval. + rendered = render_os_window(window, monotonic(), true, true); } if (!rendered) { debug_rendering("Cocoa out of sequence render did not happen\n"); @@ -3801,8 +3803,11 @@ cocoa_frame_request_callback(GLFWwindow *window) { void request_frame_render(OSWindow *w) { glfwCocoaRequestRenderFrame(w->handle, cocoa_frame_request_callback); + // Track the oldest unanswered request, so that a display link that has + // stopped delivering frames is detected even though frames are + // re-requested after every render, see is_render_deferred_by_frame_pacing() + if (w->render_state != RENDER_FRAME_REQUESTED) w->render_frame_requested_at = monotonic(); w->render_state = RENDER_FRAME_REQUESTED; - w->render_frame_requested_at = monotonic(); } static PyObject * diff --git a/kitty/state.h b/kitty/state.h index dc271c6e4..00470310b 100644 --- a/kitty/state.h +++ b/kitty/state.h @@ -901,7 +901,7 @@ bool set_wheel_mappings(PyObject *py_opts, Options *opts); bool set_url_mappings(PyObject *py_opts, Options *opts); void update_menu_bar_title(PyObject *title UNUSED); void change_live_resize_state(OSWindow *, bool); -bool render_os_window(OSWindow *w, monotonic_t now, bool scan_for_animated_images); +bool render_os_window(OSWindow *w, monotonic_t now, bool scan_for_animated_images, bool ignore_frame_pacing); void update_mouse_pointer_shape(void); void update_pointer_shape_for_kitty_window(id_type kitty_window_id); bool update_link_hover_for_modifiers(int old_mods, int new_mods);