mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: drop test suite screenshooter implementation and protocol extension

Browse Source 
This is a follow-up of commit "tests: start to use Weston's
default screenshooter in the test suite".

As we've started to use Weston's default screenshooter
implementation and protocol extension in the test suite,
we don't need what we've created specifically for the test
suite anymore.

Drop test suite screenshooter implementation and protocol
extension.

Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
dev
Leandro Ribeiro 4 years ago committed by Pekka Paalanen
parent 9e90760ab0
commit 79491b41f5
2 changed files with 0 additions and 261 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 16
      protocol/weston-test.xml
  2. 245
      tests/weston-test.c

16
protocol/weston-test.xml
Unescape View File

@ -80,22 +80,6 @@
<arg name="x" type="fixed"/> <arg name="x" type="fixed"/>
<arg name="y" type="fixed"/> <arg name="y" type="fixed"/>
</event> </event>
<request name="capture_screenshot">
<description summary="records current screen image">
Records an image of what is currently displayed on a given
display output, returning the image as an event.
</description>
<arg name="output" type="object" interface="wl_output"
summary="output to capture from"/>
<arg name="buffer" type="object" interface="wl_buffer"
summary="buffer for returning screenshots to the test client"/>
</request>
<event name="capture_screenshot_done">
<description summary="screenshot capture is done">
The capture_screenshot_done signal is sent when a screenshot has been copied into the
provided buffer.
</description>
</event>
<request name="send_touch"> <request name="send_touch">
<arg name="tv_sec_hi" type="uint"/> <arg name="tv_sec_hi" type="uint"/>
<arg name="tv_sec_lo" type="uint"/> <arg name="tv_sec_lo" type="uint"/>

245
tests/weston-test.c
Unescape View File

