b60b57c407
This commit defines a new discard_constraints request. This request is
intended to be used by clients that use the wp-fifo and wp-commit-timing
protocols for frame pacing but want to be able to respond immediately to
resize requests.
Consider a client using wp-fifo presenting to a display with refresh
rate 1 (unitless). The client has allocated 3 buffers O1, O2, and O3.
The client receives a resize request at time T+2. The client allocates
new buffers N1, N2, and N3 with the new size.
The following sequence of requests and events can be observed in
WAYLAND_DEBUG output:
T+0: release(O1)
T+0: -> attach(O1)
T+1: release(O2)
T+1: -> attach(O2)
T+2: release(O3)
T+2: -> attach(O3)
T+2: resize request
T+2: -> attach(N1)
T+2: -> attach(N2)
T+2: -> attach(N3)
T+3: release(O1)
T+4: release(O2)
T+5: release(O3)
T+6: release(N1)
T+6: -> attach(N1)
Due to the lack of backpressure, all newly created buffers are attached
immediately at T+2. Since O1, O2, and O3 are still equeued, the content
update containing N1 will only be applied at T+5 and therefore cannot be
released any earlier than T+6, creating a presentation bubble between
T+3 and T+6.
Furthermore, even if the client did not attach N2 immediately at T+2, N1
would not become visible until T+5, which means that the client
effectively does not respond to the resize request until T+5.
This effect can be observed with the following command:
vkcube --present_mode 2
Resizing the application window causes easily visible stutters on
displays with low refresh rates.
Note that the queue can grow unbounded if the client receives an
unbounded number of resize requests between refresh cycles.
To remedy this, this commit allows the client to hint to the compositor
that it should discard all existing constraints, if able. Since
compositor architectures might impose limitations on which constraints
the compositor is able to discard, this is left to compositor policy. It
is expected that most compositors should be able to discard wp-fifo and
wp-commit-timing constraints. Some compositors might be able to discard
buffer constraints if the buffer in question is superseded by another
buffer in a later content update.
I had considered creating per-interface requests, such as
wp_fifo_v1.discard_constraints, however, such constraints are often
created by WSI layers and an update of the WSI layer could introduce new
constraints that the client would not be aware of. To discard all
constraints, the WSI layer would have to invoke these requests and there
are no APIs for the client to communicate to the WSI layer which
behavior is desired.
Signed-off-by: Julian Orth <ju.orth@gmail.com>
|
||
|---|---|---|
| .gitlab/issue_templates | ||
| cursor | ||
| doc | ||
| egl | ||
| protocol | ||
| src | ||
| tests | ||
| .editorconfig | ||
| .gitignore | ||
| .gitlab-ci.yml | ||
| .mailmap | ||
| .triage-policies.yml | ||
| CONTRIBUTING.md | ||
| COPYING | ||
| meson.build | ||
| meson_options.txt | ||
| README.md | ||
| release.sh | ||
| releasing.txt | ||
| wayland-scanner.m4 | ||
| wayland-scanner.mk | ||
Wayland
Wayland is a project to define a protocol for a compositor to talk to its clients as well as a library implementation of the protocol. The compositor can be a standalone display server running on Linux kernel modesetting and evdev input devices, an X application, or a wayland client itself. The clients can be traditional applications, X servers (rootless or fullscreen) or other display servers.
The wayland protocol is essentially only about input handling and buffer management. The compositor receives input events and forwards them to the relevant client. The clients creates buffers and renders into them and notifies the compositor when it needs to redraw. The protocol also handles drag and drop, selections, window management and other interactions that must go through the compositor. However, the protocol does not handle rendering, which is one of the features that makes wayland so simple. All clients are expected to handle rendering themselves, typically through cairo or OpenGL.
Building the wayland libraries is fairly simple, aside from libffi, they don't have many dependencies:
$ git clone https://gitlab.freedesktop.org/wayland/wayland
$ cd wayland
$ meson build/ --prefix=PREFIX
$ ninja -C build/ install
where PREFIX is where you want to install the libraries.
See https://wayland.freedesktop.org for documentation.