/* * Copyright © 2012 Intel Corporation * Copyright © 2013 Vasily Khoruzhick * Copyright © 2015 Collabora, Ltd. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial * portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "config.h" #include #include #include #include #include "pixman-renderer.h" #include "color.h" #include "pixel-formats.h" #include "shared/helpers.h" #include "shared/signal.h" #include "shared/weston-drm-fourcc.h" #include struct pixman_output_state { pixman_image_t *shadow_image; const struct pixel_format_info *shadow_format; pixman_image_t *hw_buffer; pixman_region32_t *hw_extra_damage; }; struct pixman_surface_state { struct weston_surface *surface; pixman_image_t *image; struct weston_buffer_reference buffer_ref; struct weston_buffer_release_reference buffer_release_ref; struct wl_listener buffer_destroy_listener; struct wl_listener surface_destroy_listener; struct wl_listener renderer_destroy_listener; }; struct pixman_renderer { struct weston_renderer base; int repaint_debug; pixman_image_t *debug_color; struct weston_binding *debug_binding; struct wl_signal destroy_signal; }; static inline struct pixman_output_state * get_output_state(struct weston_output *output) { return (struct pixman_output_state *)output->renderer_state; } static int pixman_renderer_create_surface(struct weston_surface *surface); static inline struct pixman_surface_state * get_surface_state(struct weston_surface *surface) { if (!surface->renderer_state) pixman_renderer_create_surface(surface); return (struct pixman_surface_state *)surface->renderer_state; } static inline struct pixman_renderer * get_renderer(struct weston_compositor *ec) { return (struct pixman_renderer *)ec->renderer; } static int pixman_renderer_read_pixels(struct weston_output *output, const struct pixel_format_info *format, void *pixels, uint32_t x, uint32_t y, uint32_t width, uint32_t height) { struct pixman_output_state *po = get_output_state(output); pixman_image_t *out_buf; if (!po->hw_buffer) { errno = ENODEV; return -1; } out_buf = pixman_image_create_bits(format->pixman_format, width, height, pixels, (PIXMAN_FORMAT_BPP(format->pixman_format) / 8) * width); pixman_image_composite32(PIXMAN_OP_SRC, po->hw_buffer, /* src */ NULL /* mask */, out_buf, /* dest */ x, y, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ pixman_image_get_width (po->hw_buffer), /* width */ pixman_image_get_height (po->hw_buffer) /* height */); pixman_image_unref(out_buf); return 0; } #define D2F(v) pixman_double_to_fixed((double)v) static void weston_matrix_to_pixman_transform(pixman_transform_t *pt, const struct weston_matrix *wm) { /* Pixman supports only 2D transform matrix, but Weston uses 3D, * * so we're omitting Z coordinate here. */ pt->matrix[0][0] = pixman_double_to_fixed(wm->d[0]); pt->matrix[0][1] = pixman_double_to_fixed(wm->d[4]); pt->matrix[0][2] = pixman_double_to_fixed(wm->d[12]); pt->matrix[1][0] = pixman_double_to_fixed(wm->d[1]); pt->matrix[1][1] = pixman_double_to_fixed(wm->d[5]); pt->matrix[1][2] = pixman_double_to_fixed(wm->d[13]); pt->matrix[2][0] = pixman_double_to_fixed(wm->d[3]); pt->matrix[2][1] = pixman_double_to_fixed(wm->d[7]); pt->matrix[2][2] = pixman_double_to_fixed(wm->d[15]); } static void pixman_renderer_compute_transform(pixman_transform_t *transform_out, struct weston_view *ev, struct weston_output *output) { struct weston_matrix matrix; /* Set up the source transformation based on the surface position, the output position/transform/scale and the client specified buffer transform/scale */ matrix = output->inverse_matrix; if (ev->transform.enabled) { weston_matrix_multiply(&matrix, &ev->transform.inverse); } else { weston_matrix_translate(&matrix, -ev->geometry.x, -ev->geometry.y, 0); } weston_matrix_multiply(&matrix, &ev->surface->surface_to_buffer_matrix); weston_matrix_to_pixman_transform(transform_out, &matrix); } static bool view_transformation_is_translation(struct weston_view *view) { if (!view->transform.enabled) return true; if (view->transform.matrix.type <= WESTON_MATRIX_TRANSFORM_TRANSLATE) return true; return false; } static void region_intersect_only_translation(pixman_region32_t *result_global, pixman_region32_t *global, pixman_region32_t *surf, struct weston_view *view) { float view_x, view_y; assert(view_transformation_is_translation(view)); /* Convert from surface to global coordinates */ pixman_region32_copy(result_global, surf); weston_view_to_global_float(view, 0, 0, &view_x, &view_y); pixman_region32_translate(result_global, (int)view_x, (int)view_y); pixman_region32_intersect(result_global, result_global, global); } static void composite_whole(pixman_op_t op, pixman_image_t *src, pixman_image_t *mask, pixman_image_t *dest, const pixman_transform_t *transform, pixman_filter_t filter) { int32_t dest_width; int32_t dest_height; dest_width = pixman_image_get_width(dest); dest_height = pixman_image_get_height(dest); pixman_image_set_transform(src, transform); pixman_image_set_filter(src, filter, NULL, 0); /* bilinear filtering needs the equivalent of OpenGL CLAMP_TO_EDGE */ if (filter == PIXMAN_FILTER_NEAREST) pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE); else pixman_image_set_repeat(src, PIXMAN_REPEAT_PAD); pixman_image_composite32(op, src, mask, dest, 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ dest_width, dest_height); } static void composite_clipped(pixman_image_t *src, pixman_image_t *mask, pixman_image_t *dest, const pixman_transform_t *transform, pixman_filter_t filter, pixman_region32_t *src_clip) { int n_box; pixman_box32_t *boxes; int32_t dest_width; int32_t dest_height; int src_stride; int bitspp; pixman_format_code_t src_format; void *src_data; int i; /* * Hardcoded to use PIXMAN_OP_OVER, because sampling outside of * a Pixman image produces (0,0,0,0) instead of discarding the * fragment. * * Also repeat mode must be PIXMAN_REPEAT_NONE (the default) to * actually sample (0,0,0,0). This may cause issues for clients that * expect OpenGL CLAMP_TO_EDGE sampling behavior on their buffer. * Using temporary 'boximg' it is not possible to apply CLAMP_TO_EDGE * correctly with bilinear filter. Maybe trapezoid rendering could be * the answer instead of source clip? */ dest_width = pixman_image_get_width(dest); dest_height = pixman_image_get_height(dest); src_format = pixman_image_get_format(src); src_stride = pixman_image_get_stride(src); bitspp = PIXMAN_FORMAT_BPP(src_format); src_data = pixman_image_get_data(src); assert(src_format); /* This would be massive overdraw, except when n_box is 1. */ boxes = pixman_region32_rectangles(src_clip, &n_box); for (i = 0; i < n_box; i++) { uint8_t *ptr = src_data; pixman_image_t *boximg; pixman_transform_t adj = *transform; ptr += boxes[i].y1 * src_stride; ptr += boxes[i].x1 * bitspp / 8; boximg = pixman_image_create_bits_no_clear(src_format, boxes[i].x2 - boxes[i].x1, boxes[i].y2 - boxes[i].y1, (uint32_t *)ptr, src_stride); pixman_transform_translate(&adj, NULL, pixman_int_to_fixed(-boxes[i].x1), pixman_int_to_fixed(-boxes[i].y1)); pixman_image_set_transform(boximg, &adj); pixman_image_set_filter(boximg, filter, NULL, 0); pixman_image_composite32(PIXMAN_OP_OVER, boximg, mask, dest, 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ dest_width, dest_height); pixman_image_unref(boximg); } if (n_box > 1) { static bool warned = false; if (!warned) weston_log("Pixman-renderer warning: %dx overdraw\n", n_box); warned = true; } } /** Paint an intersected region * * \param ev The view to be painted. * \param output The output being painted. * \param repaint_output The region to be painted in output coordinates. * \param source_clip The region of the source image to use, in source image * coordinates. If NULL, use the whole source image. * \param pixman_op Compositing operator, either SRC or OVER. */ static void repaint_region(struct weston_view *ev, struct weston_output *output, pixman_region32_t *repaint_output, pixman_region32_t *source_clip, pixman_op_t pixman_op) { struct pixman_renderer *pr = (struct pixman_renderer *) output->compositor->renderer; struct pixman_surface_state *ps = get_surface_state(ev->surface); struct pixman_output_state *po = get_output_state(output); struct weston_buffer_viewport *vp = &ev->surface->buffer_viewport; pixman_image_t *target_image; pixman_transform_t transform; pixman_filter_t filter; pixman_image_t *mask_image; pixman_color_t mask = { 0, }; if (po->shadow_image) target_image = po->shadow_image; else target_image = po->hw_buffer; /* Clip rendering to the damaged output region */ pixman_image_set_clip_region32(target_image, repaint_output); pixman_renderer_compute_transform(&transform, ev, output); if (ev->transform.enabled || output->current_scale != vp->buffer.scale) filter = PIXMAN_FILTER_BILINEAR; else filter = PIXMAN_FILTER_NEAREST; if (ps->buffer_ref.buffer) wl_shm_buffer_begin_access(ps->buffer_ref.buffer->shm_buffer); if (ev->alpha < 1.0) { mask.alpha = 0xffff * ev->alpha; mask_image = pixman_image_create_solid_fill(&mask); } else { mask_image = NULL; } if (source_clip) composite_clipped(ps->image, mask_image, target_image, &transform, filter, source_clip); else composite_whole(pixman_op, ps->image, mask_image, target_image, &transform, filter); if (mask_image) pixman_image_unref(mask_image); if (ps->buffer_ref.buffer) wl_shm_buffer_end_access(ps->buffer_ref.buffer->shm_buffer); if (pr->repaint_debug) pixman_image_composite32(PIXMAN_OP_OVER, pr->debug_color, /* src */ NULL /* mask */, target_image, /* dest */ 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ pixman_image_get_width (target_image), /* width */ pixman_image_get_height (target_image) /* height */); pixman_image_set_clip_region32(target_image, NULL); } static void draw_view_translated(struct weston_view *view, struct weston_output *output, pixman_region32_t *repaint_global) { struct weston_surface *surface = view->surface; /* non-opaque region in surface coordinates: */ pixman_region32_t surface_blend; /* region to be painted in output coordinates: */ pixman_region32_t repaint_output; pixman_region32_init(&repaint_output); /* Blended region is whole surface minus opaque region, * unless surface alpha forces us to blend all. */ pixman_region32_init_rect(&surface_blend, 0, 0, surface->width, surface->height); if (!(view->alpha < 1.0)) { pixman_region32_subtract(&surface_blend, &surface_blend, &surface->opaque); if (pixman_region32_not_empty(&surface->opaque)) { region_intersect_only_translation(&repaint_output, repaint_global, &surface->opaque, view); weston_region_global_to_output(&repaint_output, output, &repaint_output); repaint_region(view, output, &repaint_output, NULL, PIXMAN_OP_SRC); } } if (pixman_region32_not_empty(&surface_blend)) { region_intersect_only_translation(&repaint_output, repaint_global, &surface_blend, view); weston_region_global_to_output(&repaint_output, output, &repaint_output); repaint_region(view, output, &repaint_output, NULL, PIXMAN_OP_OVER); } pixman_region32_fini(&surface_blend); pixman_region32_fini(&repaint_output); } static void draw_view_source_clipped(struct weston_view *view, struct weston_output *output, pixman_region32_t *repaint_global) { struct weston_surface *surface = view->surface; pixman_region32_t surf_region; pixman_region32_t buffer_region; pixman_region32_t repaint_output; /* Do not bother separating the opaque region from non-opaque. * Source clipping requires PIXMAN_OP_OVER in all cases, so painting * opaque separately has no benefit. */ pixman_region32_init_rect(&surf_region, 0, 0, surface->width, surface->height); if (view->geometry.scissor_enabled) pixman_region32_intersect(&surf_region, &surf_region, &view->geometry.scissor); pixman_region32_init(&buffer_region); weston_surface_to_buffer_region(surface, &surf_region, &buffer_region); pixman_region32_init(&repaint_output); pixman_region32_copy(&repaint_output, repaint_global); weston_region_global_to_output(&repaint_output, output, &repaint_output); repaint_region(view, output, &repaint_output, &buffer_region, PIXMAN_OP_OVER); pixman_region32_fini(&repaint_output); pixman_region32_fini(&buffer_region); pixman_region32_fini(&surf_region); } static void draw_paint_node(struct weston_paint_node *pnode, pixman_region32_t *damage /* in global coordinates */) { struct pixman_surface_state *ps = get_surface_state(pnode->surface); /* repaint bounding region in global coordinates: */ pixman_region32_t repaint; if (!pnode->surf_xform_valid) return; assert(pnode->surf_xform.transform == NULL); /* No buffer attached */ if (!ps->image) return; /* if we still have a reference, but the underlying buffer is no longer * available signal that we should unref image_t as well. This happens * when using close animations, with the reference surviving the * animation while the underlying buffer went away as the client was * terminated. This is a particular use-case and should probably be * refactored to provide some analogue with the GL-renderer (as in, to * still maintain the buffer and let the compositor dispose of it). */ if (ps->buffer_ref.buffer && !ps->buffer_ref.buffer->shm_buffer) { pixman_image_unref(ps->image); ps->image = NULL; return; } pixman_region32_init(&repaint); pixman_region32_intersect(&repaint, &pnode->view->transform.boundingbox, damage); pixman_region32_subtract(&repaint, &repaint, &pnode->view->clip); if (!pixman_region32_not_empty(&repaint)) goto out; if (view_transformation_is_translation(pnode->view)) { /* The simple case: The surface regions opaque, non-opaque, * etc. are convertible to global coordinate space. * There is no need to use a source clip region. * It is possible to paint opaque region as PIXMAN_OP_SRC. * Also the boundingbox is accurate rather than an * approximation. */ draw_view_translated(pnode->view, pnode->output, &repaint); } else { /* The complex case: the view transformation does not allow * converting opaque etc. regions into global coordinate space. * Therefore we need source clipping to avoid sampling from * unwanted source image areas, unless the source image is * to be used whole. Source clipping does not work with * PIXMAN_OP_SRC. */ draw_view_source_clipped(pnode->view, pnode->output, &repaint); } out: pixman_region32_fini(&repaint); } static void repaint_surfaces(struct weston_output *output, pixman_region32_t *damage) { struct weston_compositor *compositor = output->compositor; struct weston_paint_node *pnode; wl_list_for_each_reverse(pnode, &output->paint_node_z_order_list, z_order_link) { if (pnode->view->plane == &compositor->primary_plane) draw_paint_node(pnode, damage); } } static void copy_to_hw_buffer(struct weston_output *output, pixman_region32_t *region) { struct pixman_output_state *po = get_output_state(output); pixman_region32_t output_region; pixman_region32_init(&output_region); pixman_region32_copy(&output_region, region); weston_region_global_to_output(&output_region, output, &output_region); pixman_image_set_clip_region32 (po->hw_buffer, &output_region); pixman_region32_fini(&output_region); pixman_image_composite32(PIXMAN_OP_SRC, po->shadow_image, /* src */ NULL /* mask */, po->hw_buffer, /* dest */ 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ pixman_image_get_width (po->hw_buffer), /* width */ pixman_image_get_height (po->hw_buffer) /* height */); pixman_image_set_clip_region32 (po->hw_buffer, NULL); } static void pixman_renderer_repaint_output(struct weston_output *output, pixman_region32_t *output_damage) { struct pixman_output_state *po = get_output_state(output); pixman_region32_t hw_damage; assert(output->from_blend_to_output_by_backend || output->color_outcome->from_blend_to_output == NULL); if (!po->hw_buffer) { po->hw_extra_damage = NULL; return; } pixman_region32_init(&hw_damage); if (po->hw_extra_damage) { pixman_region32_union(&hw_damage, po->hw_extra_damage, output_damage); po->hw_extra_damage = NULL; } else { pixman_region32_copy(&hw_damage, output_damage); } if (po->shadow_image) { repaint_surfaces(output, output_damage); copy_to_hw_buffer(output, &hw_damage); } else { repaint_surfaces(output, &hw_damage); } pixman_region32_fini(&hw_damage); wl_signal_emit(&output->frame_signal, output_damage); /* Actual flip should be done by caller */ } static void pixman_renderer_flush_damage(struct weston_surface *surface, struct weston_buffer *buffer) { /* No-op for pixman renderer */ } static void buffer_state_handle_buffer_destroy(struct wl_listener *listener, void *data) { struct pixman_surface_state *ps; ps = container_of(listener, struct pixman_surface_state, buffer_destroy_listener); if (ps->image) { pixman_image_unref(ps->image); ps->image = NULL; } ps->buffer_destroy_listener.notify = NULL; } static void pixman_renderer_surface_set_color(struct weston_surface *es, float red, float green, float blue, float alpha) { struct pixman_surface_state *ps = get_surface_state(es); pixman_color_t color; color.red = red * 0xffff; color.green = green * 0xffff; color.blue = blue * 0xffff; color.alpha = alpha * 0xffff; if (ps->image) { pixman_image_unref(ps->image); ps->image = NULL; } ps->image = pixman_image_create_solid_fill(&color); } static void pixman_renderer_attach(struct weston_surface *es, struct weston_buffer *buffer) { struct pixman_surface_state *ps = get_surface_state(es); struct wl_shm_buffer *shm_buffer; const struct pixel_format_info *pixel_info; weston_buffer_reference(&ps->buffer_ref, buffer, buffer ? BUFFER_MAY_BE_ACCESSED : BUFFER_WILL_NOT_BE_ACCESSED); weston_buffer_release_reference(&ps->buffer_release_ref, es->buffer_release_ref.buffer_release); if (ps->buffer_destroy_listener.notify) { wl_list_remove(&ps->buffer_destroy_listener.link); ps->buffer_destroy_listener.notify = NULL; } if (ps->image) { pixman_image_unref(ps->image); ps->image = NULL; } if (!buffer) return; if (buffer->type == WESTON_BUFFER_SOLID) { pixman_renderer_surface_set_color(es, buffer->solid.r, buffer->solid.g, buffer->solid.b, buffer->solid.a); weston_buffer_reference(&ps->buffer_ref, NULL, BUFFER_WILL_NOT_BE_ACCESSED); weston_buffer_release_reference(&ps->buffer_release_ref, NULL); return; } if (buffer->type != WESTON_BUFFER_SHM) { weston_log("Pixman renderer supports only SHM buffers\n"); weston_buffer_reference(&ps->buffer_ref, NULL, BUFFER_WILL_NOT_BE_ACCESSED); weston_buffer_release_reference(&ps->buffer_release_ref, NULL); return; } shm_buffer = buffer->shm_buffer; pixel_info = pixel_format_get_info_shm(wl_shm_buffer_get_format(shm_buffer)); if (!pixel_info || !pixman_format_supported_source(pixel_info->pixman_format)) { weston_log("Unsupported SHM buffer format 0x%x\n", wl_shm_buffer_get_format(shm_buffer)); weston_buffer_reference(&ps->buffer_ref, NULL, BUFFER_WILL_NOT_BE_ACCESSED); weston_buffer_release_reference(&ps->buffer_release_ref, NULL); weston_buffer_send_server_error(buffer, "disconnecting due to unhandled buffer type"); return; } ps->image = pixman_image_create_bits(pixel_info->pixman_format, buffer->width, buffer->height, wl_shm_buffer_get_data(shm_buffer), wl_shm_buffer_get_stride(shm_buffer)); ps->buffer_destroy_listener.notify = buffer_state_handle_buffer_destroy; wl_signal_add(&buffer->destroy_signal, &ps->buffer_destroy_listener); } static void pixman_renderer_surface_state_destroy(struct pixman_surface_state *ps) { wl_list_remove(&ps->surface_destroy_listener.link); wl_list_remove(&ps->renderer_destroy_listener.link); if (ps->buffer_destroy_listener.notify) { wl_list_remove(&ps->buffer_destroy_listener.link); ps->buffer_destroy_listener.notify = NULL; } ps->surface->renderer_state = NULL; if (ps->image) { pixman_image_unref(ps->image); ps->image = NULL; } weston_buffer_reference(&ps->buffer_ref, NULL, BUFFER_WILL_NOT_BE_ACCESSED); weston_buffer_release_reference(&ps->buffer_release_ref, NULL); free(ps); } static void surface_state_handle_surface_destroy(struct wl_listener *listener, void *data) { struct pixman_surface_state *ps; ps = container_of(listener, struct pixman_surface_state, surface_destroy_listener); pixman_renderer_surface_state_destroy(ps); } static void surface_state_handle_renderer_destroy(struct wl_listener *listener, void *data) { struct pixman_surface_state *ps; ps = container_of(listener, struct pixman_surface_state, renderer_destroy_listener); pixman_renderer_surface_state_destroy(ps); } static int pixman_renderer_create_surface(struct weston_surface *surface) { struct pixman_surface_state *ps; struct pixman_renderer *pr = get_renderer(surface->compositor); ps = zalloc(sizeof *ps); if (ps == NULL) return -1; surface->renderer_state = ps; ps->surface = surface; ps->surface_destroy_listener.notify = surface_state_handle_surface_destroy; wl_signal_add(&surface->destroy_signal, &ps->surface_destroy_listener); ps->renderer_destroy_listener.notify = surface_state_handle_renderer_destroy; wl_signal_add(&pr->destroy_signal, &ps->renderer_destroy_listener); return 0; } static void pixman_renderer_destroy(struct weston_compositor *ec) { struct pixman_renderer *pr = get_renderer(ec); wl_signal_emit(&pr->destroy_signal, pr); weston_binding_destroy(pr->debug_binding); free(pr); ec->renderer = NULL; } static int pixman_renderer_surface_copy_content(struct weston_surface *surface, void *target, size_t size, int src_x, int src_y, int width, int height) { const pixman_format_code_t format = PIXMAN_a8b8g8r8; const size_t bytespp = 4; /* PIXMAN_a8b8g8r8 */ struct pixman_surface_state *ps = get_surface_state(surface); pixman_image_t *out_buf; if (!ps->image) return -1; out_buf = pixman_image_create_bits(format, width, height, target, width * bytespp); pixman_image_set_transform(ps->image, NULL); pixman_image_composite32(PIXMAN_OP_SRC, ps->image, /* src */ NULL, /* mask */ out_buf, /* dest */ src_x, src_y, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ width, height); pixman_image_unref(out_buf); return 0; } static bool pixman_renderer_resize_output(struct weston_output *output, const struct weston_size *fb_size, const struct weston_geometry *area) { struct pixman_output_state *po = get_output_state(output); check_compositing_area(fb_size, area); /* * Pixman-renderer does not implement output decorations blitting, * wayland-backend does it on its own. */ assert(area->x == 0); assert(area->y == 0); assert(fb_size->width == area->width); assert(fb_size->height == area->height); pixman_renderer_output_set_buffer(output, NULL); if (!po->shadow_format) return true; if (po->shadow_image) pixman_image_unref(po->shadow_image); po->shadow_image = pixman_image_create_bits_no_clear(po->shadow_format->pixman_format, fb_size->width, fb_size->height, NULL, 0); return !!po->shadow_image; } static void debug_binding(struct weston_keyboard *keyboard, const struct timespec *time, uint32_t key, void *data) { struct weston_compositor *ec = data; struct pixman_renderer *pr = (struct pixman_renderer *) ec->renderer; pr->repaint_debug ^= 1; if (pr->repaint_debug) { pixman_color_t red = { 0x3fff, 0x0000, 0x0000, 0x3fff }; pr->debug_color = pixman_image_create_solid_fill(&red); } else { pixman_image_unref(pr->debug_color); weston_compositor_damage_all(ec); } } WL_EXPORT int pixman_renderer_init(struct weston_compositor *ec) { struct pixman_renderer *renderer; const struct pixel_format_info *pixel_info, *info_argb8888, *info_xrgb8888; unsigned int i, num_formats; renderer = zalloc(sizeof *renderer); if (renderer == NULL) return -1; renderer->repaint_debug = 0; renderer->debug_color = NULL; renderer->base.read_pixels = pixman_renderer_read_pixels; renderer->base.repaint_output = pixman_renderer_repaint_output; renderer->base.resize_output = pixman_renderer_resize_output; renderer->base.flush_damage = pixman_renderer_flush_damage; renderer->base.attach = pixman_renderer_attach; renderer->base.destroy = pixman_renderer_destroy; renderer->base.surface_copy_content = pixman_renderer_surface_copy_content; ec->renderer = &renderer->base; ec->capabilities |= WESTON_CAP_ROTATION_ANY; ec->capabilities |= WESTON_CAP_VIEW_CLIP_MASK; renderer->debug_binding = weston_compositor_add_debug_binding(ec, KEY_R, debug_binding, ec); info_argb8888 = pixel_format_get_info_shm(WL_SHM_FORMAT_ARGB8888); info_xrgb8888 = pixel_format_get_info_shm(WL_SHM_FORMAT_XRGB8888); num_formats = pixel_format_get_info_count(); for (i = 0; i < num_formats; i++) { pixel_info = pixel_format_get_info_by_index(i); if (!pixman_format_supported_source(pixel_info->pixman_format)) continue; /* skip formats which libwayland registers by default */ if (pixel_info == info_argb8888 || pixel_info == info_xrgb8888) continue; wl_display_add_shm_format(ec->wl_display, pixel_info->format); } wl_signal_init(&renderer->destroy_signal); return 0; } WL_EXPORT void pixman_renderer_output_set_buffer(struct weston_output *output, pixman_image_t *buffer) { struct pixman_output_state *po = get_output_state(output); pixman_format_code_t pixman_format; if (po->hw_buffer) pixman_image_unref(po->hw_buffer); po->hw_buffer = buffer; if (po->hw_buffer) { pixman_format = pixman_image_get_format(po->hw_buffer); output->compositor->read_format = pixel_format_get_info_by_pixman(pixman_format); pixman_image_ref(po->hw_buffer); } } WL_EXPORT void pixman_renderer_output_set_hw_extra_damage(struct weston_output *output, pixman_region32_t *extra_damage) { struct pixman_output_state *po = get_output_state(output); po->hw_extra_damage = extra_damage; } WL_EXPORT int pixman_renderer_output_create(struct weston_output *output, const struct pixman_renderer_output_options *options) { struct pixman_output_state *po; struct weston_geometry area = { .x = 0, .y = 0, .width = output->current_mode->width, .height = output->current_mode->height }; struct weston_size fb_size = { .width = area.width, .height = area.height }; po = zalloc(sizeof *po); if (po == NULL) return -1; output->renderer_state = po; if (options->use_shadow) po->shadow_format = pixel_format_get_info(DRM_FORMAT_XRGB8888); if (!pixman_renderer_resize_output(output, &fb_size, &area)) { output->renderer_state = NULL; free(po); return -1; } return 0; } WL_EXPORT void pixman_renderer_output_destroy(struct weston_output *output) { struct pixman_output_state *po = get_output_state(output); if (po->shadow_image) pixman_image_unref(po->shadow_image); if (po->hw_buffer) pixman_image_unref(po->hw_buffer); po->shadow_image = NULL; po->hw_buffer = NULL; free(po); }