mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3035 Commits
1 Branch
0 Tags
13 MiB
Tag: Branch: Tree: 5238b683e2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5238b683e2'
${ noResults }
weston/src/pixman-renderer.c

741 lines
21 KiB
Raw Normal View History Unescape

Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
/*
* Copyright © 2012 Intel Corporation
* Copyright © 2013 Vasily Khoruzhick <anarsoul@gmail.com>
*
* 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.
*/
#define _GNU_SOURCE
#include <errno.h>
#include <stdlib.h>
#include "pixman-renderer.h"
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
#include <linux/input.h>
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
struct pixman_output_state {
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
void *shadow_buffer;
pixman_image_t *shadow_image;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_image_t *hw_buffer;
};
struct pixman_surface_state {
pixman_image_t *image;
struct weston_buffer_reference buffer_ref;
};
struct pixman_renderer {
struct weston_renderer base;
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
int repaint_debug;
pixman_image_t *debug_color;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
};
static inline struct pixman_output_state *
get_output_state(struct weston_output *output)
{
return (struct pixman_output_state *)output->renderer_state;
}
static inline struct pixman_surface_state *
get_surface_state(struct weston_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,
pixman_format_code_t 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-renderer: Fix read_pixels for screen recorder The old code had an off-by-one error on the y coordinate where it says height - (cur_y - y). And it does the vflipping of the *destination* buffer, whereas what is really needed is to vflip the whole source buffer. This only affects when you read out part of the image, such as when using the screen recoder. Also, instead of doing the flipping manually we just let pixman handle it.
11 years ago
pixman_transform_t transform;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_image_t *out_buf;
if (!po->hw_buffer) {
errno = ENODEV;
return -1;
}
out_buf = pixman_image_create_bits(format,
width,
height,
pixels,
(PIXMAN_FORMAT_BPP(format) / 8) * width);
pixman-renderer: Fix read_pixels for screen recorder The old code had an off-by-one error on the y coordinate where it says height - (cur_y - y). And it does the vflipping of the *destination* buffer, whereas what is really needed is to vflip the whole source buffer. This only affects when you read out part of the image, such as when using the screen recoder. Also, instead of doing the flipping manually we just let pixman handle it.
11 years ago
/* Caller expects vflipped source image */
pixman_transform_init_translate(&transform,
pixman_int_to_fixed (x),
pixman_int_to_fixed (y - pixman_image_get_height (po->hw_buffer)));
pixman_transform_scale(&transform, NULL,
pixman_fixed_1,
pixman_fixed_minus_1);
pixman_image_set_transform(po->hw_buffer, &transform);
pixman_image_composite32(PIXMAN_OP_SRC,
po->hw_buffer, /* src */
NULL /* mask */,
out_buf, /* 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_transform(po->hw_buffer, NULL);
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_image_unref(out_buf);
return 0;
}
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
static void
box_scale(pixman_box32_t *dst, int scale)
{
dst->x1 *= scale;
dst->x2 *= scale;
dst->y1 *= scale;
dst->y2 *= scale;
}
static void
scale_region (pixman_region32_t *region, int scale)
{
pixman_box32_t *rects, *scaled_rects;
int nrects, i;
if (scale != 1) {
rects = pixman_region32_rectangles(region, &nrects);
scaled_rects = calloc(nrects, sizeof(pixman_box32_t));
for (i = 0; i < nrects; i++) {
scaled_rects[i] = rects[i];
box_scale(&scaled_rects[i], scale);
}
pixman_region32_clear(region);
pixman_region32_init_rects (region, scaled_rects, nrects);
free (scaled_rects);
}
}
pixman renderer: respect output position Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
static void
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
transform_region (pixman_region32_t *region, int width, int height, enum wl_output_transform transform)
pixman renderer: respect output position Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
{
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_box32_t *rects, *transformed_rects;
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
int nrects, i;
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
if (transform == WL_OUTPUT_TRANSFORM_NORMAL)
return;
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
rects = pixman_region32_rectangles(region, &nrects);
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
transformed_rects = calloc(nrects, sizeof(pixman_box32_t));
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
for (i = 0; i < nrects; i++) {
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
switch (transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
transformed_rects[i].x1 = rects[i].x1;
transformed_rects[i].y1 = rects[i].y1;
transformed_rects[i].x2 = rects[i].x2;
transformed_rects[i].y2 = rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_90:
transformed_rects[i].x1 = height - rects[i].y2;
transformed_rects[i].y1 = rects[i].x1;
transformed_rects[i].x2 = height - rects[i].y1;
transformed_rects[i].y2 = rects[i].x2;
break;
case WL_OUTPUT_TRANSFORM_180:
transformed_rects[i].x1 = width - rects[i].x2;
transformed_rects[i].y1 = height - rects[i].y2;
transformed_rects[i].x2 = width - rects[i].x1;
transformed_rects[i].y2 = height - rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_270:
transformed_rects[i].x1 = rects[i].y1;
transformed_rects[i].y1 = width - rects[i].x2;
transformed_rects[i].x2 = rects[i].y2;
transformed_rects[i].y2 = width - rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
transformed_rects[i].x1 = width - rects[i].x2;
transformed_rects[i].y1 = rects[i].y1;
transformed_rects[i].x2 = width - rects[i].x1;
transformed_rects[i].y2 = rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
transformed_rects[i].x1 = height - rects[i].y2;
transformed_rects[i].y1 = width - rects[i].x2;
transformed_rects[i].x2 = height - rects[i].y1;
transformed_rects[i].y2 = width - rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
transformed_rects[i].x1 = rects[i].x1;
transformed_rects[i].y1 = height - rects[i].y2;
transformed_rects[i].x2 = rects[i].x2;
transformed_rects[i].y2 = height - rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
transformed_rects[i].x1 = rects[i].y1;
transformed_rects[i].y1 = rects[i].x1;
transformed_rects[i].x2 = rects[i].y2;
transformed_rects[i].y2 = rects[i].x2;
break;
}
}
pixman_region32_clear(region);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_region32_init_rects (region, transformed_rects, nrects);
free (transformed_rects);
}
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
static void
region_global_to_output(struct weston_output *output, pixman_region32_t *region)
{
pixman_region32_translate(region, -output->x, -output->y);
transform_region (region, output->width, output->height, output->transform);
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
scale_region (region, output->scale);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
#define D2F(v) pixman_double_to_fixed((double)v)
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
static void
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
repaint_region(struct weston_surface *es, struct weston_output *output,
pixman_region32_t *region, pixman_region32_t *surf_region,
pixman_op_t pixman_op)
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
{
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
struct pixman_renderer *pr =
(struct pixman_renderer *) output->compositor->renderer;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
struct pixman_surface_state *ps = get_surface_state(es);
struct pixman_output_state *po = get_output_state(output);
pixman_region32_t final_region;
float surface_x, surface_y;
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_transform_t transform;
pixman_fixed_t fw, fh;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
/* The final region to be painted is the intersection of
* 'region' and 'surf_region'. However, 'region' is in the global
* coordinates, and 'surf_region' is in the surface-local
* coordinates
*/
pixman_region32_init(&final_region);
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
if (surf_region) {
pixman_region32_copy(&final_region, surf_region);
/* Convert from surface to global coordinates */
if (!es->transform.enabled) {
pixman_region32_translate(&final_region, es->geometry.x, es->geometry.y);
} else {
weston_surface_to_global_float(es, 0, 0, &surface_x, &surface_y);
pixman_region32_translate(&final_region, (int)surface_x, (int)surface_y);
}
/* We need to paint the intersection */
pixman_region32_intersect(&final_region, &final_region, region);
} else {
/* If there is no surface region, just use the global region */
pixman_region32_copy(&final_region, region);
}
/* Convert from global to output coord */
region_global_to_output(output, &final_region);
/* And clip to it */
pixman_image_set_clip_region32 (po->shadow_image, &final_region);
/* Set up the source transformation based on the surface
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
position, the output position/transform/scale and the client
specified buffer transform/scale */
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_transform_init_identity(&transform);
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed ((double)1.0/output->scale),
pixman_double_to_fixed ((double)1.0/output->scale));
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
fw = pixman_int_to_fixed(output->width);
fh = pixman_int_to_fixed(output->height);
switch (output->transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fh);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
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:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed (output->x),
pixman_double_to_fixed (output->y));
if (es->transform.enabled) {
/* Pixman supports only 2D transform matrix, but Weston uses 3D,
* so we're omitting Z coordinate here
*/
pixman_transform_t surface_transform = {{
{ D2F(es->transform.matrix.d[0]),
D2F(es->transform.matrix.d[4]),
D2F(es->transform.matrix.d[12]),
},
{ D2F(es->transform.matrix.d[1]),
D2F(es->transform.matrix.d[5]),
D2F(es->transform.matrix.d[13]),
},
{ D2F(es->transform.matrix.d[3]),
D2F(es->transform.matrix.d[7]),
D2F(es->transform.matrix.d[15]),
}
}};
pixman_transform_invert(&surface_transform, &surface_transform);
pixman_transform_multiply (&transform, &surface_transform, &transform);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
} else {
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed ((double)-es->geometry.x),
pixman_double_to_fixed ((double)-es->geometry.y));
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
fw = pixman_int_to_fixed(es->geometry.width);
fh = pixman_int_to_fixed(es->geometry.height);
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
switch (es->buffer_transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
switch (es->buffer_transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fh, 0);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fw);
break;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed ((double)es->buffer_scale),
pixman_double_to_fixed ((double)es->buffer_scale));
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_image_set_transform(ps->image, &transform);
compositor: Support output/buffer scaling If you specify e.g. scale=2 in weston.ini an output section for the X11 backend we automatically upscale all normal surfaces by this amount. Additionally we respect a buffer_scale set on the buffer to mean that the buffer is already in a scaled form. This works with both the gl and the pixman renderer. The non-X backends compile and work, but don't support changing the output scale (they do downscale as needed due to buffer_scale though). This also sends the new "scale" and "done" events on wl_output, making clients aware of the scale.
11 years ago
if (es->transform.enabled || output->scale != es->buffer_scale)
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_image_set_filter(ps->image, PIXMAN_FILTER_BILINEAR, NULL, 0);
else
pixman_image_set_filter(ps->image, PIXMAN_FILTER_NEAREST, NULL, 0);
pixman_image_composite32(pixman_op,
ps->image, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
if (pr->repaint_debug)
pixman_image_composite32(PIXMAN_OP_OVER,
pr->debug_color, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
pixman_image_set_clip_region32 (po->shadow_image, NULL);
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_region32_fini(&final_region);
}
static void
draw_surface(struct weston_surface *es, struct weston_output *output,
pixman_region32_t *damage) /* in global coordinates */
{
struct pixman_surface_state *ps = get_surface_state(es);
/* repaint bounding region in global coordinates: */
pixman_region32_t repaint;
/* non-opaque region in surface coordinates: */
pixman_region32_t surface_blend;
/* No buffer attached */
if (!ps->image)
return;
pixman_region32_init(&repaint);
pixman_region32_intersect(&repaint,
&es->transform.boundingbox, damage);
pixman_region32_subtract(&repaint, &repaint, &es->clip);
if (!pixman_region32_not_empty(&repaint))
goto out;
if (output->zoom.active) {
weston_log("pixman renderer does not support zoom\n");
goto out;
}
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
/* TODO: Implement repaint_region_complex() using pixman_composite_trapezoids() */
if (es->transform.enabled &&
es->transform.matrix.type != WESTON_MATRIX_TRANSFORM_TRANSLATE) {
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
repaint_region(es, output, &repaint, NULL, PIXMAN_OP_OVER);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
} else {
/* blended region is whole surface minus opaque region: */
pixman_region32_init_rect(&surface_blend, 0, 0,
es->geometry.width, es->geometry.height);
pixman_region32_subtract(&surface_blend, &surface_blend, &es->opaque);
if (pixman_region32_not_empty(&es->opaque)) {
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
repaint_region(es, output, &repaint, &es->opaque, PIXMAN_OP_SRC);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
if (pixman_region32_not_empty(&surface_blend)) {
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
repaint_region(es, output, &repaint, &surface_blend, PIXMAN_OP_OVER);
pixman-renderer: handle surface transform matrix properly Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
pixman_region32_fini(&surface_blend);
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
}
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_surface *surface;
wl_list_for_each_reverse(surface, &compositor->surface_list, link)
if (surface->plane == &compositor->primary_plane)
draw_surface(surface, output, damage);
}
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
static void
copy_to_hw_buffer(struct weston_output *output, pixman_region32_t *region)
{
struct pixman_output_state *po = get_output_state(output);
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_region32_t output_region;
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_region32_init(&output_region);
pixman_region32_copy(&output_region, region);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
region_global_to_output(output, &output_region);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_image_set_clip_region32 (po->hw_buffer, &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-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
pixman-renderer: Fix up transform handling Rather than storing the shadow_image in the untransformed space and rotating on copy to hw_buffer we store both on the transformed space. This means a copy between them is a straight copy, and that apps supplying correctly transformed surface buffers need not change them. We also correctly handle all output transform including the previously unhandled flipped ones, as well as client supplied buffer_transforms (which were previously ignored). We also simplify the actual rendering by just converting any damage region to output coordinates and set it on a clip and composite the whole buffer, letting pixman do the rectangle handling. This means we always do all the transforms, including the surface positioning as a pixman_image transform. This simplifies the code and sets us up for handling scaling at a later stage. The transform looks complicated, but in practice it ends up being an integer translation almost always, so it will hit the pixman fastpaths.
11 years ago
pixman_image_set_clip_region32 (po->hw_buffer, NULL);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
}
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
static void
pixman_renderer_repaint_output(struct weston_output *output,
pixman_region32_t *output_damage)
{
struct pixman_output_state *po = get_output_state(output);
if (!po->hw_buffer)
return;
repaint_surfaces(output, output_damage);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
copy_to_hw_buffer(output, output_damage);
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_region32_copy(&output->previous_damage, output_damage);
wl_signal_emit(&output->frame_signal, output);
/* Actual flip should be done by caller */
}
static void
pixman_renderer_flush_damage(struct weston_surface *surface)
{
/* No-op for pixman renderer */
}
static void
pixman_renderer_attach(struct weston_surface *es, struct wl_buffer *buffer)
{
struct pixman_surface_state *ps = get_surface_state(es);
pixman_format_code_t pixman_format;
weston_buffer_reference(&ps->buffer_ref, buffer);
if (ps->image) {
pixman_image_unref(ps->image);
ps->image = NULL;
}
if (!buffer)
return;
if (!wl_buffer_is_shm(buffer)) {
weston_log("Pixman renderer supports only SHM buffers\n");
weston_buffer_reference(&ps->buffer_ref, NULL);
return;
}
switch (wl_shm_buffer_get_format(buffer)) {
case WL_SHM_FORMAT_XRGB8888:
pixman_format = PIXMAN_x8r8g8b8;
break;
case WL_SHM_FORMAT_ARGB8888:
pixman_format = PIXMAN_a8r8g8b8;
break;
default:
weston_log("Unsupported SHM buffer format\n");
weston_buffer_reference(&ps->buffer_ref, NULL);
return;
break;
}
ps->image = pixman_image_create_bits(pixman_format,
wl_shm_buffer_get_width(buffer),
wl_shm_buffer_get_height(buffer),
wl_shm_buffer_get_data(buffer),
wl_shm_buffer_get_stride(buffer));
}
static int
pixman_renderer_create_surface(struct weston_surface *surface)
{
struct pixman_surface_state *ps;
ps = calloc(1, sizeof *ps);
if (!ps)
return -1;
surface->renderer_state = ps;
return 0;
}
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_destroy_surface(struct weston_surface *surface)
{
struct pixman_surface_state *ps = get_surface_state(surface);
if (ps->image) {
pixman_image_unref(ps->image);
ps->image = NULL;
}
weston_buffer_reference(&ps->buffer_ref, NULL);
free(ps);
}
renderer: introduce destroy callback Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
static void
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
pixman_renderer_destroy(struct weston_compositor *ec)
{
free(ec->renderer);
ec->renderer = NULL;
}
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
static void
input: Merge wl_seat into weston_seat
12 years ago
debug_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
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);
}
}
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
WL_EXPORT int
pixman_renderer_init(struct weston_compositor *ec)
{
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
struct pixman_renderer *renderer;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
renderer = malloc(sizeof *renderer);
if (renderer == NULL)
return -1;
pixman-renderer: don't forget to initialize the debug fields Fixes https://bugs.freedesktop.org/show_bug.cgi?id=61930
12 years ago
renderer->repaint_debug = 0;
renderer->debug_color = NULL;
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
renderer->base.read_pixels = pixman_renderer_read_pixels;
renderer->base.repaint_output = pixman_renderer_repaint_output;
renderer->base.flush_damage = pixman_renderer_flush_damage;
renderer->base.attach = pixman_renderer_attach;
renderer->base.create_surface = pixman_renderer_create_surface;
renderer->base.surface_set_color = pixman_renderer_surface_set_color;
renderer->base.destroy_surface = pixman_renderer_destroy_surface;
renderer->base.destroy = pixman_renderer_destroy;
ec->renderer = &renderer->base;
compositor: add capability flag for arbitrary surface rotation The upcoming rpi-renderer cannot handle arbitrary rotations. Introduce Weston capability bits, and add a bit for arbitrary rotation. GL and Pixman renderers support it. Shell or any other module must not produce surface transformations with rotation, if the capability bit is not set. Do not register the surface rotation binding in desktop shell, if arbitary rotation is not supported. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
11 years ago
ec->capabilities |= WESTON_CAP_ROTATION_ANY;
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>
11 years ago
ec->capabilities |= WESTON_CAP_CAPTURE_YFLIP;
pixman-renderer: Add repaint debugging feature Add 'R' as a debug shortcut that highlights repainted regions.
12 years ago
weston_compositor_add_debug_binding(ec, KEY_R,
debug_binding, ec);
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
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);
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
po->hw_buffer = buffer;
if (po->hw_buffer) {
output->compositor->read_format = pixman_image_get_format(po->hw_buffer);
pixman_image_ref(po->hw_buffer);
}
}
WL_EXPORT int
pixman_renderer_output_create(struct weston_output *output)
{
struct pixman_output_state *po = calloc(1, sizeof *po);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
int w, h;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
if (!po)
return -1;
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
/* set shadow image transformation */
compositor: Store modes in physical units We changed the protocol to always list modes in physical pixel units (not scaled). And we removed the scaled mode flag. This just updates the DRM and X11 compositors and the gl and pixman renderers to handle this.
11 years ago
w = output->current->width;
h = output->current->height;
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
po->shadow_buffer = malloc(w * h * 4);
if (!po->shadow_buffer) {
free(po);
return -1;
}
po->shadow_image =
pixman_image_create_bits(PIXMAN_x8r8g8b8, w, h,
po->shadow_buffer, w * 4);
if (!po->shadow_image) {
free(po->shadow_buffer);
free(po);
return -1;
}
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
output->renderer_state = po;
return 0;
}
WL_EXPORT void
pixman_renderer_output_destroy(struct weston_output *output)
{
struct pixman_output_state *po = get_output_state(output);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
pixman_image_unref(po->shadow_image);
pixman-renderer: Don't unreference NULL hw_buffer image If the buffer for an output was never set, or was reset to NULL at some point, destroying the renderer output private would cause a crash.
12 years ago
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
pixman-renderer: Move shadow buffer into renderer The X11 backend uses a shadow buffer to be able to support transformed outputs. However, this belongs in the renderer, since otherwise this code would have to be copied into every backend that uses the pixman renderer and supports transformed outputs.
12 years ago
po->shadow_image = NULL;
Implement pixman renderer This renderer could be used when there's no graphic accelerator available, for example in (future) KMS and fbdev backends. Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
12 years ago
po->hw_buffer = NULL;
free(po);
}