CoglBool
cogl_wayland_texture_set_region_from_shm_buffer (CoglTexture *texture,
int src_x,
int src_y,
int width,
int height,
struct wl_shm_buffer *
shm_buffer,
int dst_x,
int dst_y,
int level,
CoglError **error)
{
const uint8_t *data = wl_shm_buffer_get_data (shm_buffer);
int32_t stride = wl_shm_buffer_get_stride (shm_buffer);
CoglPixelFormat format;
int bpp;
shm_buffer_get_cogl_pixel_format (shm_buffer, &format, NULL);
bpp = _cogl_pixel_format_get_bytes_per_pixel (format);
return _cogl_texture_set_region (COGL_TEXTURE (texture),
width, height,
format,
stride,
data + src_x * bpp + src_y * stride,
dst_x, dst_y,
level,
error);
}
static gboolean
process_shm_buffer_damage (MetaWaylandBuffer *buffer,
CoglTexture *texture,
cairo_region_t *region,
GError **error)
{
struct wl_shm_buffer *shm_buffer;
int i, n_rectangles;
gboolean set_texture_failed = FALSE;
n_rectangles = cairo_region_num_rectangles (region);
shm_buffer = wl_shm_buffer_get (buffer->resource);
wl_shm_buffer_begin_access (shm_buffer);
for (i = 0; i < n_rectangles; i++)
{
const uint8_t *data = wl_shm_buffer_get_data (shm_buffer);
int32_t stride = wl_shm_buffer_get_stride (shm_buffer);
CoglPixelFormat format;
int bpp;
cairo_rectangle_int_t rect;
shm_buffer_get_cogl_pixel_format (shm_buffer, &format, NULL);
bpp = _cogl_pixel_format_get_bytes_per_pixel (format);
cairo_region_get_rectangle (region, i, &rect);
if (!_cogl_texture_set_region (texture,
rect.width, rect.height,
format,
stride,
data + rect.x * bpp + rect.y * stride,
rect.x, rect.y,
0,
error))
{
set_texture_failed = TRUE;
break;
}
}
wl_shm_buffer_end_access (shm_buffer);
return !set_texture_failed;
}
static void
_cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
{
CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
Display *display;
Visual *visual;
CoglPixelFormat image_format;
XImage *image;
int src_x, src_y;
int x, y, width, height;
int bpp;
int offset;
CoglError *ignore = NULL;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
display = cogl_xlib_renderer_get_display (ctx->display->renderer);
visual = tex_pixmap->visual;
/* If the damage region is empty then there's nothing to do */
if (tex_pixmap->damage_rect.x2 == tex_pixmap->damage_rect.x1)
return;
x = tex_pixmap->damage_rect.x1;
y = tex_pixmap->damage_rect.y1;
width = tex_pixmap->damage_rect.x2 - x;
height = tex_pixmap->damage_rect.y2 - y;
/* We lazily create the texture the first time it is needed in case
this texture can be entirely handled using the GLX texture
instead */
if (tex_pixmap->tex == NULL)
{
CoglPixelFormat texture_format;
texture_format = (tex_pixmap->depth >= 32
? COGL_PIXEL_FORMAT_RGBA_8888_PRE
: COGL_PIXEL_FORMAT_RGB_888);
tex_pixmap->tex = create_fallback_texture (ctx,
tex->width,
tex->height,
texture_format);
}
if (tex_pixmap->image == NULL)
{
/* If we also haven't got a shm segment then this must be the
first time we've tried to update, so lets try allocating shm
first */
if (tex_pixmap->shm_info.shmid == -1)
try_alloc_shm (tex_pixmap);
if (tex_pixmap->shm_info.shmid == -1)
{
COGL_NOTE (TEXTURE_PIXMAP, "Updating %p using XGetImage", tex_pixmap);
/* We'll fallback to using a regular XImage. We'll download
the entire area instead of a sub region because presumably
if this is the first update then the entire pixmap is
needed anyway and it saves trying to manually allocate an
XImage at the right size */
tex_pixmap->image = XGetImage (display,
tex_pixmap->pixmap,
0, 0,
tex->width, tex->height,
AllPlanes, ZPixmap);
image = tex_pixmap->image;
src_x = x;
src_y = y;
}
else
{
COGL_NOTE (TEXTURE_PIXMAP, "Updating %p using XShmGetImage",
tex_pixmap);
/* Create a temporary image using the beginning of the
shared memory segment and the right size for the region
we want to update. We need to reallocate the XImage every
time because there is no XShmGetSubImage. */
image = XShmCreateImage (display,
tex_pixmap->visual,
tex_pixmap->depth,
ZPixmap,
NULL,
&tex_pixmap->shm_info,
width,
height);
image->data = tex_pixmap->shm_info.shmaddr;
src_x = 0;
src_y = 0;
XShmGetImage (display, tex_pixmap->pixmap, image, x, y, AllPlanes);
}
}
else
{
COGL_NOTE (TEXTURE_PIXMAP, "Updating %p using XGetSubImage", tex_pixmap);
image = tex_pixmap->image;
src_x = x;
src_y = y;
XGetSubImage (display,
tex_pixmap->pixmap,
x, y, width, height,
AllPlanes, ZPixmap,
image,
x, y);
}
image_format =
_cogl_util_pixel_format_from_masks (visual->red_mask,
visual->green_mask,
visual->blue_mask,
image->depth,
image->bits_per_pixel,
image->byte_order == LSBFirst);
bpp = _cogl_pixel_format_get_bytes_per_pixel (image_format);
offset = image->bytes_per_line * src_y + bpp * src_x;
_cogl_texture_set_region (tex_pixmap->tex,
width,
height,
image_format,
image->bytes_per_line,
((const uint8_t *) image->data) + offset,
x, y,
0, /* level */
&ignore);
/* If we have a shared memory segment then the XImage would be a
temporary one with no data allocated so we can just XFree it */
if (tex_pixmap->shm_info.shmid != -1)
XFree (image);
memset (&tex_pixmap->damage_rect, 0, sizeof (CoglDamageRectangle));
}
