2 * Copyright © 2008-2011 Kristian Høgsberg
4 * 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.
14 * 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.
28 #include <linux/input.h>
33 #include "compositor.h"
34 #include "screenshooter-server-protocol.h"
36 #include "../wcap/wcap-decode.h"
38 struct screenshooter {
39 struct weston_compositor *ec;
40 struct wl_global *global;
41 struct wl_client *client;
42 struct weston_process process;
43 struct wl_listener destroy_listener;
46 struct screenshooter_frame_listener {
47 struct wl_listener listener;
48 struct weston_buffer *buffer;
49 weston_screenshooter_done_func_t done;
54 copy_bgra_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
58 end = dst + height * stride;
60 memcpy(dst, src, stride);
67 copy_bgra(uint8_t *dst, uint8_t *src, int height, int stride)
69 /* TODO: optimize this out */
70 memcpy(dst, src, height * stride);
74 copy_row_swap_RB(void *vdst, void *vsrc, int bytes)
78 uint32_t *end = dst + bytes / 4;
83 uint32_t tmp = v & 0xff00ff00;
84 tmp |= (v >> 16) & 0x000000ff;
85 tmp |= (v << 16) & 0x00ff0000;
91 copy_rgba_yflip(uint8_t *dst, uint8_t *src, int height, int stride)
95 end = dst + height * stride;
97 copy_row_swap_RB(dst, src, stride);
104 copy_rgba(uint8_t *dst, uint8_t *src, int height, int stride)
108 end = dst + height * stride;
110 copy_row_swap_RB(dst, src, stride);
117 screenshooter_frame_notify(struct wl_listener *listener, void *data)
119 struct screenshooter_frame_listener *l =
120 container_of(listener,
121 struct screenshooter_frame_listener, listener);
122 struct weston_output *output = data;
123 struct weston_compositor *compositor = output->compositor;
125 uint8_t *pixels, *d, *s;
127 output->disable_planes--;
128 wl_list_remove(&listener->link);
129 stride = l->buffer->width * (PIXMAN_FORMAT_BPP(compositor->read_format) / 8);
130 pixels = malloc(stride * l->buffer->height);
132 if (pixels == NULL) {
133 l->done(l->data, WESTON_SCREENSHOOTER_NO_MEMORY);
138 compositor->renderer->read_pixels(output,
139 compositor->read_format, pixels,
140 0, 0, output->current_mode->width,
141 output->current_mode->height);
143 stride = wl_shm_buffer_get_stride(l->buffer->shm_buffer);
145 d = wl_shm_buffer_get_data(l->buffer->shm_buffer);
146 s = pixels + stride * (l->buffer->height - 1);
148 wl_shm_buffer_begin_access(l->buffer->shm_buffer);
150 switch (compositor->read_format) {
151 case PIXMAN_a8r8g8b8:
152 case PIXMAN_x8r8g8b8:
153 if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
154 copy_bgra_yflip(d, s, output->current_mode->height, stride);
156 copy_bgra(d, pixels, output->current_mode->height, stride);
158 case PIXMAN_x8b8g8r8:
159 case PIXMAN_a8b8g8r8:
160 if (compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP)
161 copy_rgba_yflip(d, s, output->current_mode->height, stride);
163 copy_rgba(d, pixels, output->current_mode->height, stride);
169 wl_shm_buffer_end_access(l->buffer->shm_buffer);
171 l->done(l->data, WESTON_SCREENSHOOTER_SUCCESS);
177 weston_screenshooter_shoot(struct weston_output *output,
178 struct weston_buffer *buffer,
179 weston_screenshooter_done_func_t done, void *data)
181 struct screenshooter_frame_listener *l;
183 if (!wl_shm_buffer_get(buffer->resource)) {
184 done(data, WESTON_SCREENSHOOTER_BAD_BUFFER);
188 buffer->shm_buffer = wl_shm_buffer_get(buffer->resource);
189 buffer->width = wl_shm_buffer_get_width(buffer->shm_buffer);
190 buffer->height = wl_shm_buffer_get_height(buffer->shm_buffer);
192 if (buffer->width < output->current_mode->width ||
193 buffer->height < output->current_mode->height) {
194 done(data, WESTON_SCREENSHOOTER_BAD_BUFFER);
198 l = malloc(sizeof *l);
200 done(data, WESTON_SCREENSHOOTER_NO_MEMORY);
207 l->listener.notify = screenshooter_frame_notify;
208 wl_signal_add(&output->frame_signal, &l->listener);
209 output->disable_planes++;
210 weston_output_schedule_repaint(output);
216 screenshooter_done(void *data, enum weston_screenshooter_outcome outcome)
218 struct wl_resource *resource = data;
221 case WESTON_SCREENSHOOTER_SUCCESS:
222 screenshooter_send_done(resource);
224 case WESTON_SCREENSHOOTER_NO_MEMORY:
225 wl_resource_post_no_memory(resource);
233 screenshooter_shoot(struct wl_client *client,
234 struct wl_resource *resource,
235 struct wl_resource *output_resource,
236 struct wl_resource *buffer_resource)
238 struct weston_output *output =
239 wl_resource_get_user_data(output_resource);
240 struct weston_buffer *buffer =
241 weston_buffer_from_resource(buffer_resource);
243 if (buffer == NULL) {
244 wl_resource_post_no_memory(resource);
248 weston_screenshooter_shoot(output, buffer, screenshooter_done, resource);
251 struct screenshooter_interface screenshooter_implementation = {
256 bind_shooter(struct wl_client *client,
257 void *data, uint32_t version, uint32_t id)
259 struct screenshooter *shooter = data;
260 struct wl_resource *resource;
262 resource = wl_resource_create(client,
263 &screenshooter_interface, 1, id);
265 if (client != shooter->client) {
266 wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
267 "screenshooter failed: permission denied");
271 wl_resource_set_implementation(resource, &screenshooter_implementation,
276 screenshooter_sigchld(struct weston_process *process, int status)
278 struct screenshooter *shooter =
279 container_of(process, struct screenshooter, process);
281 shooter->client = NULL;
285 screenshooter_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
288 struct screenshooter *shooter = data;
289 char *screenshooter_exe;
292 ret = asprintf(&screenshooter_exe, "%s/%s",
293 weston_config_get_libexec_dir(),
294 "/weston-screenshooter");
296 weston_log("Could not construct screenshooter path.\n");
300 if (!shooter->client)
301 shooter->client = weston_client_launch(shooter->ec,
303 screenshooter_exe, screenshooter_sigchld);
304 free(screenshooter_exe);
307 struct weston_recorder {
308 struct weston_output *output;
309 uint32_t *frame, *rect;
313 struct wl_listener frame_listener;
314 int count, destroying;
318 output_run(uint32_t *p, uint32_t delta, int run)
324 *p++ = delta | ((run - 1) << 24);
328 i = 24 - __builtin_clz(run);
329 *p++ = delta | ((i + 0xe0) << 24);
337 component_delta(uint32_t next, uint32_t prev)
339 unsigned char dr, dg, db;
341 dr = (next >> 16) - (prev >> 16);
342 dg = (next >> 8) - (prev >> 8);
343 db = (next >> 0) - (prev >> 0);
345 return (dr << 16) | (dg << 8) | (db << 0);
349 weston_recorder_destroy(struct weston_recorder *recorder);
352 weston_recorder_frame_notify(struct wl_listener *listener, void *data)
354 struct weston_recorder *recorder =
355 container_of(listener, struct weston_recorder, frame_listener);
356 struct weston_output *output = data;
357 struct weston_compositor *compositor = output->compositor;
358 uint32_t msecs = output->frame_time;
360 pixman_region32_t damage, transformed_damage;
361 int i, j, k, n, width, height, run, stride;
362 uint32_t delta, prev, *d, *s, *p, next;
372 do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
374 outbuf = recorder->rect;
376 outbuf = recorder->tmpbuf;
378 pixman_region32_init(&damage);
379 pixman_region32_init(&transformed_damage);
380 pixman_region32_intersect(&damage, &output->region,
381 &output->previous_damage);
382 pixman_region32_translate(&damage, -output->x, -output->y);
383 weston_transformed_region(output->width, output->height,
384 output->transform, output->current_scale,
385 &damage, &transformed_damage);
386 pixman_region32_fini(&damage);
388 r = pixman_region32_rectangles(&transformed_damage, &n);
390 pixman_region32_fini(&transformed_damage);
394 header.msecs = msecs;
396 v[0].iov_base = &header;
397 v[0].iov_len = sizeof header;
399 v[1].iov_len = n * sizeof *r;
400 recorder->total += writev(recorder->fd, v, 2);
401 stride = output->current_mode->width;
403 for (i = 0; i < n; i++) {
404 width = r[i].x2 - r[i].x1;
405 height = r[i].y2 - r[i].y1;
408 y_orig = output->current_mode->height - r[i].y2;
412 compositor->renderer->read_pixels(output,
413 compositor->read_format, recorder->rect,
414 r[i].x1, y_orig, width, height);
418 run = prev = 0; /* quiet gcc */
419 for (j = 0; j < height; j++) {
421 y_orig = r[i].y2 - j - 1;
423 y_orig = r[i].y1 + j;
424 d = recorder->frame + stride * y_orig + r[i].x1;
426 for (k = 0; k < width; k++) {
428 delta = component_delta(next, *d);
430 if (run == 0 || delta == prev) {
433 p = output_run(p, prev, run);
440 p = output_run(p, prev, run);
442 recorder->total += write(recorder->fd,
443 outbuf, (p - outbuf) * 4);
447 "%dx%d at %d,%d rle from %d to %d bytes (%f) total %dM\n",
448 width, height, r[i].x1, r[i].y1,
449 width * height * 4, (int) (p - outbuf) * 4,
450 (float) (p - outbuf) / (width * height),
451 recorder->total / 1024 / 1024);
455 pixman_region32_fini(&transformed_damage);
458 if (recorder->destroying)
459 weston_recorder_destroy(recorder);
463 weston_recorder_free(struct weston_recorder *recorder)
465 if (recorder == NULL)
467 free(recorder->rect);
468 free(recorder->tmpbuf);
469 free(recorder->frame);
474 weston_recorder_create(struct weston_output *output, const char *filename)
476 struct weston_compositor *compositor = output->compositor;
477 struct weston_recorder *recorder;
479 struct { uint32_t magic, format, width, height; } header;
482 do_yflip = !!(compositor->capabilities & WESTON_CAP_CAPTURE_YFLIP);
484 recorder = malloc(sizeof *recorder);
485 if (recorder == NULL) {
486 weston_log("%s: out of memory\n", __func__);
490 stride = output->current_mode->width;
491 size = stride * 4 * output->current_mode->height;
492 recorder->frame = zalloc(size);
493 recorder->rect = malloc(size);
496 recorder->destroying = 0;
497 recorder->output = output;
499 if ((recorder->frame == NULL) || (recorder->rect == NULL)) {
500 weston_log("%s: out of memory\n", __func__);
501 weston_recorder_free(recorder);
506 recorder->tmpbuf = NULL;
508 recorder->tmpbuf = malloc(size);
510 header.magic = WCAP_HEADER_MAGIC;
512 switch (compositor->read_format) {
513 case PIXMAN_x8r8g8b8:
514 case PIXMAN_a8r8g8b8:
515 header.format = WCAP_FORMAT_XRGB8888;
517 case PIXMAN_a8b8g8r8:
518 header.format = WCAP_FORMAT_XBGR8888;
521 weston_log("unknown recorder format\n");
522 weston_recorder_free(recorder);
526 recorder->fd = open(filename,
527 O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
529 if (recorder->fd < 0) {
530 weston_log("problem opening output file %s: %m\n", filename);
531 weston_recorder_free(recorder);
535 header.width = output->current_mode->width;
536 header.height = output->current_mode->height;
537 recorder->total += write(recorder->fd, &header, sizeof header);
539 recorder->frame_listener.notify = weston_recorder_frame_notify;
540 wl_signal_add(&output->frame_signal, &recorder->frame_listener);
541 output->disable_planes++;
542 weston_output_damage(output);
546 weston_recorder_destroy(struct weston_recorder *recorder)
548 wl_list_remove(&recorder->frame_listener.link);
550 recorder->output->disable_planes--;
551 weston_recorder_free(recorder);
555 recorder_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
557 struct weston_seat *ws = (struct weston_seat *) seat;
558 struct weston_compositor *ec = ws->compositor;
559 struct weston_output *output;
560 struct wl_listener *listener = NULL;
561 struct weston_recorder *recorder;
562 static const char filename[] = "capture.wcap";
564 wl_list_for_each(output, &seat->compositor->output_list, link) {
565 listener = wl_signal_get(&output->frame_signal,
566 weston_recorder_frame_notify);
572 recorder = container_of(listener, struct weston_recorder,
576 "stopping recorder, total file size %dM, %d frames\n",
577 recorder->total / (1024 * 1024), recorder->count);
579 recorder->destroying = 1;
580 weston_output_schedule_repaint(recorder->output);
582 if (seat->keyboard && seat->keyboard->focus &&
583 seat->keyboard->focus->output)
584 output = seat->keyboard->focus->output;
586 output = container_of(ec->output_list.next,
587 struct weston_output, link);
589 weston_log("starting recorder for output %s, file %s\n",
590 output->name, filename);
591 weston_recorder_create(output, filename);
596 screenshooter_destroy(struct wl_listener *listener, void *data)
598 struct screenshooter *shooter =
599 container_of(listener, struct screenshooter, destroy_listener);
601 wl_global_destroy(shooter->global);
606 screenshooter_create(struct weston_compositor *ec)
608 struct screenshooter *shooter;
610 shooter = malloc(sizeof *shooter);
615 shooter->client = NULL;
617 shooter->global = wl_global_create(ec->wl_display,
618 &screenshooter_interface, 1,
619 shooter, bind_shooter);
620 weston_compositor_add_key_binding(ec, KEY_S, MODIFIER_SUPER,
621 screenshooter_binding, shooter);
622 weston_compositor_add_key_binding(ec, KEY_R, MODIFIER_SUPER,
623 recorder_binding, shooter);
625 shooter->destroy_listener.notify = screenshooter_destroy;
626 wl_signal_add(&ec->destroy_signal, &shooter->destroy_listener);