@ -338,250 +338,6 @@ device_add(struct wl_client *client,
} }
} }
enum weston_test_screenshot_outcome {
WESTON_TEST_SCREENSHOT_SUCCESS,
WESTON_TEST_SCREENSHOT_NO_MEMORY,
WESTON_TEST_SCREENSHOT_BAD_BUFFER
};
typedef void (*weston_test_screenshot_done_func_t)(void *data,
enum weston_test_screenshot_outcome outcome);
struct test_screenshot {
struct weston_compositor *compositor;
struct wl_global *global;
struct wl_client *client;
struct weston_process process;
struct wl_listener destroy_listener;
};
struct test_screenshot_frame_listener {
struct wl_listener listener;
struct weston_buffer *buffer;
struct weston_output *output;
weston_test_screenshot_done_func_t done;
void *data;
};
static void
copy_bgra_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
{
uint8_t *end;
end = dst + height * stride;
while (dst < end) {
memcpy(dst, src, stride);
dst += stride;
src -= stride;
}
}
static void
copy_bgra(uint8_t *dst, uint8_t *src, int height, int stride)
{
/* TODO: optimize this out */
memcpy(dst, src, height * stride);
}
static void
copy_row_swap_RB(void *vdst, void *vsrc, int bytes)
{
uint32_t *dst = vdst;
uint32_t *src = vsrc;
uint32_t *end = dst + bytes / 4;
while (dst < end) {
uint32_t v = *src++;
/* A R G B */
uint32_t tmp = v & 0xff00ff00;
tmp |= (v >> 16) & 0x000000ff;
tmp |= (v << 16) & 0x00ff0000;
*dst++ = tmp;
}
}
static void
copy_rgba_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
{
uint8_t *end;
end = dst + height * stride;
while (dst < end) {
copy_row_swap_RB(dst, src, stride);
dst += stride;
src -= stride;
}
}
static void
copy_rgba(uint8_t *dst, uint8_t *src, int height, int stride)
{
uint8_t *end;
end = dst + height * stride;
while (dst < end) {
copy_row_swap_RB(dst, src, stride);
dst += stride;
src += stride;
}
}
static void
test_screenshot_frame_notify(struct wl_listener *listener, void *data)
{
struct test_screenshot_frame_listener *l =
container_of(listener,
struct test_screenshot_frame_listener, listener);
struct weston_output *output = l->output;
struct weston_compositor *compositor = output->compositor;
int32_t stride;
uint8_t *pixels, *d, *s;
weston_output_disable_planes_decr(output);
wl_list_remove(&listener->link);
stride = l->buffer->width * (PIXMAN_FORMAT_BPP(compositor->read_format) / 8);
pixels = malloc(stride * l->buffer->height);
if (pixels == NULL) {
l->done(l->data, WESTON_TEST_SCREENSHOT_NO_MEMORY);
free(l);
return;
}
/* FIXME: Needs to handle output transformations */
compositor->renderer->read_pixels(output,
compositor->read_format,
pixels,
0, 0,
output->current_mode->width,
output->current_mode->height);
stride = wl_shm_buffer_get_stride(l->buffer->shm_buffer);
d = wl_shm_buffer_get_data(l->buffer->shm_buffer);
s = pixels + stride * (l->buffer->height - 1);
wl_shm_buffer_begin_access(l->buffer->shm_buffer);
/* XXX: It would be nice if we used Pixman to do all this rather
* than our own implementation
*/
switch (compositor->read_format) {
case PIXMAN_a8r8g8b8:
case PIXMAN_x8r8g8b8:
if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
copy_bgra_yflip(d, s, output->current_mode->height, stride);
else
copy_bgra(d, pixels, output->current_mode->height, stride);
break;
case PIXMAN_x8b8g8r8:
case PIXMAN_a8b8g8r8:
if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
copy_rgba_yflip(d, s, output->current_mode->height, stride);
else
copy_rgba(d, pixels, output->current_mode->height, stride);
break;
default:
break;
}
wl_shm_buffer_end_access(l->buffer->shm_buffer);
l->done(l->data, WESTON_TEST_SCREENSHOT_SUCCESS);
free(pixels);
free(l);
}
static bool
weston_test_screenshot_shoot(struct weston_output *output,
struct weston_buffer *buffer,
weston_test_screenshot_done_func_t done,
void *data)
{
struct test_screenshot_frame_listener *l;
/* Get the shm buffer resource the client created */
if (!wl_shm_buffer_get(buffer->resource)) {
done(data, WESTON_TEST_SCREENSHOT_BAD_BUFFER);
return false;
}
buffer->shm_buffer = wl_shm_buffer_get(buffer->resource);
buffer->width = wl_shm_buffer_get_width(buffer->shm_buffer);
buffer->height = wl_shm_buffer_get_height(buffer->shm_buffer);
/* Verify buffer is big enough */
if (buffer->width < output->current_mode->width ||
buffer->height < output->current_mode->height) {
done(data, WESTON_TEST_SCREENSHOT_BAD_BUFFER);
return false;
}
/* allocate the frame listener */
l = malloc(sizeof *l);
if (l == NULL) {
done(data, WESTON_TEST_SCREENSHOT_NO_MEMORY);
return false;
}
/* Set up the listener */
l->buffer = buffer;
l->output = output;
l->done = done;
l->data = data;
l->listener.notify = test_screenshot_frame_notify;
wl_signal_add(&output->frame_signal, &l->listener);
/* Fire off a repaint */
weston_output_disable_planes_incr(output);
weston_output_schedule_repaint(output);
return true;
}
static void
capture_screenshot_done(void *data, enum weston_test_screenshot_outcome outcome)
{
struct wl_resource *resource = data;
switch (outcome) {
case WESTON_TEST_SCREENSHOT_SUCCESS:
weston_test_send_capture_screenshot_done(resource);
break;
case WESTON_TEST_SCREENSHOT_NO_MEMORY:
wl_resource_post_no_memory(resource);
break;
default:
break;
}
}
/**
* Grabs a snapshot of the screen.
*/
static void
capture_screenshot(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *output_resource,
struct wl_resource *buffer_resource)
{
struct weston_output *output =
weston_head_from_resource(output_resource)->output;
struct weston_buffer *buffer =
weston_buffer_from_resource(buffer_resource);
if (buffer == NULL) {
wl_resource_post_no_memory(resource);
return;
}
weston_test_screenshot_shoot(output, buffer,
capture_screenshot_done, resource);
}
static void static void
send_touch(struct wl_client *client, struct wl_resource *resource, send_touch(struct wl_client *client, struct wl_resource *resource,
uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec, uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec,
@ -608,7 +364,6 @@ static const struct weston_test_interface test_implementation = {
send_key, send_key,
device_release, device_release,
device_add, device_add,
capture_screenshot,
send_touch, send_touch,
}; };

Write Preview
Loading…
Cancel
Save