blob: f236ca497748f2e4e8ef160e3b06aeb8fafeb119 [file] [log] [blame]
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001/*
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04002 * Copyright © 2008-2011 Kristian Høgsberg
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04004 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040013 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040014 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040021 */
22
Daniel Stonec228e232013-05-22 18:03:19 +030023#include "config.h"
24
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040025#include <stdlib.h>
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -040026#include <stdio.h>
Kristian Høgsbergf02a6492012-03-12 01:05:25 -040027#include <string.h>
Scott Moreau56456d62012-03-23 16:42:04 -060028#include <linux/input.h>
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -040029#include <fcntl.h>
30#include <unistd.h>
31#include <sys/uio.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040032
33#include "compositor.h"
Kristian Høgsbergc5dcb902010-09-14 15:53:32 -040034#include "screenshooter-server-protocol.h"
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040035
Kristian Høgsberg2bcb2fc2012-05-25 18:03:52 -040036#include "../wcap/wcap-decode.h"
Kristian Høgsberg894e0b52012-05-25 17:55:20 -040037
Kristian Høgsbergcf57dc52011-04-18 10:33:25 -040038struct screenshooter {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050039 struct weston_compositor *ec;
Pekka Paalanen35ce06d2012-01-03 11:39:13 +020040 struct wl_global *global;
Scott Moreau56456d62012-03-23 16:42:04 -060041 struct wl_client *client;
Scott Moreau80d27b72012-04-04 11:49:21 -060042 struct weston_process process;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -040043 struct wl_listener destroy_listener;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040044};
45
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -040046struct screenshooter_frame_listener {
47 struct wl_listener listener;
Jason Ekstrand6bd62942013-06-20 20:38:23 -050048 struct weston_buffer *buffer;
Scott Moreau062be7e2012-04-20 13:37:33 -060049 struct wl_resource *resource;
50};
51
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040052static void
Scott Moreau72c23722012-04-20 13:37:34 -060053copy_bgra_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
Pekka Paalanen45fab0e2012-04-17 11:55:41 +030054{
55 uint8_t *end;
56
Scott Moreau72c23722012-04-20 13:37:34 -060057 end = dst + height * stride;
Pekka Paalanen45fab0e2012-04-17 11:55:41 +030058 while (dst < end) {
Scott Moreau72c23722012-04-20 13:37:34 -060059 memcpy(dst, src, stride);
60 dst += stride;
61 src -= stride;
Pekka Paalanen45fab0e2012-04-17 11:55:41 +030062 }
63}
64
65static void
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +030066copy_bgra(uint8_t *dst, uint8_t *src, int height, int stride)
67{
68 /* TODO: optimize this out */
69 memcpy(dst, src, height * stride);
70}
71
72static void
Pekka Paalanena1d57db2012-04-17 15:02:08 +030073copy_row_swap_RB(void *vdst, void *vsrc, int bytes)
74{
75 uint32_t *dst = vdst;
76 uint32_t *src = vsrc;
77 uint32_t *end = dst + bytes / 4;
78
79 while (dst < end) {
80 uint32_t v = *src++;
81 /* A R G B */
82 uint32_t tmp = v & 0xff00ff00;
83 tmp |= (v >> 16) & 0x000000ff;
84 tmp |= (v << 16) & 0x00ff0000;
85 *dst++ = tmp;
86 }
87}
88
89static void
Scott Moreau72c23722012-04-20 13:37:34 -060090copy_rgba_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
Pekka Paalanena1d57db2012-04-17 15:02:08 +030091{
92 uint8_t *end;
93
Scott Moreau72c23722012-04-20 13:37:34 -060094 end = dst + height * stride;
Pekka Paalanena1d57db2012-04-17 15:02:08 +030095 while (dst < end) {
Scott Moreau72c23722012-04-20 13:37:34 -060096 copy_row_swap_RB(dst, src, stride);
97 dst += stride;
98 src -= stride;
Pekka Paalanena1d57db2012-04-17 15:02:08 +030099 }
100}
101
102static void
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300103copy_rgba(uint8_t *dst, uint8_t *src, int height, int stride)
104{
105 uint8_t *end;
106
107 end = dst + height * stride;
108 while (dst < end) {
109 copy_row_swap_RB(dst, src, stride);
110 dst += stride;
111 src += stride;
112 }
113}
114
115static void
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400116screenshooter_frame_notify(struct wl_listener *listener, void *data)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400117{
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400118 struct screenshooter_frame_listener *l =
119 container_of(listener,
120 struct screenshooter_frame_listener, listener);
Kristian Høgsberge0f832b2012-06-20 00:13:18 -0400121 struct weston_output *output = data;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300122 struct weston_compositor *compositor = output->compositor;
Scott Moreau72c23722012-04-20 13:37:34 -0600123 int32_t stride;
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400124 uint8_t *pixels, *d, *s;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400125
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400126 output->disable_planes--;
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400127 wl_list_remove(&listener->link);
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300128 stride = l->buffer->width * (PIXMAN_FORMAT_BPP(compositor->read_format) / 8);
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400129 pixels = malloc(stride * l->buffer->height);
Kristian Høgsbergf02a6492012-03-12 01:05:25 -0400130
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400131 if (pixels == NULL) {
132 wl_resource_post_no_memory(l->resource);
133 free(l);
134 return;
135 }
136
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300137 compositor->renderer->read_pixels(output,
138 compositor->read_format, pixels,
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100139 0, 0, output->current->width,
140 output->current->height);
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400141
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500142 stride = wl_shm_buffer_get_stride(l->buffer->shm_buffer);
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400143
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500144 d = wl_shm_buffer_get_data(l->buffer->shm_buffer);
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400145 s = pixels + stride * (l->buffer->height - 1);
Pekka Paalanena1d57db2012-04-17 15:02:08 +0300146
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300147 switch (compositor->read_format) {
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100148 case PIXMAN_a8r8g8b8:
Vasily Khoruzhick26171852013-01-06 12:12:41 +0300149 case PIXMAN_x8r8g8b8:
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300150 if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
151 copy_bgra_yflip(d, s, output->current->height, stride);
152 else
153 copy_bgra(d, pixels, output->current->height, stride);
Pekka Paalanena1d57db2012-04-17 15:02:08 +0300154 break;
Vasily Khoruzhick26171852013-01-06 12:12:41 +0300155 case PIXMAN_x8b8g8r8:
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100156 case PIXMAN_a8b8g8r8:
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300157 if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
158 copy_rgba_yflip(d, s, output->current->height, stride);
159 else
160 copy_rgba(d, pixels, output->current->height, stride);
Pekka Paalanena1d57db2012-04-17 15:02:08 +0300161 break;
162 default:
163 break;
164 }
Kristian Høgsbergf02a6492012-03-12 01:05:25 -0400165
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400166 screenshooter_send_done(l->resource);
167 free(pixels);
168 free(l);
Scott Moreau062be7e2012-04-20 13:37:33 -0600169}
170
171static void
172screenshooter_shoot(struct wl_client *client,
173 struct wl_resource *resource,
174 struct wl_resource *output_resource,
175 struct wl_resource *buffer_resource)
176{
Jason Ekstranda0d2dde2013-06-14 10:08:01 -0500177 struct weston_output *output =
178 wl_resource_get_user_data(output_resource);
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400179 struct screenshooter_frame_listener *l;
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500180 struct weston_buffer *buffer =
181 weston_buffer_from_resource(buffer_resource);
Scott Moreau062be7e2012-04-20 13:37:33 -0600182
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500183 if (!wl_shm_buffer_get(buffer->resource))
Scott Moreau062be7e2012-04-20 13:37:33 -0600184 return;
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500185
186 buffer->shm_buffer = wl_shm_buffer_get(buffer->resource);
187 buffer->width = wl_shm_buffer_get_width(buffer->shm_buffer);
188 buffer->height = wl_shm_buffer_get_height(buffer->shm_buffer);
Scott Moreau062be7e2012-04-20 13:37:33 -0600189
190 if (buffer->width < output->current->width ||
191 buffer->height < output->current->height)
192 return;
193
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400194 l = malloc(sizeof *l);
195 if (l == NULL) {
Scott Moreau062be7e2012-04-20 13:37:33 -0600196 wl_resource_post_no_memory(resource);
197 return;
198 }
199
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400200 l->buffer = buffer;
201 l->resource = resource;
Scott Moreau062be7e2012-04-20 13:37:33 -0600202
Kristian Høgsbergae2ba9b2012-06-20 00:05:46 -0400203 l->listener.notify = screenshooter_frame_notify;
204 wl_signal_add(&output->frame_signal, &l->listener);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400205 output->disable_planes++;
Kristian Høgsberg49952d12012-06-20 00:35:59 -0400206 weston_output_schedule_repaint(output);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400207}
208
Kristian Høgsbergcf57dc52011-04-18 10:33:25 -0400209struct screenshooter_interface screenshooter_implementation = {
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400210 screenshooter_shoot
211};
212
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -0400213static void
214bind_shooter(struct wl_client *client,
215 void *data, uint32_t version, uint32_t id)
216{
Scott Moreau56456d62012-03-23 16:42:04 -0600217 struct screenshooter *shooter = data;
218 struct wl_resource *resource;
219
Jason Ekstranda85118c2013-06-27 20:17:02 -0500220 resource = wl_resource_create(client,
221 &screenshooter_interface, 1, id);
Scott Moreau56456d62012-03-23 16:42:04 -0600222
223 if (client != shooter->client) {
224 wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
225 "screenshooter failed: permission denied");
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400226 wl_resource_destroy(resource);
Scott Moreau56456d62012-03-23 16:42:04 -0600227 }
Jason Ekstranda85118c2013-06-27 20:17:02 -0500228
229 wl_resource_set_implementation(resource, &screenshooter_implementation,
230 data, NULL);
Scott Moreau56456d62012-03-23 16:42:04 -0600231}
232
233static void
234screenshooter_sigchld(struct weston_process *process, int status)
235{
236 struct screenshooter *shooter =
Scott Moreau80d27b72012-04-04 11:49:21 -0600237 container_of(process, struct screenshooter, process);
Scott Moreau56456d62012-03-23 16:42:04 -0600238
239 shooter->client = NULL;
240}
241
242static void
Kristian Høgsberge3148752013-05-06 23:19:49 -0400243screenshooter_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
Daniel Stone325fc2d2012-05-30 16:31:58 +0100244 void *data)
Scott Moreau56456d62012-03-23 16:42:04 -0600245{
246 struct screenshooter *shooter = data;
247 const char *screenshooter_exe = LIBEXECDIR "/weston-screenshooter";
248
249 if (!shooter->client)
250 shooter->client = weston_client_launch(shooter->ec,
Scott Moreau80d27b72012-04-04 11:49:21 -0600251 &shooter->process,
Scott Moreau56456d62012-03-23 16:42:04 -0600252 screenshooter_exe, screenshooter_sigchld);
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -0400253}
254
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400255struct weston_recorder {
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400256 struct weston_output *output;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400257 uint32_t *frame, *rect;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300258 uint32_t *tmpbuf;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400259 uint32_t total;
260 int fd;
261 struct wl_listener frame_listener;
Kristian Høgsberge012c822012-05-25 17:50:42 -0400262 int count;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400263};
264
265static uint32_t *
266output_run(uint32_t *p, uint32_t delta, int run)
267{
268 int i;
269
270 while (run > 0) {
271 if (run <= 0xe0) {
272 *p++ = delta | ((run - 1) << 24);
273 break;
274 }
275
276 i = 24 - __builtin_clz(run);
277 *p++ = delta | ((i + 0xe0) << 24);
278 run -= 1 << (7 + i);
279 }
280
281 return p;
282}
283
Kristian Høgsberg053be422012-05-29 12:15:47 -0400284static uint32_t
285component_delta(uint32_t next, uint32_t prev)
286{
287 unsigned char dr, dg, db;
288
289 dr = (next >> 16) - (prev >> 16);
290 dg = (next >> 8) - (prev >> 8);
291 db = (next >> 0) - (prev >> 0);
292
293 return (dr << 16) | (dg << 8) | (db << 0);
294}
295
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400296static void
Kristian Høgsbergf0377dd2012-11-14 20:28:30 -0500297transform_rect(struct weston_output *output, pixman_box32_t *r)
298{
299 pixman_box32_t s = *r;
300
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300301 switch (output->transform) {
Kristian Høgsbergf0377dd2012-11-14 20:28:30 -0500302 case WL_OUTPUT_TRANSFORM_FLIPPED:
303 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
304 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
305 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
306 s.x1 = output->width - r->x2;
307 s.x2 = output->width - r->x1;
308 break;
309 default:
310 break;
311 }
312
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300313 switch (output->transform) {
Kristian Høgsbergf0377dd2012-11-14 20:28:30 -0500314 case WL_OUTPUT_TRANSFORM_NORMAL:
315 case WL_OUTPUT_TRANSFORM_FLIPPED:
316 r->x1 = s.x1;
317 r->x2 = s.x2;
318 break;
319 case WL_OUTPUT_TRANSFORM_90:
320 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
321 r->x1 = output->current->width - s.y2;
322 r->y1 = s.x1;
323 r->x2 = output->current->width - s.y1;
324 r->y2 = s.x2;
325 break;
326 case WL_OUTPUT_TRANSFORM_180:
327 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
328 r->x1 = output->current->width - s.x2;
329 r->y1 = output->current->height - s.y2;
330 r->x2 = output->current->width - s.x1;
331 r->y2 = output->current->height - s.y1;
332 break;
333 case WL_OUTPUT_TRANSFORM_270:
334 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
335 r->x1 = s.y1;
336 r->y1 = output->current->height - s.x2;
337 r->x2 = s.y2;
338 r->y2 = output->current->height - s.x1;
339 break;
340 default:
341 break;
342 }
Alexander Larssonb846a8d2013-05-29 12:01:34 +0200343
344 r->x1 *= output->scale;
345 r->y1 *= output->scale;
346 r->x2 *= output->scale;
347 r->y2 *= output->scale;
Kristian Høgsbergf0377dd2012-11-14 20:28:30 -0500348}
349
350static void
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400351weston_recorder_frame_notify(struct wl_listener *listener, void *data)
352{
353 struct weston_recorder *recorder =
354 container_of(listener, struct weston_recorder, frame_listener);
Kristian Høgsberge0f832b2012-06-20 00:13:18 -0400355 struct weston_output *output = data;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300356 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge0f832b2012-06-20 00:13:18 -0400357 uint32_t msecs = output->frame_time;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400358 pixman_box32_t *r;
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +0200359 pixman_region32_t damage;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400360 int i, j, k, n, width, height, run, stride;
361 uint32_t delta, prev, *d, *s, *p, next;
362 struct {
363 uint32_t msecs;
364 uint32_t nrects;
365 } header;
366 struct iovec v[2];
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300367 int do_yflip;
368 int y_orig;
369 uint32_t *outbuf;
370
371 do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
372 if (do_yflip)
373 outbuf = recorder->rect;
374 else
375 outbuf = recorder->tmpbuf;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400376
377 pixman_region32_init(&damage);
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +0200378 pixman_region32_intersect(&damage, &output->region,
379 &output->previous_damage);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400380
381 r = pixman_region32_rectangles(&damage, &n);
382 if (n == 0)
383 return;
384
Kristian Høgsbergf0377dd2012-11-14 20:28:30 -0500385 for (i = 0; i < n; i++)
386 transform_rect(output, &r[i]);
387
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400388 header.msecs = msecs;
389 header.nrects = n;
390 v[0].iov_base = &header;
391 v[0].iov_len = sizeof header;
392 v[1].iov_base = r;
393 v[1].iov_len = n * sizeof *r;
394 recorder->total += writev(recorder->fd, v, 2);
395 stride = output->current->width;
396
397 for (i = 0; i < n; i++) {
398 width = r[i].x2 - r[i].x1;
399 height = r[i].y2 - r[i].y1;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300400
401 if (do_yflip)
402 y_orig = output->current->height - r[i].y2;
403 else
404 y_orig = r[i].y1;
405
406 compositor->renderer->read_pixels(output,
407 compositor->read_format, recorder->rect,
408 r[i].x1, y_orig, width, height);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400409
410 s = recorder->rect;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300411 p = outbuf;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400412 run = prev = 0; /* quiet gcc */
413 for (j = 0; j < height; j++) {
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300414 if (do_yflip)
415 y_orig = r[i].y2 - j - 1;
416 else
417 y_orig = r[i].y1 + j;
418 d = recorder->frame + stride * y_orig + r[i].x1;
419
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400420 for (k = 0; k < width; k++) {
421 next = *s++;
Kristian Høgsberg053be422012-05-29 12:15:47 -0400422 delta = component_delta(next, *d);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400423 *d++ = next;
424 if (run == 0 || delta == prev) {
425 run++;
426 } else {
427 p = output_run(p, prev, run);
428 run = 1;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400429 }
Kristian Høgsberg9c9b3a42012-06-20 00:28:16 -0400430 prev = delta;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400431 }
432 }
433
434 p = output_run(p, prev, run);
435
436 recorder->total += write(recorder->fd,
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300437 outbuf, (p - outbuf) * 4);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400438
439#if 0
440 fprintf(stderr,
441 "%dx%d at %d,%d rle from %d to %d bytes (%f) total %dM\n",
442 width, height, r[i].x1, r[i].y1,
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300443 width * height * 4, (int) (p - outbuf) * 4,
444 (float) (p - outbuf) / (width * height),
Kristian Høgsbergf6f69d32012-06-18 17:10:19 -0400445 recorder->total / 1024 / 1024);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400446#endif
447 }
448
449 pixman_region32_fini(&damage);
Pekka Paalanend0cbf182013-05-22 18:03:12 +0300450 recorder->count++;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400451}
452
453static void
454weston_recorder_create(struct weston_output *output, const char *filename)
455{
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300456 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400457 struct weston_recorder *recorder;
458 int stride, size;
Kristian Høgsberg3b969602012-05-25 17:45:39 -0400459 struct { uint32_t magic, format, width, height; } header;
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300460 int do_yflip;
461
462 do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400463
464 recorder = malloc(sizeof *recorder);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400465
466 stride = output->current->width;
467 size = stride * 4 * output->current->height;
468 recorder->frame = malloc(size);
469 recorder->rect = malloc(size);
470 recorder->total = 0;
Kristian Høgsberge012c822012-05-25 17:50:42 -0400471 recorder->count = 0;
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400472 recorder->output = output;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400473 memset(recorder->frame, 0, size);
474
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300475 if (do_yflip)
476 recorder->tmpbuf = NULL;
477 else
478 recorder->tmpbuf = malloc(size);
479
Kristian Høgsberg3b969602012-05-25 17:45:39 -0400480 header.magic = WCAP_HEADER_MAGIC;
481
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300482 switch (compositor->read_format) {
Alexander Larsson55765462013-05-29 12:01:32 +0200483 case PIXMAN_x8r8g8b8:
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100484 case PIXMAN_a8r8g8b8:
Kristian Høgsberg3b969602012-05-25 17:45:39 -0400485 header.format = WCAP_FORMAT_XRGB8888;
486 break;
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100487 case PIXMAN_a8b8g8r8:
Kristian Høgsberg3b969602012-05-25 17:45:39 -0400488 header.format = WCAP_FORMAT_XBGR8888;
489 break;
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +0100490 default:
491 weston_log("unknown recorder format\n");
Rob Bradforde6675c22013-01-10 19:48:52 +0000492 free(recorder);
Rob Bradford49887032012-12-05 18:47:03 +0000493 return;
Kristian Høgsberg3b969602012-05-25 17:45:39 -0400494 }
495
Rob Bradfordba1e2922012-12-05 18:47:04 +0000496 recorder->fd = open(filename,
497 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
498
499 if (recorder->fd < 0) {
500 weston_log("problem opening output file %s: %m\n", filename);
Rob Bradforde6675c22013-01-10 19:48:52 +0000501 free(recorder);
Rob Bradfordba1e2922012-12-05 18:47:04 +0000502 return;
503 }
504
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400505 header.width = output->current->width;
506 header.height = output->current->height;
507 recorder->total += write(recorder->fd, &header, sizeof header);
508
509 recorder->frame_listener.notify = weston_recorder_frame_notify;
510 wl_signal_add(&output->frame_signal, &recorder->frame_listener);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400511 output->disable_planes++;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400512 weston_output_damage(output);
513}
514
515static void
516weston_recorder_destroy(struct weston_recorder *recorder)
517{
518 wl_list_remove(&recorder->frame_listener.link);
519 close(recorder->fd);
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +0300520 free(recorder->tmpbuf);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400521 free(recorder->frame);
522 free(recorder->rect);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400523 recorder->output->disable_planes--;
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400524 free(recorder);
525}
526
527static void
Kristian Høgsberge3148752013-05-06 23:19:49 -0400528recorder_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400529{
530 struct weston_seat *ws = (struct weston_seat *) seat;
531 struct weston_compositor *ec = ws->compositor;
532 struct weston_output *output =
533 container_of(ec->output_list.next,
534 struct weston_output, link);
535 struct wl_listener *listener;
536 struct weston_recorder *recorder;
537 static const char filename[] = "capture.wcap";
538
539 listener = wl_signal_get(&output->frame_signal,
540 weston_recorder_frame_notify);
541 if (listener) {
542 recorder = container_of(listener, struct weston_recorder,
543 frame_listener);
544
Pekka Paalanend0cbf182013-05-22 18:03:12 +0300545 weston_log(
Kristian Høgsberge012c822012-05-25 17:50:42 -0400546 "stopping recorder, total file size %dM, %d frames\n",
547 recorder->total / (1024 * 1024), recorder->count);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400548
549 weston_recorder_destroy(recorder);
550 } else {
Pekka Paalanend0cbf182013-05-22 18:03:12 +0300551 weston_log("starting recorder, file %s\n", filename);
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -0400552 weston_recorder_create(output, filename);
553 }
554}
555
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400556static void
557screenshooter_destroy(struct wl_listener *listener, void *data)
558{
559 struct screenshooter *shooter =
560 container_of(listener, struct screenshooter, destroy_listener);
561
562 wl_display_remove_global(shooter->ec->wl_display, shooter->global);
563 free(shooter);
564}
565
566void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500567screenshooter_create(struct weston_compositor *ec)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400568{
Kristian Høgsbergcf57dc52011-04-18 10:33:25 -0400569 struct screenshooter *shooter;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400570
571 shooter = malloc(sizeof *shooter);
572 if (shooter == NULL)
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400573 return;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400574
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400575 shooter->ec = ec;
Scott Moreau56456d62012-03-23 16:42:04 -0600576 shooter->client = NULL;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400577
Pekka Paalanen35ce06d2012-01-03 11:39:13 +0200578 shooter->global = wl_display_add_global(ec->wl_display,
579 &screenshooter_interface,
580 shooter, bind_shooter);
Daniel Stone325fc2d2012-05-30 16:31:58 +0100581 weston_compositor_add_key_binding(ec, KEY_S, MODIFIER_SUPER,
582 screenshooter_binding, shooter);
583 weston_compositor_add_key_binding(ec, KEY_R, MODIFIER_SUPER,
584 recorder_binding, shooter);
Pekka Paalanen35ce06d2012-01-03 11:39:13 +0200585
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400586 shooter->destroy_listener.notify = screenshooter_destroy;
587 wl_signal_add(&ec->destroy_signal, &shooter->destroy_listener);
Pekka Paalanen35ce06d2012-01-03 11:39:13 +0200588}