mirrors/weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
676296749a
weston/tests/linux-explicit-synchronization-test.c
Alexandros Frantzis 676296749a libweston: Support zwp_surface_synchronization_v1.get_release 
Implement the get_release request of the zwp_surface_synchronization_v1
interface.

This commit implements the zwp_buffer_release_v1 interface. It supports
the zwp_buffer_release_v1.fenced_release event for surfaces rendered by
the GL renderer, and the zwp_buffer_release_v1.immediate_release event
for other cases.

Note that the immediate_release event is safe to be used for surface
buffers used as planes in the DRM backend, since the backend releases
them only after the next page flip that doesn't use the buffers has
finished.

Changes in v7:
  - Remove "partial" from commit title and description.
  - Fix inverted check when clearing used_in_output_repaint flag.

Changes in v5:
  - Use the new, generic explicit sync server error reporting function.
  - Introduce and use weston_buffer_release_move.
  - Introduce internally and use weston_buffer_release_destroy.

Changes in v4:
  - Support the zwp_buffer_release_v1.fenced_release event.
  - Support release fences in the GL renderer.
  - Assert that pending state buffer_release is always NULL after a
    commit.
  - Simplify weston_buffer_release_reference.
  - Move removal of destroy listener before resource destruction to
    avoid concerns about use-after-free in
    weston_buffer_release_reference
  - Rename weston_buffer_release_reference.busy_count to ref_count.
  - Add documentation for weston_buffer_release and ..._reference.

Changes in v3:
  - Raise NO_BUFFER for get_release if no buffer has been committed,
    don't raise UNSUPPORTED_BUFFER for non-dmabuf buffers,
    so get_release works for all valid buffers.
  - Destroy the buffer_release object after sending an event.
  - Track lifetime of buffer_release objects per commit, independently
    of any buffers.
  - Use updated protocol interface names.
  - Use correct format specifier for resource ids.

Changes in v2:
  - Raise UNSUPPORTED_BUFFER at commit if client has requested a
    buffer_release, but the committed buffer is not a valid linux_dmabuf.
  - Remove tests that are not viable anymore due to our inability to
    create dmabuf buffers and fences in a unit-test environment.

Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
2019-02-06 12:21:56 +00:00

330 lines
11 KiB
C
Raw Blame History

/*
* 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"
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 == 1);
sync = wl_registry_bind(
client->wl_registry, global_sync->name,
&zwp_linux_explicit_synchronization_v1_interface, 1);
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
};
TEST(get_release_events_are_emitted)
{
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);
/* Check that exactly one buffer_release event was emitted. */
assert(buf_released1 == 1);
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 we didn't get any new events on the inactive
* buffer_release. */
assert(buf_released1 == 1);
/* Check that exactly one buffer_release event was emitted. */
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);
}
Reference in New Issue View Git Blame Copy Permalink