You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
498 lines
17 KiB
498 lines
17 KiB
/*
|
|
* 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>
|
|
#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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|