|
|
|
/*
|
|
|
|
* Copyright © 2018 Collabora, Ltd.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
|
|
* a copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial
|
|
|
|
* portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
libweston: Support zwp_surface_synchronization_v1.set_acquire_fence
Implement the set_acquire_fence request of the
zwp_surface_synchronization_v1 interface.
The implementation uses the acquire fence in two ways:
1. If the associated buffer is used as GL render source, an
EGLSyncKHR is created from the fence and used to synchronize
access.
2. If the associated buffer is used as a plane framebuffer,
the acquire fence is treated as an in-fence for the atomic
commit operation. If in-fences are not supported and the buffer
has an acquire fence, we don't consider it for plane placement.
If the used compositor/renderer doesn't support explicit
synchronization, we don't advertise the protocol at all. Currently only
the DRM and X11 backends when using the GL renderer advertise the
protocol for production use.
Issues for discussion
---------------------
a. Currently, a server-side wait of EGLSyncKHR is performed before
using the EGLImage/texture during rendering. Unfortunately, it's not clear
from the specs whether this is generally safe to do, or we need to
sync before glEGLImageTargetTexture2DOES. The exception is
TEXTURE_EXTERNAL_OES where the spec mentions it's enough to sync
and then glBindTexture for any changes to take effect.
Changes in v5:
- Meson support.
- Make explicit sync server error reporting more generic, supporting
all explicit sync related interfaces not just
wp_linux_surface_synchronization.
- Fix typo in warning for missing EGL_KHR_wait_sync extension.
- Support minor version 2 of the explicit sync protocol (i.e., support
fences for opaque EGL buffers).
Changes in v4:
- Introduce and use fd_clear and and fd_move helpers.
- Don't check for a valid buffer when updating surface acquire fence fd
from state.
- Assert that pending state acquire fence fd is always clear
after a commit.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to just the
renderer.
- Check for EGL_KHR_wait_sync before using eglWaitSyncKHR.
- Dup the acquire fence before passing to EGL.
Changes in v3:
- Keep acquire_fence_fd in surface instead of buffer.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to both backend and
renderer.
- Move comment about non-ownership of in_fence_fd to struct
drm_plane_state definition.
- Assert that we don't try to use planes with in-fences when using the
legacy KMS API.
- Remove unnecessary info from wayland error messages.
- Handle acquire fence for subsurface commits.
- Guard against self-update in fd_update.
- Disconnect the client if acquire fence EGLSyncKHR creation or wait
fails.
- Use updated protocol interface names.
- User correct format specifier for resource ids.
- Advertise protocol for X11 backend with GL renderer.
Changes in v2:
- Remove sync file wait fallbacks.
- Raise UNSUPPORTED_BUFFER error at commit if we have an acquire
fence, but the committed buffer is not a valid linux_dmabuf.
- Don't put buffers with in-fences on planes that don't support
in-fences.
- Don't advertise explicit sync protocol if backend does not
support explicit sync.
Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
6 years ago
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "linux-explicit-synchronization-unstable-v1-client-protocol.h"
|
|
|
|
#include "weston-test-client-helper.h"
|
|
|
|
#include "wayland-server-protocol.h"
|
|
|
|
#include "weston-test-fixture-compositor.h"
|
|
|
|
|
|
|
|
static enum test_result_code
|
|
|
|
fixture_setup(struct weston_test_harness *harness)
|
|
|
|
{
|
|
|
|
struct compositor_setup setup;
|
|
|
|
|
|
|
|
compositor_setup_defaults(&setup);
|
|
|
|
|
|
|
|
/* We need to use the pixman renderer, since a few of the tests depend
|
|
|
|
* on the renderer holding onto a surface buffer until the next one
|
|
|
|
* is committed, which the noop renderer doesn't do. */
|
|
|
|
setup.renderer = RENDERER_PIXMAN;
|
|
|
|
|
|
|
|
return weston_test_harness_execute_as_client(harness, &setup);
|
|
|
|
}
|
|
|
|
DECLARE_FIXTURE_SETUP(fixture_setup);
|
|
|
|
|
|
|
|
static struct zwp_linux_explicit_synchronization_v1 *
|
|
|
|
get_linux_explicit_synchronization(struct client *client)
|
|
|
|
{
|
|
|
|
struct global *g;
|
|
|
|
struct global *global_sync = NULL;
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync = NULL;
|
|
|
|
|
|
|
|
wl_list_for_each(g, &client->global_list, link) {
|
|
|
|
if (strcmp(g->interface,
|
|
|
|
zwp_linux_explicit_synchronization_v1_interface.name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (global_sync)
|
|
|
|
assert(!"Multiple linux explicit sync objects");
|
|
|
|
|
|
|
|
global_sync = g;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(global_sync);
|
|
|
|
assert(global_sync->version == 2);
|
|
|
|
|
|
|
|
sync = wl_registry_bind(
|
|
|
|
client->wl_registry, global_sync->name,
|
|
|
|
&zwp_linux_explicit_synchronization_v1_interface, 2);
|
|
|
|
assert(sync);
|
|
|
|
|
|
|
|
return sync;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct client *
|
|
|
|
create_test_client(void)
|
|
|
|
{
|
|
|
|
struct client *cl = create_client_and_test_surface(0, 0, 100, 100);
|
|
|
|
assert(cl);
|
|
|
|
return cl;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(second_surface_synchronization_on_surface_raises_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync1;
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync2;
|
|
|
|
|
|
|
|
surface_sync1 =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
client_roundtrip(client);
|
|
|
|
|
|
|
|
/* Second surface_synchronization creation should fail */
|
|
|
|
surface_sync2 =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_explicit_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_EXPLICIT_SYNCHRONIZATION_V1_ERROR_SYNCHRONIZATION_EXISTS);
|
|
|
|
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync2);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync1);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
libweston: Support zwp_surface_synchronization_v1.set_acquire_fence
Implement the set_acquire_fence request of the
zwp_surface_synchronization_v1 interface.
The implementation uses the acquire fence in two ways:
1. If the associated buffer is used as GL render source, an
EGLSyncKHR is created from the fence and used to synchronize
access.
2. If the associated buffer is used as a plane framebuffer,
the acquire fence is treated as an in-fence for the atomic
commit operation. If in-fences are not supported and the buffer
has an acquire fence, we don't consider it for plane placement.
If the used compositor/renderer doesn't support explicit
synchronization, we don't advertise the protocol at all. Currently only
the DRM and X11 backends when using the GL renderer advertise the
protocol for production use.
Issues for discussion
---------------------
a. Currently, a server-side wait of EGLSyncKHR is performed before
using the EGLImage/texture during rendering. Unfortunately, it's not clear
from the specs whether this is generally safe to do, or we need to
sync before glEGLImageTargetTexture2DOES. The exception is
TEXTURE_EXTERNAL_OES where the spec mentions it's enough to sync
and then glBindTexture for any changes to take effect.
Changes in v5:
- Meson support.
- Make explicit sync server error reporting more generic, supporting
all explicit sync related interfaces not just
wp_linux_surface_synchronization.
- Fix typo in warning for missing EGL_KHR_wait_sync extension.
- Support minor version 2 of the explicit sync protocol (i.e., support
fences for opaque EGL buffers).
Changes in v4:
- Introduce and use fd_clear and and fd_move helpers.
- Don't check for a valid buffer when updating surface acquire fence fd
from state.
- Assert that pending state acquire fence fd is always clear
after a commit.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to just the
renderer.
- Check for EGL_KHR_wait_sync before using eglWaitSyncKHR.
- Dup the acquire fence before passing to EGL.
Changes in v3:
- Keep acquire_fence_fd in surface instead of buffer.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to both backend and
renderer.
- Move comment about non-ownership of in_fence_fd to struct
drm_plane_state definition.
- Assert that we don't try to use planes with in-fences when using the
legacy KMS API.
- Remove unnecessary info from wayland error messages.
- Handle acquire fence for subsurface commits.
- Guard against self-update in fd_update.
- Disconnect the client if acquire fence EGLSyncKHR creation or wait
fails.
- Use updated protocol interface names.
- User correct format specifier for resource ids.
- Advertise protocol for X11 backend with GL renderer.
Changes in v2:
- Remove sync file wait fallbacks.
- Raise UNSUPPORTED_BUFFER error at commit if we have an acquire
fence, but the committed buffer is not a valid linux_dmabuf.
- Don't put buffers with in-fences on planes that don't support
in-fences.
- Don't advertise explicit sync protocol if backend does not
support explicit sync.
Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
6 years ago
|
|
|
|
|
|
|
TEST(set_acquire_fence_with_invalid_fence_raises_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
int pipefd[2] = { -1, -1 };
|
|
|
|
|
|
|
|
assert(pipe(pipefd) == 0);
|
|
|
|
|
|
|
|
zwp_linux_surface_synchronization_v1_set_acquire_fence(surface_sync,
|
|
|
|
pipefd[0]);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_surface_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_ERROR_INVALID_FENCE);
|
|
|
|
|
|
|
|
close(pipefd[0]);
|
|
|
|
close(pipefd[1]);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
libweston: Support zwp_surface_synchronization_v1.set_acquire_fence
Implement the set_acquire_fence request of the
zwp_surface_synchronization_v1 interface.
The implementation uses the acquire fence in two ways:
1. If the associated buffer is used as GL render source, an
EGLSyncKHR is created from the fence and used to synchronize
access.
2. If the associated buffer is used as a plane framebuffer,
the acquire fence is treated as an in-fence for the atomic
commit operation. If in-fences are not supported and the buffer
has an acquire fence, we don't consider it for plane placement.
If the used compositor/renderer doesn't support explicit
synchronization, we don't advertise the protocol at all. Currently only
the DRM and X11 backends when using the GL renderer advertise the
protocol for production use.
Issues for discussion
---------------------
a. Currently, a server-side wait of EGLSyncKHR is performed before
using the EGLImage/texture during rendering. Unfortunately, it's not clear
from the specs whether this is generally safe to do, or we need to
sync before glEGLImageTargetTexture2DOES. The exception is
TEXTURE_EXTERNAL_OES where the spec mentions it's enough to sync
and then glBindTexture for any changes to take effect.
Changes in v5:
- Meson support.
- Make explicit sync server error reporting more generic, supporting
all explicit sync related interfaces not just
wp_linux_surface_synchronization.
- Fix typo in warning for missing EGL_KHR_wait_sync extension.
- Support minor version 2 of the explicit sync protocol (i.e., support
fences for opaque EGL buffers).
Changes in v4:
- Introduce and use fd_clear and and fd_move helpers.
- Don't check for a valid buffer when updating surface acquire fence fd
from state.
- Assert that pending state acquire fence fd is always clear
after a commit.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to just the
renderer.
- Check for EGL_KHR_wait_sync before using eglWaitSyncKHR.
- Dup the acquire fence before passing to EGL.
Changes in v3:
- Keep acquire_fence_fd in surface instead of buffer.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to both backend and
renderer.
- Move comment about non-ownership of in_fence_fd to struct
drm_plane_state definition.
- Assert that we don't try to use planes with in-fences when using the
legacy KMS API.
- Remove unnecessary info from wayland error messages.
- Handle acquire fence for subsurface commits.
- Guard against self-update in fd_update.
- Disconnect the client if acquire fence EGLSyncKHR creation or wait
fails.
- Use updated protocol interface names.
- User correct format specifier for resource ids.
- Advertise protocol for X11 backend with GL renderer.
Changes in v2:
- Remove sync file wait fallbacks.
- Raise UNSUPPORTED_BUFFER error at commit if we have an acquire
fence, but the committed buffer is not a valid linux_dmabuf.
- Don't put buffers with in-fences on planes that don't support
in-fences.
- Don't advertise explicit sync protocol if backend does not
support explicit sync.
Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
6 years ago
|
|
|
}
|
|
|
|
|
|
|
|
TEST(set_acquire_fence_on_destroyed_surface_raises_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
int pipefd[2] = { -1, -1 };
|
|
|
|
|
|
|
|
assert(pipe(pipefd) == 0);
|
|
|
|
|
|
|
|
wl_surface_destroy(client->surface->wl_surface);
|
|
|
|
client->surface->wl_surface = NULL;
|
libweston: Support zwp_surface_synchronization_v1.set_acquire_fence
Implement the set_acquire_fence request of the
zwp_surface_synchronization_v1 interface.
The implementation uses the acquire fence in two ways:
1. If the associated buffer is used as GL render source, an
EGLSyncKHR is created from the fence and used to synchronize
access.
2. If the associated buffer is used as a plane framebuffer,
the acquire fence is treated as an in-fence for the atomic
commit operation. If in-fences are not supported and the buffer
has an acquire fence, we don't consider it for plane placement.
If the used compositor/renderer doesn't support explicit
synchronization, we don't advertise the protocol at all. Currently only
the DRM and X11 backends when using the GL renderer advertise the
protocol for production use.
Issues for discussion
---------------------
a. Currently, a server-side wait of EGLSyncKHR is performed before
using the EGLImage/texture during rendering. Unfortunately, it's not clear
from the specs whether this is generally safe to do, or we need to
sync before glEGLImageTargetTexture2DOES. The exception is
TEXTURE_EXTERNAL_OES where the spec mentions it's enough to sync
and then glBindTexture for any changes to take effect.
Changes in v5:
- Meson support.
- Make explicit sync server error reporting more generic, supporting
all explicit sync related interfaces not just
wp_linux_surface_synchronization.
- Fix typo in warning for missing EGL_KHR_wait_sync extension.
- Support minor version 2 of the explicit sync protocol (i.e., support
fences for opaque EGL buffers).
Changes in v4:
- Introduce and use fd_clear and and fd_move helpers.
- Don't check for a valid buffer when updating surface acquire fence fd
from state.
- Assert that pending state acquire fence fd is always clear
after a commit.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to just the
renderer.
- Check for EGL_KHR_wait_sync before using eglWaitSyncKHR.
- Dup the acquire fence before passing to EGL.
Changes in v3:
- Keep acquire_fence_fd in surface instead of buffer.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to both backend and
renderer.
- Move comment about non-ownership of in_fence_fd to struct
drm_plane_state definition.
- Assert that we don't try to use planes with in-fences when using the
legacy KMS API.
- Remove unnecessary info from wayland error messages.
- Handle acquire fence for subsurface commits.
- Guard against self-update in fd_update.
- Disconnect the client if acquire fence EGLSyncKHR creation or wait
fails.
- Use updated protocol interface names.
- User correct format specifier for resource ids.
- Advertise protocol for X11 backend with GL renderer.
Changes in v2:
- Remove sync file wait fallbacks.
- Raise UNSUPPORTED_BUFFER error at commit if we have an acquire
fence, but the committed buffer is not a valid linux_dmabuf.
- Don't put buffers with in-fences on planes that don't support
in-fences.
- Don't advertise explicit sync protocol if backend does not
support explicit sync.
Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
6 years ago
|
|
|
zwp_linux_surface_synchronization_v1_set_acquire_fence(surface_sync,
|
|
|
|
pipefd[0]);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_surface_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_ERROR_NO_SURFACE);
|
|
|
|
|
|
|
|
close(pipefd[0]);
|
|
|
|
close(pipefd[1]);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
libweston: Support zwp_surface_synchronization_v1.set_acquire_fence
Implement the set_acquire_fence request of the
zwp_surface_synchronization_v1 interface.
The implementation uses the acquire fence in two ways:
1. If the associated buffer is used as GL render source, an
EGLSyncKHR is created from the fence and used to synchronize
access.
2. If the associated buffer is used as a plane framebuffer,
the acquire fence is treated as an in-fence for the atomic
commit operation. If in-fences are not supported and the buffer
has an acquire fence, we don't consider it for plane placement.
If the used compositor/renderer doesn't support explicit
synchronization, we don't advertise the protocol at all. Currently only
the DRM and X11 backends when using the GL renderer advertise the
protocol for production use.
Issues for discussion
---------------------
a. Currently, a server-side wait of EGLSyncKHR is performed before
using the EGLImage/texture during rendering. Unfortunately, it's not clear
from the specs whether this is generally safe to do, or we need to
sync before glEGLImageTargetTexture2DOES. The exception is
TEXTURE_EXTERNAL_OES where the spec mentions it's enough to sync
and then glBindTexture for any changes to take effect.
Changes in v5:
- Meson support.
- Make explicit sync server error reporting more generic, supporting
all explicit sync related interfaces not just
wp_linux_surface_synchronization.
- Fix typo in warning for missing EGL_KHR_wait_sync extension.
- Support minor version 2 of the explicit sync protocol (i.e., support
fences for opaque EGL buffers).
Changes in v4:
- Introduce and use fd_clear and and fd_move helpers.
- Don't check for a valid buffer when updating surface acquire fence fd
from state.
- Assert that pending state acquire fence fd is always clear
after a commit.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to just the
renderer.
- Check for EGL_KHR_wait_sync before using eglWaitSyncKHR.
- Dup the acquire fence before passing to EGL.
Changes in v3:
- Keep acquire_fence_fd in surface instead of buffer.
- Clarify that WESTON_CAP_EXPLICIT_SYNC applies to both backend and
renderer.
- Move comment about non-ownership of in_fence_fd to struct
drm_plane_state definition.
- Assert that we don't try to use planes with in-fences when using the
legacy KMS API.
- Remove unnecessary info from wayland error messages.
- Handle acquire fence for subsurface commits.
- Guard against self-update in fd_update.
- Disconnect the client if acquire fence EGLSyncKHR creation or wait
fails.
- Use updated protocol interface names.
- User correct format specifier for resource ids.
- Advertise protocol for X11 backend with GL renderer.
Changes in v2:
- Remove sync file wait fallbacks.
- Raise UNSUPPORTED_BUFFER error at commit if we have an acquire
fence, but the committed buffer is not a valid linux_dmabuf.
- Don't put buffers with in-fences on planes that don't support
in-fences.
- Don't advertise explicit sync protocol if backend does not
support explicit sync.
Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
6 years ago
|
|
|
}
|
|
|
|
|
|
|
|
TEST(second_buffer_release_in_commit_raises_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release1;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release2;
|
|
|
|
|
|
|
|
buffer_release1 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
client_roundtrip(client);
|
|
|
|
|
|
|
|
/* Second buffer_release creation should fail */
|
|
|
|
buffer_release2 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_surface_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_ERROR_DUPLICATE_RELEASE);
|
|
|
|
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release2);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release1);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(get_release_without_buffer_raises_commit_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
struct wl_surface *surface = client->surface->wl_surface;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release;
|
|
|
|
|
|
|
|
buffer_release =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_surface_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_ERROR_NO_BUFFER);
|
|
|
|
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(get_release_on_destroyed_surface_raises_error)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release;
|
|
|
|
|
|
|
|
wl_surface_destroy(client->surface->wl_surface);
|
|
|
|
client->surface->wl_surface = NULL;
|
|
|
|
buffer_release =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
expect_protocol_error(
|
|
|
|
client,
|
|
|
|
&zwp_linux_surface_synchronization_v1_interface,
|
|
|
|
ZWP_LINUX_SURFACE_SYNCHRONIZATION_V1_ERROR_NO_SURFACE);
|
|
|
|
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(get_release_after_commit_succeeds)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct wl_surface *surface = client->surface->wl_surface;
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, surface);
|
|
|
|
struct buffer *buf1 = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release1;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release2;
|
|
|
|
|
|
|
|
buffer_release1 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
client_roundtrip(client);
|
|
|
|
|
|
|
|
wl_surface_attach(surface, buf1->proxy, 0, 0);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
|
|
|
|
buffer_release2 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
client_roundtrip(client);
|
|
|
|
|
|
|
|
buffer_destroy(buf1);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release2);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release1);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
buffer_release_fenced_handler(void *data,
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release,
|
|
|
|
int32_t fence)
|
|
|
|
{
|
|
|
|
assert(!"Fenced release not supported yet");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
buffer_release_immediate_handler(void *data,
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release)
|
|
|
|
{
|
|
|
|
int *released = data;
|
|
|
|
|
|
|
|
*released += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct zwp_linux_buffer_release_v1_listener buffer_release_listener = {
|
|
|
|
buffer_release_fenced_handler,
|
|
|
|
buffer_release_immediate_handler
|
|
|
|
};
|
|
|
|
|
|
|
|
/* The following release event tests depend on the behavior of the used
|
|
|
|
* backend, in this case the pixman backend. This doesn't limit their
|
|
|
|
* usefulness, though, since it allows them to check if, given a typical
|
|
|
|
* backend implementation, weston core supports the per commit nature of the
|
|
|
|
* release events.
|
|
|
|
*/
|
|
|
|
|
|
|
|
TEST(get_release_events_are_emitted_for_different_buffers)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
struct buffer *buf1 = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct buffer *buf2 = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct wl_surface *surface = client->surface->wl_surface;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release1;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release2;
|
|
|
|
int buf_released1 = 0;
|
|
|
|
int buf_released2 = 0;
|
|
|
|
int frame;
|
|
|
|
|
|
|
|
buffer_release1 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release1,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released1);
|
|
|
|
wl_surface_attach(surface, buf1->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* No release event should have been emitted yet (we are using the
|
|
|
|
* pixman renderer, which holds buffers until they are replaced). */
|
|
|
|
assert(buf_released1 == 0);
|
|
|
|
|
|
|
|
buffer_release2 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release2,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released2);
|
|
|
|
wl_surface_attach(surface, buf2->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* Check that exactly one buffer_release event was emitted for the
|
|
|
|
* previous commit (buf1). */
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 0);
|
|
|
|
|
|
|
|
wl_surface_attach(surface, buf1->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* Check that exactly one buffer_release event was emitted for the
|
|
|
|
* previous commit (buf2). */
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 1);
|
|
|
|
|
|
|
|
buffer_destroy(buf2);
|
|
|
|
buffer_destroy(buf1);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release2);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release1);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(get_release_events_are_emitted_for_same_buffer_on_surface)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, client->surface->wl_surface);
|
|
|
|
struct buffer *buf = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct wl_surface *surface = client->surface->wl_surface;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release1;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release2;
|
|
|
|
int buf_released1 = 0;
|
|
|
|
int buf_released2 = 0;
|
|
|
|
int frame;
|
|
|
|
|
|
|
|
buffer_release1 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release1,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released1);
|
|
|
|
wl_surface_attach(surface, buf->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* No release event should have been emitted yet (we are using the
|
|
|
|
* pixman renderer, which holds buffers until they are replaced). */
|
|
|
|
assert(buf_released1 == 0);
|
|
|
|
|
|
|
|
buffer_release2 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release2,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released2);
|
|
|
|
wl_surface_attach(surface, buf->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* Check that exactly one buffer_release event was emitted for the
|
|
|
|
* previous commit (buf). */
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 0);
|
|
|
|
|
|
|
|
wl_surface_attach(surface, buf->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface, &frame);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
/* Check that exactly one buffer_release event was emitted for the
|
|
|
|
* previous commit (buf again). */
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 1);
|
|
|
|
|
|
|
|
buffer_destroy(buf);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release2);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release1);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(get_release_events_are_emitted_for_same_buffer_on_different_surfaces)
|
|
|
|
{
|
|
|
|
struct client *client = create_test_client();
|
|
|
|
struct surface *other_surface = create_test_surface(client);
|
|
|
|
struct wl_surface *surface1 = client->surface->wl_surface;
|
|
|
|
struct wl_surface *surface2 = other_surface->wl_surface;
|
|
|
|
struct zwp_linux_explicit_synchronization_v1 *sync =
|
|
|
|
get_linux_explicit_synchronization(client);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync1 =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, surface1);
|
|
|
|
struct zwp_linux_surface_synchronization_v1 *surface_sync2 =
|
|
|
|
zwp_linux_explicit_synchronization_v1_get_synchronization(
|
|
|
|
sync, surface2);
|
|
|
|
struct buffer *buf1 = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct buffer *buf2 = create_shm_buffer_a8r8g8b8(client, 100, 100);
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release1;
|
|
|
|
struct zwp_linux_buffer_release_v1 *buffer_release2;
|
|
|
|
int buf_released1 = 0;
|
|
|
|
int buf_released2 = 0;
|
|
|
|
int frame;
|
|
|
|
|
|
|
|
weston_test_move_surface(client->test->weston_test, surface2, 0, 0);
|
|
|
|
|
|
|
|
/* Attach buf1 to both surface1 and surface2. */
|
|
|
|
buffer_release1 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync1);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release1,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released1);
|
|
|
|
wl_surface_attach(surface1, buf1->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface1, &frame);
|
|
|
|
wl_surface_commit(surface1);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
|
|
|
|
buffer_release2 =
|
|
|
|
zwp_linux_surface_synchronization_v1_get_release(surface_sync2);
|
|
|
|
zwp_linux_buffer_release_v1_add_listener(buffer_release2,
|
|
|
|
&buffer_release_listener,
|
|
|
|
&buf_released2);
|
|
|
|
wl_surface_attach(surface2, buf1->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface2, &frame);
|
|
|
|
wl_surface_commit(surface2);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
|
|
|
|
assert(buf_released1 == 0);
|
|
|
|
assert(buf_released2 == 0);
|
|
|
|
|
|
|
|
/* Attach buf2 to surface1, and check that a buffer_release event for
|
|
|
|
* the previous commit (buf1) for that surface is emitted. */
|
|
|
|
wl_surface_attach(surface1, buf2->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface1, &frame);
|
|
|
|
wl_surface_commit(surface1);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 0);
|
|
|
|
|
|
|
|
/* Attach buf2 to surface2, and check that a buffer_release event for
|
|
|
|
* the previous commit (buf1) for that surface is emitted. */
|
|
|
|
wl_surface_attach(surface2, buf2->proxy, 0, 0);
|
|
|
|
frame_callback_set(surface2, &frame);
|
|
|
|
wl_surface_commit(surface2);
|
|
|
|
frame_callback_wait(client, &frame);
|
|
|
|
|
|
|
|
assert(buf_released1 == 1);
|
|
|
|
assert(buf_released2 == 1);
|
|
|
|
|
|
|
|
buffer_destroy(buf2);
|
|
|
|
buffer_destroy(buf1);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release2);
|
|
|
|
zwp_linux_buffer_release_v1_destroy(buffer_release1);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync2);
|
|
|
|
zwp_linux_surface_synchronization_v1_destroy(surface_sync1);
|
|
|
|
zwp_linux_explicit_synchronization_v1_destroy(sync);
|
|
|
|
surface_destroy(other_surface);
|
|
|
|
client_destroy(client);
|
|
|
|
}
|