compositor: add capability CAPTURE_YFLIP
Both GL and pixman renderer (pixman probably only because GL did?)
return the screen capture image as y-flipped, therefore Weston y-flips
it again. However, the future rpi-renderer can produce only right-way-up
(non-flipped) screen captures, and does not need an y-flip.
Add a capability flag for y-flip, which the rpi-renderer will not set,
to get screen captures the right way up.
The wcap recording code needs yet another temporary buffer for the
non-flipped case, since the WCAP format is flipped, and the code
normally overwrites the input image as it compresses it. This becomes
difficult, if the compressor is supposed to flip while processing.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
diff --git a/src/compositor.c b/src/compositor.c
index 6e5879e..a35649d 100644
--- a/src/compositor.c
+++ b/src/compositor.c
@@ -2889,10 +2889,11 @@
}
static const struct {
- uint32_t bit;
+ uint32_t bit; /* enum weston_capability */
const char *desc;
} capability_strings[] = {
{ WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" },
+ { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" },
};
static void
diff --git a/src/compositor.h b/src/compositor.h
index ea3ff65..06476cc 100644
--- a/src/compositor.h
+++ b/src/compositor.h
@@ -488,6 +488,9 @@
enum weston_capability {
/* backend/renderer supports arbitrary rotation */
WESTON_CAP_ROTATION_ANY = 0x0001,
+
+ /* screencaptures need to be y-flipped */
+ WESTON_CAP_CAPTURE_YFLIP = 0x0002,
};
struct weston_compositor {
diff --git a/src/gl-renderer.c b/src/gl-renderer.c
index a3785f8..c89b916 100644
--- a/src/gl-renderer.c
+++ b/src/gl-renderer.c
@@ -1831,6 +1831,7 @@
ec->renderer = &gr->base;
ec->capabilities |= WESTON_CAP_ROTATION_ANY;
+ ec->capabilities |= WESTON_CAP_CAPTURE_YFLIP;
return 0;
diff --git a/src/pixman-renderer.c b/src/pixman-renderer.c
index eea32fc..315ea15 100644
--- a/src/pixman-renderer.c
+++ b/src/pixman-renderer.c
@@ -659,6 +659,7 @@
renderer->base.destroy = pixman_renderer_destroy;
ec->renderer = &renderer->base;
ec->capabilities |= WESTON_CAP_ROTATION_ANY;
+ ec->capabilities |= WESTON_CAP_CAPTURE_YFLIP;
weston_compositor_add_debug_binding(ec, KEY_R,
debug_binding, ec);
diff --git a/src/screenshooter.c b/src/screenshooter.c
index ae97b4e..6f53fad 100644
--- a/src/screenshooter.c
+++ b/src/screenshooter.c
@@ -62,6 +62,13 @@
}
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;
@@ -92,18 +99,32 @@
}
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
screenshooter_frame_notify(struct wl_listener *listener, void *data)
{
struct screenshooter_frame_listener *l =
container_of(listener,
struct screenshooter_frame_listener, listener);
struct weston_output *output = data;
+ struct weston_compositor *compositor = output->compositor;
int32_t stride;
uint8_t *pixels, *d, *s;
output->disable_planes--;
wl_list_remove(&listener->link);
- stride = l->buffer->width * (PIXMAN_FORMAT_BPP(output->compositor->read_format) / 8);
+ stride = l->buffer->width * (PIXMAN_FORMAT_BPP(compositor->read_format) / 8);
pixels = malloc(stride * l->buffer->height);
if (pixels == NULL) {
@@ -112,8 +133,8 @@
return;
}
- output->compositor->renderer->read_pixels(output,
- output->compositor->read_format, pixels,
+ compositor->renderer->read_pixels(output,
+ compositor->read_format, pixels,
0, 0, output->current->width,
output->current->height);
@@ -122,14 +143,20 @@
d = wl_shm_buffer_get_data(l->buffer);
s = pixels + stride * (l->buffer->height - 1);
- switch (output->compositor->read_format) {
+ switch (compositor->read_format) {
case PIXMAN_a8r8g8b8:
case PIXMAN_x8r8g8b8:
- copy_bgra_yflip(d, s, output->current->height, stride);
+ if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
+ copy_bgra_yflip(d, s, output->current->height, stride);
+ else
+ copy_bgra(d, pixels, output->current->height, stride);
break;
case PIXMAN_x8b8g8r8:
case PIXMAN_a8b8g8r8:
- copy_rgba_yflip(d, s, output->current->height, stride);
+ if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
+ copy_rgba_yflip(d, s, output->current->height, stride);
+ else
+ copy_rgba(d, pixels, output->current->height, stride);
break;
default:
break;
@@ -218,6 +245,7 @@
struct weston_recorder {
struct weston_output *output;
uint32_t *frame, *rect;
+ uint32_t *tmpbuf;
uint32_t total;
int fd;
struct wl_listener frame_listener;
@@ -260,7 +288,7 @@
{
pixman_box32_t s = *r;
- switch(output->transform) {
+ switch (output->transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
@@ -272,7 +300,7 @@
break;
}
- switch(output->transform) {
+ switch (output->transform) {
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
r->x1 = s.x1;
@@ -310,6 +338,7 @@
struct weston_recorder *recorder =
container_of(listener, struct weston_recorder, frame_listener);
struct weston_output *output = data;
+ struct weston_compositor *compositor = output->compositor;
uint32_t msecs = output->frame_time;
pixman_box32_t *r;
pixman_region32_t damage;
@@ -320,6 +349,15 @@
uint32_t nrects;
} header;
struct iovec v[2];
+ int do_yflip;
+ int y_orig;
+ uint32_t *outbuf;
+
+ do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
+ if (do_yflip)
+ outbuf = recorder->rect;
+ else
+ outbuf = recorder->tmpbuf;
pixman_region32_init(&damage);
pixman_region32_intersect(&damage, &output->region,
@@ -344,17 +382,26 @@
for (i = 0; i < n; i++) {
width = r[i].x2 - r[i].x1;
height = r[i].y2 - r[i].y1;
- output->compositor->renderer->read_pixels(output,
- output->compositor->read_format, recorder->rect,
- r[i].x1, output->current->height - r[i].y2,
- width, height);
+
+ if (do_yflip)
+ y_orig = output->current->height - r[i].y2;
+ else
+ y_orig = r[i].y1;
+
+ compositor->renderer->read_pixels(output,
+ compositor->read_format, recorder->rect,
+ r[i].x1, y_orig, width, height);
s = recorder->rect;
- p = recorder->rect;
+ p = outbuf;
run = prev = 0; /* quiet gcc */
for (j = 0; j < height; j++) {
- d = recorder->frame +
- stride * (r[i].y2 - j - 1) + r[i].x1;
+ if (do_yflip)
+ y_orig = r[i].y2 - j - 1;
+ else
+ y_orig = r[i].y1 + j;
+ d = recorder->frame + stride * y_orig + r[i].x1;
+
for (k = 0; k < width; k++) {
next = *s++;
delta = component_delta(next, *d);
@@ -372,15 +419,14 @@
p = output_run(p, prev, run);
recorder->total += write(recorder->fd,
- recorder->rect,
- (p - recorder->rect) * 4);
+ outbuf, (p - outbuf) * 4);
#if 0
fprintf(stderr,
"%dx%d at %d,%d rle from %d to %d bytes (%f) total %dM\n",
width, height, r[i].x1, r[i].y1,
- width * height * 4, (int) (p - recorder->rect) * 4,
- (float) (p - recorder->rect) / (width * height),
+ width * height * 4, (int) (p - outbuf) * 4,
+ (float) (p - outbuf) / (width * height),
recorder->total / 1024 / 1024);
#endif
}
@@ -391,9 +437,13 @@
static void
weston_recorder_create(struct weston_output *output, const char *filename)
{
+ struct weston_compositor *compositor = output->compositor;
struct weston_recorder *recorder;
int stride, size;
struct { uint32_t magic, format, width, height; } header;
+ int do_yflip;
+
+ do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
recorder = malloc(sizeof *recorder);
@@ -406,9 +456,14 @@
recorder->output = output;
memset(recorder->frame, 0, size);
+ if (do_yflip)
+ recorder->tmpbuf = NULL;
+ else
+ recorder->tmpbuf = malloc(size);
+
header.magic = WCAP_HEADER_MAGIC;
- switch (output->compositor->read_format) {
+ switch (compositor->read_format) {
case PIXMAN_a8r8g8b8:
header.format = WCAP_FORMAT_XRGB8888;
break;
@@ -445,6 +500,7 @@
{
wl_list_remove(&recorder->frame_listener.link);
close(recorder->fd);
+ free(recorder->tmpbuf);
free(recorder->frame);
free(recorder->rect);
recorder->output->disable_planes--;