mirror of
https://codeberg.org/dnkl/foot.git
synced 2026-02-05 04:06:08 -05:00
299186a654
Foot likes it when compositor releases buffer immediately, as that means we only have to re-render the cells that have changed since the last frame. For various reasons, not all compositors do this. In this case, foot is typically forced to switch between two buffers, i.e. double-buffer. In this case, each frame starts with copying over the damage from the previous frame, to the new frame. Then we start rendering the updated cells. Bringing over the previous frame's damage can be slow, if the changed area was large (e.g. when scrolling one or a few lines, or on full screen updates). It's also done single-threaded. Thus it not only slows down frame rendering, but pauses everything else (i.e. input processing). All in all, it reduces performance and increases input latency. But we don't have to wait until it's time to render a frame to copy over the previous frame's damage. We can do that as soon as the compositor has released the buffer (for the frame _before_ the previous frame). And we can do this in a thread. This frees up foot to continue processing input, and reduces frame rendering time since we can now start rendering the modified cells immediately, without first doing a large memcpy(3). In worst case scenarios (or perhaps we should consider them best case scenarios...), I've seen up to a 10x performance increase in frame rendering times (this obviously does *not* include the time it takes to copy over the previous frame's damage, since that doesn't affect neither input processing nor frame rendering). Implemented by adding a callback mechanism to the shm abstraction layer. Use it for the grid buffers, and kick off a thread that copies the previous frame's damage, and resets the buffers age to 0 (so that foot understands it can start render to it immediately when it later needs to render a frame). Since we have certain way of knowing if a compositor releases buffers immediately or not, use a bit of heuristics; if we see 10 consecutive non-immediate releases (that is, we reset the counter as soon as we do see an immediate release), this new "pre-apply damage" logic is enabled. It can be force-disabled with tweak.pre-apply-damage=no. We also need to take care to wait for the thread before resetting the render's "last_buf" pointer (or we'll SEGFAULT in the thread...). We must also ensure we wait for the thread to finish before we start rendering a new frame. Under normal circumstances, the wait time is always 0, the thread has almost always finished long before we need to render the next frame. But it _can_ happen. Closes #2188
51 lines
1.4 KiB
C
51 lines
1.4 KiB
C
#pragma once
|
|
#include <stdbool.h>
|
|
|
|
#include "terminal.h"
|
|
#include "fdm.h"
|
|
#include "wayland.h"
|
|
#include "misc.h"
|
|
|
|
struct renderer;
|
|
struct renderer *render_init(struct fdm *fdm, struct wayland *wayl);
|
|
void render_destroy(struct renderer *renderer);
|
|
|
|
enum resize_options {
|
|
RESIZE_NORMAL = 0,
|
|
RESIZE_FORCE = 1 << 0,
|
|
RESIZE_BY_CELLS = 1 << 1,
|
|
RESIZE_KEEP_GRID = 1 << 2,
|
|
};
|
|
|
|
bool render_resize(
|
|
struct terminal *term, int width, int height, uint8_t resize_options);
|
|
|
|
void render_refresh(struct terminal *term);
|
|
void render_refresh_app_id(struct terminal *term);
|
|
void render_refresh_icon(struct terminal *term);
|
|
void render_refresh_csd(struct terminal *term);
|
|
void render_refresh_search(struct terminal *term);
|
|
void render_refresh_title(struct terminal *term);
|
|
void render_refresh_urls(struct terminal *term);
|
|
bool render_xcursor_set(
|
|
struct seat *seat, struct terminal *term, enum cursor_shape shape);
|
|
bool render_xcursor_is_valid(const struct seat *seat, const char *cursor);
|
|
|
|
void render_overlay(struct terminal *term);
|
|
|
|
struct render_worker_context {
|
|
int my_id;
|
|
struct terminal *term;
|
|
};
|
|
int render_worker_thread(void *_ctx);
|
|
|
|
struct csd_data {
|
|
int x;
|
|
int y;
|
|
int width;
|
|
int height;
|
|
};
|
|
|
|
struct csd_data get_csd_data(const struct terminal *term, enum csd_surface surf_idx);
|
|
|
|
void render_buffer_release_callback(struct buffer *buf, void *data);
|