Weston 1.3.1

1 files changed, 591 insertions, 0 deletions

diff --git a/src/screenshooter.c b/src/screenshooter.c
new file mode 100644
index 00000000..645114d0
--- /dev/null
+++ b/src/screenshooter.c
@@ -0,0 +1,591 @@
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the copyright holders not be used in
+ * advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission.  The copyright holders make
+ * no representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <linux/input.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/uio.h>
+
+#include "compositor.h"
+#include "screenshooter-server-protocol.h"
+
+#include "../wcap/wcap-decode.h"
+
+struct screenshooter {
+	struct weston_compositor *ec;
+	struct wl_global *global;
+	struct wl_client *client;
+	struct weston_process process;
+	struct wl_listener destroy_listener;
+};
+
+struct screenshooter_frame_listener {
+	struct wl_listener listener;
+	struct weston_buffer *buffer;
+	struct wl_resource *resource;
+};
+
+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
+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(compositor->read_format) / 8);
+	pixels = malloc(stride * l->buffer->height);
+
+	if (pixels == NULL) {
+		wl_resource_post_no_memory(l->resource);
+		free(l);
+		return;
+	}
+
+	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);
+
+	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;
+	}
+
+	screenshooter_send_done(l->resource);
+	free(pixels);
+	free(l);
+}
+
+static void
+screenshooter_shoot(struct wl_client *client,
+		    struct wl_resource *resource,
+		    struct wl_resource *output_resource,
+		    struct wl_resource *buffer_resource)
+{
+	struct weston_output *output =
+		wl_resource_get_user_data(output_resource);
+	struct screenshooter_frame_listener *l;
+	struct weston_buffer *buffer =
+		weston_buffer_from_resource(buffer_resource);
+
+	if (buffer == NULL) {
+		wl_resource_post_no_memory(resource);
+		return;
+	}
+	if (!wl_shm_buffer_get(buffer->resource))
+		return;
+	
+	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);
+
+	if (buffer->width < output->current_mode->width ||
+	    buffer->height < output->current_mode->height)
+		return;
+
+	l = malloc(sizeof *l);
+	if (l == NULL) {
+		wl_resource_post_no_memory(resource);
+		return;
+	}
+
+	l->buffer = buffer;
+	l->resource = resource;
+
+	l->listener.notify = screenshooter_frame_notify;
+	wl_signal_add(&output->frame_signal, &l->listener);
+	output->disable_planes++;
+	weston_output_schedule_repaint(output);
+}
+
+struct screenshooter_interface screenshooter_implementation = {
+	screenshooter_shoot
+};
+
+static void
+bind_shooter(struct wl_client *client,
+	     void *data, uint32_t version, uint32_t id)
+{
+	struct screenshooter *shooter = data;
+	struct wl_resource *resource;
+
+	resource = wl_resource_create(client,
+				      &screenshooter_interface, 1, id);
+
+	if (client != shooter->client) {
+		wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
+				       "screenshooter failed: permission denied");
+		wl_resource_destroy(resource);
+	}
+
+	wl_resource_set_implementation(resource, &screenshooter_implementation,
+				       data, NULL);
+}
+
+static void
+screenshooter_sigchld(struct weston_process *process, int status)
+{
+	struct screenshooter *shooter =
+		container_of(process, struct screenshooter, process);
+
+	shooter->client = NULL;
+}
+
+static void
+screenshooter_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
+		      void *data)
+{
+	struct screenshooter *shooter = data;
+	const char *screenshooter_exe = LIBEXECDIR "/weston-screenshooter";
+
+	if (!shooter->client)
+		shooter->client = weston_client_launch(shooter->ec,
+					&shooter->process,
+					screenshooter_exe, screenshooter_sigchld);
+}
+
+struct weston_recorder {
+	struct weston_output *output;
+	uint32_t *frame, *rect;
+	uint32_t *tmpbuf;
+	uint32_t total;
+	int fd;
+	struct wl_listener frame_listener;
+	int count;
+};
+
+static uint32_t *
+output_run(uint32_t *p, uint32_t delta, int run)
+{
+	int i;
+
+	while (run > 0) {
+		if (run <= 0xe0) {
+			*p++ = delta | ((run - 1) << 24);
+			break;
+		}
+
+		i = 24 - __builtin_clz(run);
+		*p++ = delta | ((i + 0xe0) << 24);
+		run -= 1 << (7 + i);
+	}
+
+	return p;
+}
+
+static uint32_t
+component_delta(uint32_t next, uint32_t prev)
+{
+	unsigned char dr, dg, db;
+
+	dr = (next >> 16) - (prev >> 16);
+	dg = (next >>  8) - (prev >>  8);
+	db = (next >>  0) - (prev >>  0);
+
+	return (dr << 16) | (dg << 8) | (db << 0);
+}
+
+static void
+transform_rect(struct weston_output *output, pixman_box32_t *r)
+{
+	pixman_box32_t s = *r;
+
+	switch (output->transform) {
+	case WL_OUTPUT_TRANSFORM_FLIPPED:
+	case WL_OUTPUT_TRANSFORM_FLIPPED_90:
+	case WL_OUTPUT_TRANSFORM_FLIPPED_180:
+	case WL_OUTPUT_TRANSFORM_FLIPPED_270:
+		s.x1 = output->width - r->x2;
+		s.x2 = output->width - r->x1;
+		break;
+	default:
+		break;
+	}
+
+	switch (output->transform) {
+        case WL_OUTPUT_TRANSFORM_NORMAL:
+        case WL_OUTPUT_TRANSFORM_FLIPPED:
+		r->x1 = s.x1;
+		r->x2 = s.x2;
+                break;
+        case WL_OUTPUT_TRANSFORM_90:
+        case WL_OUTPUT_TRANSFORM_FLIPPED_90:
+		r->x1 = output->current_mode->width - s.y2;
+		r->y1 = s.x1;
+		r->x2 = output->current_mode->width - s.y1;
+		r->y2 = s.x2;
+                break;
+        case WL_OUTPUT_TRANSFORM_180:
+        case WL_OUTPUT_TRANSFORM_FLIPPED_180:
+		r->x1 = output->current_mode->width - s.x2;
+		r->y1 = output->current_mode->height - s.y2;
+		r->x2 = output->current_mode->width - s.x1;
+		r->y2 = output->current_mode->height - s.y1;
+                break;
+        case WL_OUTPUT_TRANSFORM_270:
+        case WL_OUTPUT_TRANSFORM_FLIPPED_270:
+		r->x1 = s.y1; 
+		r->y1 = output->current_mode->height - s.x2;
+		r->x2 = s.y2; 
+		r->y2 = output->current_mode->height - s.x1;
+                break;
+        default:
+                break;
+        }
+
+	r->x1 *= output->current_scale;
+	r->y1 *= output->current_scale;
+	r->x2 *= output->current_scale;
+	r->y2 *= output->current_scale;
+}
+
+static void
+weston_recorder_frame_notify(struct wl_listener *listener, void *data)
+{
+	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;
+	int i, j, k, n, width, height, run, stride;
+	uint32_t delta, prev, *d, *s, *p, next;
+	struct {
+		uint32_t msecs;
+		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,
+				  &output->previous_damage);
+
+	r = pixman_region32_rectangles(&damage, &n);
+	if (n == 0)
+		return;
+
+	for (i = 0; i < n; i++)
+		transform_rect(output, &r[i]);
+
+	header.msecs = msecs;
+	header.nrects = n;
+	v[0].iov_base = &header;
+	v[0].iov_len = sizeof header;
+	v[1].iov_base = r;
+	v[1].iov_len = n * sizeof *r;
+	recorder->total += writev(recorder->fd, v, 2);
+	stride = output->current_mode->width;
+
+	for (i = 0; i < n; i++) {
+		width = r[i].x2 - r[i].x1;
+		height = r[i].y2 - r[i].y1;
+
+		if (do_yflip)
+			y_orig = output->current_mode->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 = outbuf;
+		run = prev = 0; /* quiet gcc */
+		for (j = 0; j < height; j++) {
+			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);
+				*d++ = next;
+				if (run == 0 || delta == prev) {
+					run++;
+				} else {
+					p = output_run(p, prev, run);
+					run = 1;
+				}
+				prev = delta;
+			}
+		}
+
+		p = output_run(p, prev, run);
+
+		recorder->total += write(recorder->fd,
+					 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 - outbuf) * 4,
+			(float) (p - outbuf) / (width * height),
+			recorder->total / 1024 / 1024);
+#endif
+	}
+
+	pixman_region32_fini(&damage);
+	recorder->count++;
+}
+
+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);
+
+	stride = output->current_mode->width;
+	size = stride * 4 * output->current_mode->height;
+	recorder->frame = zalloc(size);
+	recorder->rect = malloc(size);
+	recorder->total = 0;
+	recorder->count = 0;
+	recorder->output = output;
+
+	if (do_yflip)
+		recorder->tmpbuf = NULL;
+	else
+		recorder->tmpbuf = malloc(size);
+
+	header.magic = WCAP_HEADER_MAGIC;
+
+	switch (compositor->read_format) {
+	case PIXMAN_x8r8g8b8:
+	case PIXMAN_a8r8g8b8:
+		header.format = WCAP_FORMAT_XRGB8888;
+		break;
+	case PIXMAN_a8b8g8r8:
+		header.format = WCAP_FORMAT_XBGR8888;
+		break;
+	default:
+		weston_log("unknown recorder format\n");
+		free(recorder);
+		return;
+	}
+
+	recorder->fd = open(filename,
+			    O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
+
+	if (recorder->fd < 0) {
+		weston_log("problem opening output file %s: %m\n", filename);
+		free(recorder);
+		return;
+	}
+
+	header.width = output->current_mode->width;
+	header.height = output->current_mode->height;
+	recorder->total += write(recorder->fd, &header, sizeof header);
+
+	recorder->frame_listener.notify = weston_recorder_frame_notify;
+	wl_signal_add(&output->frame_signal, &recorder->frame_listener);
+	output->disable_planes++;
+	weston_output_damage(output);
+}
+
+static void
+weston_recorder_destroy(struct weston_recorder *recorder)
+{
+	wl_list_remove(&recorder->frame_listener.link);
+	close(recorder->fd);
+	free(recorder->tmpbuf);
+	free(recorder->frame);
+	free(recorder->rect);
+	recorder->output->disable_planes--;
+	free(recorder);
+}
+
+static void
+recorder_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
+{
+	struct weston_seat *ws = (struct weston_seat *) seat;
+	struct weston_compositor *ec = ws->compositor;
+	struct weston_output *output =
+		container_of(ec->output_list.next,
+			     struct weston_output, link);
+	struct wl_listener *listener;
+	struct weston_recorder *recorder;
+	static const char filename[] = "capture.wcap";
+
+	listener = wl_signal_get(&output->frame_signal,
+				 weston_recorder_frame_notify);
+	if (listener) {
+		recorder = container_of(listener, struct weston_recorder,
+					frame_listener);
+
+		weston_log(
+			"stopping recorder, total file size %dM, %d frames\n",
+			recorder->total / (1024 * 1024), recorder->count);
+
+		weston_recorder_destroy(recorder);
+	} else {
+		weston_log("starting recorder, file %s\n", filename);
+		weston_recorder_create(output, filename);
+	}
+}
+
+static void
+screenshooter_destroy(struct wl_listener *listener, void *data)
+{
+	struct screenshooter *shooter =
+		container_of(listener, struct screenshooter, destroy_listener);
+
+	wl_global_destroy(shooter->global);
+	free(shooter);
+}
+
+void
+screenshooter_create(struct weston_compositor *ec)
+{
+	struct screenshooter *shooter;
+
+	shooter = malloc(sizeof *shooter);
+	if (shooter == NULL)
+		return;
+
+	shooter->ec = ec;
+	shooter->client = NULL;
+
+	shooter->global = wl_global_create(ec->wl_display,
+					   &screenshooter_interface, 1,
+					   shooter, bind_shooter);
+	weston_compositor_add_key_binding(ec, KEY_S, MODIFIER_SUPER,
+					  screenshooter_binding, shooter);
+	weston_compositor_add_key_binding(ec, KEY_R, MODIFIER_SUPER,
+					  recorder_binding, shooter);
+
+	shooter->destroy_listener.notify = screenshooter_destroy;
+	wl_signal_add(&ec->destroy_signal, &shooter->destroy_listener);
+}