/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
/* cairo - a vector graphics library with display and print output
*
* Copyright © 2002 University of Southern California
* Copyright © 2005 Red Hat, Inc.
* Copyright © 2011 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it either under the terms of the GNU Lesser General Public
* License version 2.1 as published by the Free Software Foundation
* (the "LGPL") or, at your option, under the terms of the Mozilla
* Public License Version 1.1 (the "MPL"). If you do not alter this
* notice, a recipient may use your version of this file under either
* the MPL or the LGPL.
*
* You should have received a copy of the LGPL along with this library
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
* You should have received a copy of the MPL along with this library
* in the file COPYING-MPL-1.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
* the specific language governing rights and limitations.
*
* The Original Code is the cairo graphics library.
*
* The Initial Developer of the Original Code is University of Southern
* California.
*
* Contributor(s):
* Carl D. Worth <cworth@cworth.org>
* Behdad Esfahbod <behdad@behdad.org>
* Chris Wilson <chris@chris-wilson.co.uk>
* Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation
*/
#include "cairoint.h"
#if !CAIRO_HAS_XLIB_XCB_FUNCTIONS
#include "cairo-xlib-private.h"
#include "cairo-compositor-private.h"
#include "cairo-damage-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-list-inline.h"
#include "cairo-pattern-private.h"
#include "cairo-traps-private.h"
#include "cairo-tristrip-private.h"
static cairo_int_status_t
acquire (void *abstract_dst)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_int_status_t status;
status = _cairo_xlib_display_acquire (dst->base.device, &dst->display);
if (unlikely (status))
return status;
dst->dpy = dst->display->display;
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
release (void *abstract_dst)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_device_release (&dst->display->base);
dst->dpy = NULL;
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
set_clip_region (void *_surface,
cairo_region_t *region)
{
cairo_xlib_surface_t *surface = _surface;
_cairo_xlib_surface_ensure_picture (surface);
if (region != NULL) {
XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (sizeof (XRectangle))];
XRectangle *rects = stack_rects;
int n_rects, i;
n_rects = cairo_region_num_rectangles (region);
if (n_rects > ARRAY_LENGTH (stack_rects)) {
rects = _cairo_malloc_ab (n_rects, sizeof (XRectangle));
if (unlikely (rects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
for (i = 0; i < n_rects; i++) {
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (region, i, &rect);
rects[i].x = rect.x;
rects[i].y = rect.y;
rects[i].width = rect.width;
rects[i].height = rect.height;
}
XRenderSetPictureClipRectangles (surface->dpy,
surface->picture,
0, 0,
rects, n_rects);
if (rects != stack_rects)
free (rects);
} else {
XRenderPictureAttributes pa;
pa.clip_mask = None;
XRenderChangePicture (surface->dpy,
surface->picture,
CPClipMask, &pa);
}
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
copy_image_boxes (void *_dst,
cairo_image_surface_t *image,
cairo_boxes_t *boxes,
int dx, int dy)
{
cairo_xlib_surface_t *dst = _dst;
struct _cairo_boxes_chunk *chunk;
cairo_int_status_t status;
Pixmap src;
GC gc;
int i, j;
assert (image->depth == dst->depth);
status = acquire (dst);
if (unlikely (status))
return status;
status = _cairo_xlib_surface_get_gc (dst->display, dst, &gc);
if (unlikely (status)) {
release (dst);
return status;
}
src = _cairo_xlib_shm_surface_get_pixmap (&image->base);
if (boxes->num_boxes == 1) {
int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x);
int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y);
int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x);
int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y);
XCopyArea (dst->dpy, src, dst->drawable, gc,
x1 + dx, y1 + dy,
x2 - x1, y2 - y1,
x1, y1);
} else {
XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)];
XRectangle *rects = stack_rects;
if (boxes->num_boxes > ARRAY_LENGTH (stack_rects)) {
rects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle));
if (unlikely (rects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
j = 0;
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
if (x2 > x1 && y2 > y1) {
rects[j].x = x1;
rects[j].y = y1;
rects[j].width = x2 - x1;
rects[j].height = y2 - y1;
j++;
}
}
}
XSetClipRectangles (dst->dpy, gc, 0, 0, rects, j, Unsorted);
XCopyArea (dst->dpy, src, dst->drawable, gc,
0, 0, image->width, image->height, -dx, -dy);
XSetClipMask (dst->dpy, gc, None);
if (rects != stack_rects)
free (rects);
}
_cairo_xlib_shm_surface_mark_active (&image->base);
_cairo_xlib_surface_put_gc (dst->display, dst, gc);
release (dst);
return CAIRO_STATUS_SUCCESS;
}
static cairo_bool_t
boxes_cover_surface (cairo_boxes_t *boxes,
cairo_xlib_surface_t *surface)
{
cairo_box_t *b;
if (boxes->num_boxes != 1)
return FALSE;
b = &boxes->chunks.base[0];
if (_cairo_fixed_integer_part (b->p1.x) > 0 ||
_cairo_fixed_integer_part (b->p1.y) > 0)
return FALSE;
if (_cairo_fixed_integer_part (b->p2.x) < surface->width ||
_cairo_fixed_integer_part (b->p2.y) < surface->height)
return FALSE;
return TRUE;
}
static cairo_int_status_t
draw_image_boxes (void *_dst,
cairo_image_surface_t *image,
cairo_boxes_t *boxes,
int dx, int dy)
{
cairo_xlib_surface_t *dst = _dst;
struct _cairo_boxes_chunk *chunk;
cairo_image_surface_t *shm;
cairo_int_status_t status;
int i;
if (image->base.device == dst->base.device &&
image->depth == dst->depth &&
_cairo_xlib_shm_surface_get_pixmap (&image->base))
return copy_image_boxes (dst, image, boxes, dx, dy);
shm = NULL;
if (boxes_cover_surface (boxes, dst))
shm = (cairo_image_surface_t *) _cairo_xlib_surface_get_shm (dst, TRUE);
if (shm) {
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
cairo_box_t *b = &chunk->base[i];
cairo_rectangle_int_t r;
r.x = _cairo_fixed_integer_part (b->p1.x);
r.y = _cairo_fixed_integer_part (b->p1.y);
r.width = _cairo_fixed_integer_part (b->p2.x) - r.x;
r.height = _cairo_fixed_integer_part (b->p2.y) - r.y;
if (shm->pixman_format != image->pixman_format ||
! pixman_blt ((uint32_t *)image->data, (uint32_t *)shm->data,
image->stride / sizeof (uint32_t),
shm->stride / sizeof (uint32_t),
PIXMAN_FORMAT_BPP (image->pixman_format),
PIXMAN_FORMAT_BPP (shm->pixman_format),
r.x + dx, r.y + dy,
r.x, r.y,
r.width, r.height))
{
pixman_image_composite32 (PIXMAN_OP_SRC,
image->pixman_image, NULL, shm->pixman_image,
r.x + dx, r.y + dy,
0, 0,
r.x, r.y,
r.width, r.height);
}
shm->base.damage =
_cairo_damage_add_rectangle (shm->base.damage, &r);
}
}
dst->base.is_clear = FALSE;
dst->fallback++;
dst->base.serial++;
return CAIRO_INT_STATUS_NOTHING_TO_DO;
}
if (image->depth == dst->depth &&
((cairo_xlib_display_t *)dst->display)->shm) {
cairo_box_t extents;
cairo_rectangle_int_t r;
_cairo_boxes_extents (boxes, &extents);
_cairo_box_round_to_rectangle (&extents, &r);
shm = (cairo_image_surface_t *)
_cairo_xlib_surface_create_shm (dst, image->pixman_format,
r.width, r.height);
if (shm) {
int tx = -r.x, ty = -r.y;
assert (shm->pixman_format == image->pixman_format);
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
cairo_box_t *b = &chunk->base[i];
r.x = _cairo_fixed_integer_part (b->p1.x);
r.y = _cairo_fixed_integer_part (b->p1.y);
r.width = _cairo_fixed_integer_part (b->p2.x) - r.x;
r.height = _cairo_fixed_integer_part (b->p2.y) - r.y;
if (! pixman_blt ((uint32_t *)image->data, (uint32_t *)shm->data,
image->stride / sizeof (uint32_t),
shm->stride / sizeof (uint32_t),
PIXMAN_FORMAT_BPP (image->pixman_format),
PIXMAN_FORMAT_BPP (shm->pixman_format),
r.x + dx, r.y + dy,
r.x + tx, r.y + ty,
r.width, r.height))
{
pixman_image_composite32 (PIXMAN_OP_SRC,
image->pixman_image, NULL, shm->pixman_image,
r.x + dx, r.y + dy,
0, 0,
r.x + tx, r.y + ty,
r.width, r.height);
}
}
}
dx = tx;
dy = ty;
image = shm;
if (_cairo_xlib_shm_surface_get_pixmap (&image->base)) {
status = copy_image_boxes (dst, image, boxes, dx, dy);
if (status != CAIRO_INT_STATUS_UNSUPPORTED)
goto out;
}
}
}
status = CAIRO_STATUS_SUCCESS;
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
cairo_box_t *b = &chunk->base[i];
int x1 = _cairo_fixed_integer_part (b->p1.x);
int y1 = _cairo_fixed_integer_part (b->p1.y);
int x2 = _cairo_fixed_integer_part (b->p2.x);
int y2 = _cairo_fixed_integer_part (b->p2.y);
if ( _cairo_xlib_surface_draw_image (dst, image,
x1 + dx, y1 + dy,
x2 - x1, y2 - y1,
x1, y1)) {
status = CAIRO_INT_STATUS_UNSUPPORTED;
goto out;
}
}
}
out:
cairo_surface_destroy (&shm->base);
return status;
}
static cairo_int_status_t
copy_boxes (void *_dst,
cairo_surface_t *_src,
cairo_boxes_t *boxes,
const cairo_rectangle_int_t *extents,
int dx, int dy)
{
cairo_xlib_surface_t *dst = _dst;
cairo_xlib_surface_t *src = (cairo_xlib_surface_t *)_src;
struct _cairo_boxes_chunk *chunk;
cairo_int_status_t status;
GC gc;
Drawable d;
int i, j;
if (! _cairo_xlib_surface_same_screen (dst, src))
return CAIRO_INT_STATUS_UNSUPPORTED;
if (dst->depth != src->depth)
return CAIRO_INT_STATUS_UNSUPPORTED;
status = acquire (dst);
if (unlikely (status))
return status;
status = _cairo_xlib_surface_get_gc (dst->display, dst, &gc);
if (unlikely (status)) {
release (dst);
return status;
}
if (src->fallback && src->shm->damage->dirty) {
assert (src != dst);
d = _cairo_xlib_shm_surface_get_pixmap (src->shm);
assert (d != 0);
} else {
if (! src->owns_pixmap) {
XGCValues gcv;
gcv.subwindow_mode = IncludeInferiors;
XChangeGC (dst->display->display, gc, GCSubwindowMode, &gcv);
}
d = src->drawable;
}
if (boxes->num_boxes == 1) {
int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x);
int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y);
int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x);
int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y);
XCopyArea (dst->dpy, d, dst->drawable, gc,
x1 + dx, y1 + dy,
x2 - x1, y2 - y1,
x1, y1);
} else {
/* We can only have a single control for subwindow_mode on the
* GC. If we have a Window destination, we need to set ClipByChildren,
* but if we have a Window source, we need IncludeInferiors. If we have
* both a Window destination and source, we must fallback. There is
* no convenient way to detect if a drawable is a Pixmap or Window,
* therefore we can only rely on those surfaces that we created
* ourselves to be Pixmaps, and treat everything else as a potential
* Window.
*/
if (src == dst || (!src->owns_pixmap && !dst->owns_pixmap)) {
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
XCopyArea (dst->dpy, d, dst->drawable, gc,
x1 + dx, y1 + dy,
x2 - x1, y2 - y1,
x1, y1);
}
}
} else {
XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)];
XRectangle *rects = stack_rects;
if (boxes->num_boxes > ARRAY_LENGTH (stack_rects)) {
rects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle));
if (unlikely (rects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
j = 0;
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
rects[j].x = x1;
rects[j].y = y1;
rects[j].width = x2 - x1;
rects[j].height = y2 - y1;
j++;
}
}
assert (j == boxes->num_boxes);
XSetClipRectangles (dst->dpy, gc, 0, 0, rects, j, Unsorted);
XCopyArea (dst->dpy, d, dst->drawable, gc,
extents->x + dx, extents->y + dy,
extents->width, extents->height,
extents->x, extents->y);
XSetClipMask (dst->dpy, gc, None);
if (rects != stack_rects)
free (rects);
}
}
if (src->fallback && src->shm->damage->dirty) {
_cairo_xlib_shm_surface_mark_active (src->shm);
} else if (! src->owns_pixmap) {
XGCValues gcv;
gcv.subwindow_mode = ClipByChildren;
XChangeGC (dst->display->display, gc, GCSubwindowMode, &gcv);
}
_cairo_xlib_surface_put_gc (dst->display, dst, gc);
release (dst);
return CAIRO_STATUS_SUCCESS;
}
static int
_render_operator (cairo_operator_t op)
{
switch (op) {
case CAIRO_OPERATOR_CLEAR:
return PictOpClear;
case CAIRO_OPERATOR_SOURCE:
return PictOpSrc;
case CAIRO_OPERATOR_OVER:
return PictOpOver;
case CAIRO_OPERATOR_IN:
return PictOpIn;
case CAIRO_OPERATOR_OUT:
return PictOpOut;
case CAIRO_OPERATOR_ATOP:
return PictOpAtop;
case CAIRO_OPERATOR_DEST:
return PictOpDst;
case CAIRO_OPERATOR_DEST_OVER:
return PictOpOverReverse;
case CAIRO_OPERATOR_DEST_IN:
return PictOpInReverse;
case CAIRO_OPERATOR_DEST_OUT:
return PictOpOutReverse;
case CAIRO_OPERATOR_DEST_ATOP:
return PictOpAtopReverse;
case CAIRO_OPERATOR_XOR:
return PictOpXor;
case CAIRO_OPERATOR_ADD:
return PictOpAdd;
case CAIRO_OPERATOR_SATURATE:
return PictOpSaturate;
case CAIRO_OPERATOR_MULTIPLY:
return PictOpMultiply;
case CAIRO_OPERATOR_SCREEN:
return PictOpScreen;
case CAIRO_OPERATOR_OVERLAY:
return PictOpOverlay;
case CAIRO_OPERATOR_DARKEN:
return PictOpDarken;
case CAIRO_OPERATOR_LIGHTEN:
return PictOpLighten;
case CAIRO_OPERATOR_COLOR_DODGE:
return PictOpColorDodge;
case CAIRO_OPERATOR_COLOR_BURN:
return PictOpColorBurn;
case CAIRO_OPERATOR_HARD_LIGHT:
return PictOpHardLight;
case CAIRO_OPERATOR_SOFT_LIGHT:
return PictOpSoftLight;
case CAIRO_OPERATOR_DIFFERENCE:
return PictOpDifference;
case CAIRO_OPERATOR_EXCLUSION:
return PictOpExclusion;
case CAIRO_OPERATOR_HSL_HUE:
return PictOpHSLHue;
case CAIRO_OPERATOR_HSL_SATURATION:
return PictOpHSLSaturation;
case CAIRO_OPERATOR_HSL_COLOR:
return PictOpHSLColor;
case CAIRO_OPERATOR_HSL_LUMINOSITY:
return PictOpHSLLuminosity;
default:
ASSERT_NOT_REACHED;
return PictOpOver;
}
}
static cairo_bool_t
fill_reduces_to_source (cairo_operator_t op,
const cairo_color_t *color,
cairo_xlib_surface_t *dst)
{
if (dst->base.is_clear || CAIRO_COLOR_IS_OPAQUE (color)) {
if (op == CAIRO_OPERATOR_OVER)
return TRUE;
if (op == CAIRO_OPERATOR_ADD)
return (dst->base.content & CAIRO_CONTENT_COLOR) == 0;
}
return FALSE;
}
static cairo_int_status_t
fill_rectangles (void *abstract_surface,
cairo_operator_t op,
const cairo_color_t *color,
cairo_rectangle_int_t *rects,
int num_rects)
{
cairo_xlib_surface_t *dst = abstract_surface;
XRenderColor render_color;
int i;
//X_DEBUG ((display->display, "fill_rectangles (dst=%x)", (unsigned int) surface->drawable));
render_color.red = color->red_short;
render_color.green = color->green_short;
render_color.blue = color->blue_short;
render_color.alpha = color->alpha_short;
if (fill_reduces_to_source (op, color, dst))
op = CAIRO_OPERATOR_SOURCE;
_cairo_xlib_surface_ensure_picture (dst);
if (num_rects == 1) {
/* Take advantage of the protocol compaction that libXrender performs
* to amalgamate sequences of XRenderFillRectangle().
*/
XRenderFillRectangle (dst->dpy,
_render_operator (op),
dst->picture,
&render_color,
rects->x, rects->y,
rects->width, rects->height);
} else {
XRectangle stack_xrects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)];
XRectangle *xrects = stack_xrects;
if (num_rects > ARRAY_LENGTH (stack_xrects)) {
xrects = _cairo_malloc_ab (num_rects, sizeof (XRectangle));
if (unlikely (xrects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
for (i = 0; i < num_rects; i++) {
xrects[i].x = rects[i].x;
xrects[i].y = rects[i].y;
xrects[i].width = rects[i].width;
xrects[i].height = rects[i].height;
}
XRenderFillRectangles (dst->dpy,
_render_operator (op),
dst->picture,
&render_color, xrects, num_rects);
if (xrects != stack_xrects)
free (xrects);
}
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
fill_boxes (void *abstract_surface,
cairo_operator_t op,
const cairo_color_t *color,
cairo_boxes_t *boxes)
{
cairo_xlib_surface_t *dst = abstract_surface;
XRenderColor render_color;
render_color.red = color->red_short;
render_color.green = color->green_short;
render_color.blue = color->blue_short;
render_color.alpha = color->alpha_short;
if (fill_reduces_to_source (op, color, dst))
op = CAIRO_OPERATOR_SOURCE;
_cairo_xlib_surface_ensure_picture (dst);
if (boxes->num_boxes == 1) {
int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x);
int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y);
int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x);
int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y);
/* Take advantage of the protocol compaction that libXrender performs
* to amalgamate sequences of XRenderFillRectangle().
*/
XRenderFillRectangle (dst->dpy,
_render_operator (op),
dst->picture,
&render_color,
x1, y1,
x2 - x1, y2 - y1);
} else {
XRectangle stack_xrects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)];
XRectangle *xrects = stack_xrects;
struct _cairo_boxes_chunk *chunk;
int i, j;
if (boxes->num_boxes > ARRAY_LENGTH (stack_xrects)) {
xrects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle));
if (unlikely (xrects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
j = 0;
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
xrects[j].x = x1;
xrects[j].y = y1;
xrects[j].width = x2 - x1;
xrects[j].height = y2 - y1;
j++;
}
}
XRenderFillRectangles (dst->dpy,
_render_operator (op),
dst->picture,
&render_color, xrects, j);
if (xrects != stack_xrects)
free (xrects);
}
return CAIRO_STATUS_SUCCESS;
}
#if 0
check_composite ()
operation = _categorize_composite_operation (dst, op, src_pattern,
mask_pattern != NULL);
if (operation == DO_UNSUPPORTED)
return UNSUPPORTED ("unsupported operation");
//X_DEBUG ((display->display, "composite (dst=%x)", (unsigned int) dst->drawable));
operation = _recategorize_composite_operation (dst, op, src, &src_attr,
mask_pattern != NULL);
if (operation == DO_UNSUPPORTED) {
status = UNSUPPORTED ("unsupported operation");
goto BAIL;
}
#endif
static cairo_int_status_t
composite (void *abstract_dst,
cairo_operator_t op,
cairo_surface_t *abstract_src,
cairo_surface_t *abstract_mask,
int src_x,
int src_y,
int mask_x,
int mask_y,
int dst_x,
int dst_y,
unsigned int width,
unsigned int height)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src;
op = _render_operator (op);
_cairo_xlib_surface_ensure_picture (dst);
if (abstract_mask) {
cairo_xlib_source_t *mask = (cairo_xlib_source_t *)abstract_mask;
XRenderComposite (dst->dpy, op,
src->picture, mask->picture, dst->picture,
src_x, src_y,
mask_x, mask_y,
dst_x, dst_y,
width, height);
} else {
XRenderComposite (dst->dpy, op,
src->picture, 0, dst->picture,
src_x, src_y,
0, 0,
dst_x, dst_y,
width, height);
}
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
lerp (void *abstract_dst,
cairo_surface_t *abstract_src,
cairo_surface_t *abstract_mask,
int src_x,
int src_y,
int mask_x,
int mask_y,
int dst_x,
int dst_y,
unsigned int width,
unsigned int height)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src;
cairo_xlib_source_t *mask = (cairo_xlib_source_t *)abstract_mask;
_cairo_xlib_surface_ensure_picture (dst);
XRenderComposite (dst->dpy, PictOpOutReverse,
mask->picture, None, dst->picture,
mask_x, mask_y,
0, 0,
dst_x, dst_y,
width, height);
XRenderComposite (dst->dpy, PictOpAdd,
src->picture, mask->picture, dst->picture,
src_x, src_y,
mask_x, mask_y,
dst_x, dst_y,
width, height);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
composite_boxes (void *abstract_dst,
cairo_operator_t op,
cairo_surface_t *abstract_src,
cairo_surface_t *abstract_mask,
int src_x,
int src_y,
int mask_x,
int mask_y,
int dst_x,
int dst_y,
cairo_boxes_t *boxes,
const cairo_rectangle_int_t *extents)
{
cairo_xlib_surface_t *dst = abstract_dst;
Picture src = ((cairo_xlib_source_t *)abstract_src)->picture;
Picture mask = abstract_mask ? ((cairo_xlib_source_t *)abstract_mask)->picture : 0;
XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)];
XRectangle *rects = stack_rects;
struct _cairo_boxes_chunk *chunk;
int i, j;
op = _render_operator (op);
_cairo_xlib_surface_ensure_picture (dst);
if (boxes->num_boxes == 1) {
int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x);
int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y);
int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x);
int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y);
XRenderComposite (dst->dpy, op,
src, mask, dst->picture,
x1 + src_x, y1 + src_y,
x1 + mask_x, y1 + mask_y,
x1 - dst_x, y1 - dst_y,
x2 - x1, y2 - y1);
return CAIRO_STATUS_SUCCESS;
}
if (boxes->num_boxes > ARRAY_LENGTH (stack_rects)) {
rects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle));
if (unlikely (rects == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
j = 0;
for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
rects[j].x = x1 - dst_x;
rects[j].y = y1 - dst_y;
rects[j].width = x2 - x1;
rects[j].height = y2 - y1;
j++;
}
}
assert (j == boxes->num_boxes);
XRenderSetPictureClipRectangles (dst->dpy,
dst->picture,
0, 0,
rects, j);
if (rects != stack_rects)
free (rects);
XRenderComposite (dst->dpy, op,
src, mask, dst->picture,
extents->x + src_x, extents->y + src_y,
extents->x + mask_x, extents->y + mask_y,
extents->x - dst_x, extents->y - dst_y,
extents->width, extents->height);
set_clip_region (dst, NULL);
return CAIRO_STATUS_SUCCESS;
}
/* font rendering */
void
_cairo_xlib_font_close (cairo_xlib_font_t *priv)
{
cairo_xlib_display_t *display = (cairo_xlib_display_t *)priv->base.key;
int i;
/* XXX All I really want is to do is zap my glyphs... */
_cairo_scaled_font_reset_cache (priv->font);
for (i = 0; i < NUM_GLYPHSETS; i++) {
cairo_xlib_font_glyphset_t *info;
info = &priv->glyphset[i];
if (info->glyphset)
XRenderFreeGlyphSet (display->display, info->glyphset);
}
/* XXX locking */
cairo_list_del (&priv->link);
cairo_list_del (&priv->base.link);
free (priv);
}
static void
_cairo_xlib_font_fini (cairo_scaled_font_private_t *abstract_private,
cairo_scaled_font_t *font)
{
cairo_xlib_font_t *priv = (cairo_xlib_font_t *) abstract_private;
cairo_status_t status;
cairo_xlib_display_t *display;
int i;
cairo_list_del (&priv->base.link);
cairo_list_del (&priv->link);
status = _cairo_xlib_display_acquire (priv->device, &display);
if (status)
goto BAIL;
for (i = 0; i < NUM_GLYPHSETS; i++) {
cairo_xlib_font_glyphset_t *info;
info = &priv->glyphset[i];
if (info->glyphset)
XRenderFreeGlyphSet (display->display, info->glyphset);
}
cairo_device_release (&display->base);
BAIL:
cairo_device_destroy (&display->base);
free (priv);
}
static cairo_xlib_font_t *
_cairo_xlib_font_create (cairo_xlib_display_t *display,
cairo_scaled_font_t *font)
{
cairo_xlib_font_t *priv;
int i;
priv = malloc (sizeof (cairo_xlib_font_t));
if (unlikely (priv == NULL))
return NULL;
_cairo_scaled_font_attach_private (font, &priv->base, display,
_cairo_xlib_font_fini);
priv->device = cairo_device_reference (&display->base);
priv->font = font;
cairo_list_add (&priv->link, &display->fonts);
for (i = 0; i < NUM_GLYPHSETS; i++) {
cairo_xlib_font_glyphset_t *info = &priv->glyphset[i];
switch (i) {
case GLYPHSET_INDEX_ARGB32: info->format = CAIRO_FORMAT_ARGB32; break;
case GLYPHSET_INDEX_A8: info->format = CAIRO_FORMAT_A8; break;
case GLYPHSET_INDEX_A1: info->format = CAIRO_FORMAT_A1; break;
default: ASSERT_NOT_REACHED; break;
}
info->xrender_format = NULL;
info->glyphset = None;
info->to_free.count = 0;
}
return priv;
}
static int
_cairo_xlib_get_glyphset_index_for_format (cairo_format_t format)
{
if (format == CAIRO_FORMAT_A8)
return GLYPHSET_INDEX_A8;
if (format == CAIRO_FORMAT_A1)
return GLYPHSET_INDEX_A1;
assert (format == CAIRO_FORMAT_ARGB32);
return GLYPHSET_INDEX_ARGB32;
}
static inline cairo_xlib_font_t *
_cairo_xlib_font_get (const cairo_xlib_display_t *display,
cairo_scaled_font_t *font)
{
return (cairo_xlib_font_t *)_cairo_scaled_font_find_private (font, display);
}
typedef struct {
cairo_scaled_glyph_private_t base;
cairo_xlib_font_glyphset_t *glyphset;
} cairo_xlib_glyph_private_t;
static void
_cairo_xlib_glyph_fini (cairo_scaled_glyph_private_t *glyph_private,
cairo_scaled_glyph_t *glyph,
cairo_scaled_font_t *font)
{
cairo_xlib_glyph_private_t *priv = (cairo_xlib_glyph_private_t *)glyph_private;
if (! font->finished) {
cairo_xlib_font_t *font_private;
struct _cairo_xlib_font_glyphset_free_glyphs *to_free;
cairo_xlib_font_glyphset_t *info;
font_private = _cairo_xlib_font_get (glyph_private->key, font);
assert (font_private);
info = priv->glyphset;
to_free = &info->to_free;
if (to_free->count == ARRAY_LENGTH (to_free->indices)) {
cairo_xlib_display_t *display;
if (_cairo_xlib_display_acquire (font_private->device,
&display) == CAIRO_STATUS_SUCCESS) {
XRenderFreeGlyphs (display->display,
info->glyphset,
to_free->indices,
to_free->count);
cairo_device_release (&display->base);
}
to_free->count = 0;
}
to_free->indices[to_free->count++] =
_cairo_scaled_glyph_index (glyph);
}
cairo_list_del (&glyph_private->link);
free (glyph_private);
}
static cairo_status_t
_cairo_xlib_glyph_attach (cairo_xlib_display_t *display,
cairo_scaled_glyph_t *glyph,
cairo_xlib_font_glyphset_t *info)
{
cairo_xlib_glyph_private_t *priv;
priv = malloc (sizeof (*priv));
if (unlikely (priv == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
_cairo_scaled_glyph_attach_private (glyph, &priv->base, display,
_cairo_xlib_glyph_fini);
priv->glyphset = info;
glyph->dev_private = info;
glyph->dev_private_key = display;
return CAIRO_STATUS_SUCCESS;
}
static cairo_xlib_font_glyphset_t *
_cairo_xlib_font_get_glyphset_info_for_format (cairo_xlib_display_t *display,
cairo_scaled_font_t *font,
cairo_format_t format)
{
cairo_xlib_font_t *priv;
cairo_xlib_font_glyphset_t *info;
int glyphset_index;
glyphset_index = _cairo_xlib_get_glyphset_index_for_format (format);
priv = _cairo_xlib_font_get (display, font);
if (priv == NULL) {
priv = _cairo_xlib_font_create (display, font);
if (priv == NULL)
return NULL;
}
info = &priv->glyphset[glyphset_index];
if (info->glyphset == None) {
info->xrender_format =
_cairo_xlib_display_get_xrender_format (display, info->format);
info->glyphset = XRenderCreateGlyphSet (display->display,
info->xrender_format);
}
return info;
}
static cairo_bool_t
has_pending_free_glyph (cairo_xlib_font_glyphset_t *info,
unsigned long glyph_index)
{
struct _cairo_xlib_font_glyphset_free_glyphs *to_free;
int i;
to_free = &info->to_free;
for (i = 0; i < to_free->count; i++) {
if (to_free->indices[i] == glyph_index) {
to_free->count--;
memmove (&to_free->indices[i],
&to_free->indices[i+1],
(to_free->count - i) * sizeof (to_free->indices[0]));
return TRUE;
}
}
return FALSE;
}
static cairo_xlib_font_glyphset_t *
find_pending_free_glyph (cairo_xlib_display_t *display,
cairo_scaled_font_t *font,
unsigned long glyph_index,
cairo_image_surface_t *surface)
{
cairo_xlib_font_t *priv;
int i;
priv = _cairo_xlib_font_get (display, font);
if (priv == NULL)
return NULL;
if (surface != NULL) {
i = _cairo_xlib_get_glyphset_index_for_format (surface->format);
if (has_pending_free_glyph (&priv->glyphset[i], glyph_index))
return &priv->glyphset[i];
} else {
for (i = 0; i < NUM_GLYPHSETS; i++) {
if (has_pending_free_glyph (&priv->glyphset[i], glyph_index))
return &priv->glyphset[i];
}
}
return NULL;
}
static cairo_status_t
_cairo_xlib_surface_add_glyph (cairo_xlib_display_t *display,
cairo_scaled_font_t *font,
cairo_scaled_glyph_t **pscaled_glyph)
{
XGlyphInfo glyph_info;
unsigned long glyph_index;
unsigned char *data;
cairo_status_t status = CAIRO_STATUS_SUCCESS;
cairo_scaled_glyph_t *glyph = *pscaled_glyph;
cairo_image_surface_t *glyph_surface = glyph->surface;
cairo_bool_t already_had_glyph_surface;
cairo_xlib_font_glyphset_t *info;
glyph_index = _cairo_scaled_glyph_index (glyph);
/* check to see if we have a pending XRenderFreeGlyph for this glyph */
info = find_pending_free_glyph (display, font, glyph_index, glyph_surface);
if (info != NULL)
return _cairo_xlib_glyph_attach (display, glyph, info);
if (glyph_surface == NULL) {
status = _cairo_scaled_glyph_lookup (font,
glyph_index,
CAIRO_SCALED_GLYPH_INFO_METRICS |
CAIRO_SCALED_GLYPH_INFO_SURFACE,
pscaled_glyph);
if (unlikely (status))
return status;
glyph = *pscaled_glyph;
glyph_surface = glyph->surface;
already_had_glyph_surface = FALSE;
} else {
already_had_glyph_surface = TRUE;
}
info = _cairo_xlib_font_get_glyphset_info_for_format (display, font,
glyph_surface->format);
#if 0
/* If the glyph surface has zero height or width, we create
* a clear 1x1 surface, to avoid various X server bugs.
*/
if (glyph_surface->width == 0 || glyph_surface->height == 0) {
cairo_surface_t *tmp_surface;
tmp_surface = cairo_image_surface_create (info->format, 1, 1);
status = tmp_surface->status;
if (unlikely (status))
goto BAIL;
tmp_surface->device_transform = glyph_surface->base.device_transform;
tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse;
glyph_surface = (cairo_image_surface_t *) tmp_surface;
}
#endif
/* If the glyph format does not match the font format, then we
* create a temporary surface for the glyph image with the font's
* format.
*/
if (glyph_surface->format != info->format) {
cairo_surface_pattern_t pattern;
cairo_surface_t *tmp_surface;
tmp_surface = cairo_image_surface_create (info->format,
glyph_surface->width,
glyph_surface->height);
status = tmp_surface->status;
if (unlikely (status))
goto BAIL;
tmp_surface->device_transform = glyph_surface->base.device_transform;
tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse;
_cairo_pattern_init_for_surface (&pattern, &glyph_surface->base);
status = _cairo_surface_paint (tmp_surface,
CAIRO_OPERATOR_SOURCE, &pattern.base,
NULL);
_cairo_pattern_fini (&pattern.base);
glyph_surface = (cairo_image_surface_t *) tmp_surface;
if (unlikely (status))
goto BAIL;
}
/* XXX: FRAGILE: We're ignore device_transform scaling here. A bug? */
glyph_info.x = _cairo_lround (glyph_surface->base.device_transform.x0);
glyph_info.y = _cairo_lround (glyph_surface->base.device_transform.y0);
glyph_info.width = glyph_surface->width;
glyph_info.height = glyph_surface->height;
glyph_info.xOff = glyph->x_advance;
glyph_info.yOff = glyph->y_advance;
data = glyph_surface->data;
/* flip formats around */
switch (_cairo_xlib_get_glyphset_index_for_format (glyph->surface->format)) {
case GLYPHSET_INDEX_A1:
/* local bitmaps are always stored with bit == byte */
if (_cairo_is_little_endian() != (BitmapBitOrder (display->display) == LSBFirst)) {
int c = glyph_surface->stride * glyph_surface->height;
unsigned char *d;
unsigned char *new, *n;
new = malloc (c);
if (!new) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL;
}
n = new;
d = data;
do {
char b = *d++;
b = ((b << 1) & 0xaa) | ((b >> 1) & 0x55);
b = ((b << 2) & 0xcc) | ((b >> 2) & 0x33);
b = ((b << 4) & 0xf0) | ((b >> 4) & 0x0f);
*n++ = b;
} while (--c);
data = new;
}
break;
case GLYPHSET_INDEX_A8:
break;
case GLYPHSET_INDEX_ARGB32:
if (_cairo_is_little_endian() != (ImageByteOrder (display->display) == LSBFirst)) {
unsigned int c = glyph_surface->stride * glyph_surface->height / 4;
const uint32_t *d;
uint32_t *new, *n;
new = malloc (4 * c);
if (unlikely (new == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL;
}
n = new;
d = (uint32_t *) data;
do {
*n++ = bswap_32 (*d);
d++;
} while (--c);
data = (uint8_t *) new;
}
break;
default:
ASSERT_NOT_REACHED;
break;
}
/* XXX assume X server wants pixman padding. Xft assumes this as well */
XRenderAddGlyphs (display->display, info->glyphset,
&glyph_index, &glyph_info, 1,
(char *) data,
glyph_surface->stride * glyph_surface->height);
if (data != glyph_surface->data)
free (data);
status = _cairo_xlib_glyph_attach (display, glyph, info);
BAIL:
if (glyph_surface != glyph->surface)
cairo_surface_destroy (&glyph_surface->base);
/* if the scaled glyph didn't already have a surface attached
* to it, release the created surface now that we have it
* uploaded to the X server. If the surface has already been
* there (eg. because image backend requested it), leave it in
* the cache
*/
if (!already_had_glyph_surface)
_cairo_scaled_glyph_set_surface (glyph, font, NULL);
return status;
}
typedef void (*cairo_xrender_composite_text_func_t)
(Display *dpy,
int op,
Picture src,
Picture dst,
_Xconst XRenderPictFormat *maskFormat,
int xSrc,
int ySrc,
int xDst,
int yDst,
_Xconst XGlyphElt8 *elts,
int nelt);
/* Build a struct of the same size of #cairo_glyph_t that can be used both as
* an input glyph with double coordinates, and as "working" glyph with
* integer from-current-point offsets. */
typedef union {
cairo_glyph_t d;
unsigned long index;
struct {
unsigned long index;
int x;
int y;
} i;
} cairo_xlib_glyph_t;
/* compile-time assert that #cairo_xlib_glyph_t is the same size as #cairo_glyph_t */
COMPILE_TIME_ASSERT (sizeof (cairo_xlib_glyph_t) == sizeof (cairo_glyph_t));
/* Start a new element for the first glyph,
* or for any glyph that has unexpected position,
* or if current element has too many glyphs
* (Xrender limits each element to 252 glyphs, we limit them to 128)
*
* These same conditions need to be mirrored between
* _cairo_xlib_surface_emit_glyphs and _emit_glyph_chunks
*/
#define _start_new_glyph_elt(count, glyph) \
(((count) & 127) == 0 || (glyph)->i.x || (glyph)->i.y)
static cairo_status_t
_emit_glyphs_chunk (cairo_xlib_display_t *display,
cairo_xlib_surface_t *dst,
int dst_x, int dst_y,
cairo_xlib_glyph_t *glyphs,
int num_glyphs,
cairo_scaled_font_t *font,
cairo_bool_t use_mask,
cairo_operator_t op,
cairo_xlib_source_t *src,
int src_x, int src_y,
/* info for this chunk */
int num_elts,
int width,
cairo_xlib_font_glyphset_t *info)
{
/* Which XRenderCompositeText function to use */
cairo_xrender_composite_text_func_t composite_text_func;
int size;
/* Element buffer stuff */
XGlyphElt8 *elts;
XGlyphElt8 stack_elts[CAIRO_STACK_ARRAY_LENGTH (XGlyphElt8)];
/* Reuse the input glyph array for output char generation */
char *char8 = (char *) glyphs;
unsigned short *char16 = (unsigned short *) glyphs;
unsigned int *char32 = (unsigned int *) glyphs;
int i;
int nelt; /* Element index */
int n; /* Num output glyphs in current element */
int j; /* Num output glyphs so far */
switch (width) {
case 1:
/* don't cast the 8-variant, to catch possible mismatches */
composite_text_func = XRenderCompositeText8;
size = sizeof (char);
break;
case 2:
composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText16;
size = sizeof (unsigned short);
break;
default:
case 4:
composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText32;
size = sizeof (unsigned int);
}
/* Allocate element array */
if (num_elts <= ARRAY_LENGTH (stack_elts)) {
elts = stack_elts;
} else {
elts = _cairo_malloc_ab (num_elts, sizeof (XGlyphElt8));
if (unlikely (elts == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
/* Fill them in */
nelt = 0;
n = 0;
j = 0;
for (i = 0; i < num_glyphs; i++) {
/* Start a new element for first output glyph,
* or for any glyph that has unexpected position,
* or if current element has too many glyphs.
*
* These same conditions are mirrored in _cairo_xlib_surface_emit_glyphs()
*/
if (_start_new_glyph_elt (j, &glyphs[i])) {
if (j) {
elts[nelt].nchars = n;
nelt++;
n = 0;
}
elts[nelt].chars = char8 + size * j;
elts[nelt].glyphset = info->glyphset;
elts[nelt].xOff = glyphs[i].i.x - dst_x;
elts[nelt].yOff = glyphs[i].i.y - dst_y;
}
switch (width) {
case 1: char8 [j] = (char) glyphs[i].index; break;
case 2: char16[j] = (unsigned short) glyphs[i].index; break;
default:
case 4: char32[j] = (unsigned int) glyphs[i].index; break;
}
n++;
j++;
}
if (n) {
elts[nelt].nchars = n;
nelt++;
}
/* Check that we agree with _cairo_xlib_surface_emit_glyphs() on the
* expected number of xGlyphElts. */
assert (nelt == num_elts);
composite_text_func (display->display, op,
src->picture,
dst->picture,
use_mask ? info->xrender_format : NULL,
src_x + elts[0].xOff + dst_x,
src_y + elts[0].yOff + dst_y,
elts[0].xOff, elts[0].yOff,
(XGlyphElt8 *) elts, nelt);
if (elts != stack_elts)
free (elts);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
check_composite_glyphs (const cairo_composite_rectangles_t *extents,
cairo_scaled_font_t *font,
cairo_glyph_t *glyphs,
int *num_glyphs)
{
cairo_xlib_surface_t *dst = (cairo_xlib_surface_t *)extents->surface;
cairo_xlib_display_t *display = dst->display;
int max_request_size, size;
if (! CAIRO_RENDER_SUPPORTS_OPERATOR (display, extents->op))
return CAIRO_INT_STATUS_UNSUPPORTED;
/* The glyph coordinates must be representable in an int16_t.
* When possible, they will be expressed as an offset from the
* previous glyph, otherwise they will be an offset from the
* surface origin. If we can't guarantee this to be possible,
* fallback.
*/
if (extents->bounded.x + extents->bounded.width > INT16_MAX ||
extents->bounded.y + extents->bounded.height> INT16_MAX ||
extents->bounded.x < INT16_MIN ||
extents->bounded.y < INT16_MIN)
{
return CAIRO_INT_STATUS_UNSUPPORTED;
}
/* Approximate the size of the largest glyph and fallback if we can not
* upload it to the xserver.
*/
size = ceil (font->max_scale);
size = 4 * size * size;
max_request_size = (XExtendedMaxRequestSize (display->display) ? XExtendedMaxRequestSize (display->display)
: XMaxRequestSize (display->display)) * 4 -
sz_xRenderAddGlyphsReq -
sz_xGlyphInfo -
8;
if (size >= max_request_size)
return CAIRO_INT_STATUS_UNSUPPORTED;
return CAIRO_STATUS_SUCCESS;
}
/* sz_xGlyphtElt required alignment to a 32-bit boundary, so ensure we have
* enough room for padding */
#define _cairo_sz_xGlyphElt (sz_xGlyphElt + 4)
static cairo_int_status_t
composite_glyphs (void *surface,
cairo_operator_t op,
cairo_surface_t *_src,
int src_x,
int src_y,
int dst_x,
int dst_y,
cairo_composite_glyphs_info_t *info)
{
cairo_xlib_surface_t *dst = surface;
cairo_xlib_glyph_t *glyphs = (cairo_xlib_glyph_t *)info->glyphs;
cairo_xlib_source_t *src = (cairo_xlib_source_t *)_src;
cairo_xlib_display_t *display = dst->display;
cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;
cairo_scaled_glyph_t *glyph;
cairo_fixed_t x = 0, y = 0;
cairo_xlib_font_glyphset_t *glyphset = NULL, *this_glyphset_info;
unsigned long max_index = 0;
int width = 1;
int num_elts = 0;
int num_out_glyphs = 0;
int num_glyphs = info->num_glyphs;
int max_request_size = XMaxRequestSize (display->display) * 4
- MAX (sz_xRenderCompositeGlyphs8Req,
MAX(sz_xRenderCompositeGlyphs16Req,
sz_xRenderCompositeGlyphs32Req));
int request_size = 0;
int i;
op = _render_operator (op),
_cairo_xlib_surface_ensure_picture (dst);
for (i = 0; i < num_glyphs; i++) {
int this_x, this_y;
int old_width;
status = _cairo_scaled_glyph_lookup (info->font,
glyphs[i].index,
CAIRO_SCALED_GLYPH_INFO_METRICS,
&glyph);
if (unlikely (status))
return status;
this_x = _cairo_lround (glyphs[i].d.x);
this_y = _cairo_lround (glyphs[i].d.y);
/* Send unsent glyphs to the server */
if (glyph->dev_private_key != display) {
status = _cairo_xlib_surface_add_glyph (display, info->font, &glyph);
if (unlikely (status))
return status;
}
this_glyphset_info = glyph->dev_private;
if (!glyphset)
glyphset = this_glyphset_info;
/* The invariant here is that we can always flush the glyphs
* accumulated before this one, using old_width, and they
* would fit in the request.
*/
old_width = width;
/* Update max glyph index */
if (glyphs[i].index > max_index) {
max_index = glyphs[i].index;
if (max_index >= 65536)
width = 4;
else if (max_index >= 256)
width = 2;
if (width != old_width)
request_size += (width - old_width) * num_out_glyphs;
}
/* If we will pass the max request size by adding this glyph,
* flush current glyphs. Note that we account for a
* possible element being added below.
*
* Also flush if changing glyphsets, as Xrender limits one mask
* format per request, so we can either break up, or use a
* wide-enough mask format. We do the former. One reason to
* prefer the latter is the fact that Xserver ADDs all glyphs
* to the mask first, and then composes that to final surface,
* though it's not a big deal.
*
* If the glyph has a coordinate which cannot be represented
* as a 16-bit offset from the previous glyph, flush the
* current chunk. The current glyph will be the first one in
* the next chunk, thus its coordinates will be an offset from
* the destination origin. This offset is guaranteed to be
* representable as 16-bit offset (otherwise we would have
* fallen back).
*/
if (request_size + width > max_request_size - _cairo_sz_xGlyphElt ||
this_x - x > INT16_MAX || this_x - x < INT16_MIN ||
this_y - y > INT16_MAX || this_y - y < INT16_MIN ||
(this_glyphset_info != glyphset)) {
status = _emit_glyphs_chunk (display, dst, dst_x, dst_y,
glyphs, i, info->font, info->use_mask,
op, src, src_x, src_y,
num_elts, old_width, glyphset);
if (unlikely (status))
return status;
glyphs += i;
num_glyphs -= i;
i = 0;
max_index = glyphs[i].index;
width = max_index < 256 ? 1 : max_index < 65536 ? 2 : 4;
request_size = 0;
num_elts = 0;
num_out_glyphs = 0;
x = y = 0;
glyphset = this_glyphset_info;
}
/* Convert absolute glyph position to relative-to-current-point
* position */
glyphs[i].i.x = this_x - x;
glyphs[i].i.y = this_y - y;
/* Start a new element for the first glyph,
* or for any glyph that has unexpected position,
* or if current element has too many glyphs.
*
* These same conditions are mirrored in _emit_glyphs_chunk().
*/
if (_start_new_glyph_elt (num_out_glyphs, &glyphs[i])) {
num_elts++;
request_size += _cairo_sz_xGlyphElt;
}
/* adjust current-position */
x = this_x + glyph->x_advance;
y = this_y + glyph->y_advance;
num_out_glyphs++;
request_size += width;
}
if (num_elts) {
status = _emit_glyphs_chunk (display, dst, dst_x, dst_y,
glyphs, i, info->font, info->use_mask,
op, src, src_x, src_y,
num_elts, width, glyphset);
}
return status;
}
const cairo_compositor_t *
_cairo_xlib_mask_compositor_get (void)
{
static cairo_mask_compositor_t compositor;
if (compositor.base.delegate == NULL) {
_cairo_mask_compositor_init (&compositor,
_cairo_xlib_fallback_compositor_get ());
compositor.acquire = acquire;
compositor.release = release;
compositor.set_clip_region = set_clip_region;
compositor.pattern_to_surface = _cairo_xlib_source_create_for_pattern;
compositor.draw_image_boxes = draw_image_boxes;
compositor.fill_rectangles = fill_rectangles;
compositor.fill_boxes = fill_boxes;
compositor.copy_boxes = copy_boxes;
//compositor.check_composite = check_composite;
compositor.composite = composite;
//compositor.check_composite_boxes = check_composite_boxes;
compositor.composite_boxes = composite_boxes;
compositor.check_composite_glyphs = check_composite_glyphs;
compositor.composite_glyphs = composite_glyphs;
}
return &compositor.base;
}
#define CAIRO_FIXED_16_16_MIN -32768
#define CAIRO_FIXED_16_16_MAX 32767
static cairo_bool_t
line_exceeds_16_16 (const cairo_line_t *line)
{
return
line->p1.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) ||
line->p1.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) ||
line->p2.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) ||
line->p2.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) ||
line->p1.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) ||
line->p1.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) ||
line->p2.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) ||
line->p2.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX);
}
static void
project_line_x_onto_16_16 (const cairo_line_t *line,
cairo_fixed_t top,
cairo_fixed_t bottom,
XLineFixed *out)
{
cairo_point_double_t p1, p2;
double m;
p1.x = _cairo_fixed_to_double (line->p1.x);
p1.y = _cairo_fixed_to_double (line->p1.y);
p2.x = _cairo_fixed_to_double (line->p2.x);
p2.y = _cairo_fixed_to_double (line->p2.y);
m = (p2.x - p1.x) / (p2.y - p1.y);
out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y));
out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y));
}
#if 0
static cairo_int_status_T
check_composite_trapezoids ()
{
operation = _categorize_composite_operation (dst, op, pattern, TRUE);
if (operation == DO_UNSUPPORTED)
return UNSUPPORTED ("unsupported operation");
operation = _recategorize_composite_operation (dst, op, src,
&attributes, TRUE);
if (operation == DO_UNSUPPORTED) {
status = UNSUPPORTED ("unsupported operation");
goto BAIL;
}
}
#endif
static cairo_int_status_t
composite_traps (void *abstract_dst,
cairo_operator_t op,
cairo_surface_t *abstract_src,
int src_x,
int src_y,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_antialias_t antialias,
cairo_traps_t *traps)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_xlib_display_t *display = dst->display;
cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src;
XRenderPictFormat *pict_format;
XTrapezoid xtraps_stack[CAIRO_STACK_ARRAY_LENGTH (XTrapezoid)];
XTrapezoid *xtraps = xtraps_stack;
int dx, dy;
int i;
//X_DEBUG ((display->display, "composite_trapezoids (dst=%x)", (unsigned int) dst->drawable));
if (dst->base.is_clear &&
(op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD))
{
op = CAIRO_OPERATOR_SOURCE;
}
pict_format =
_cairo_xlib_display_get_xrender_format (display,
antialias == CAIRO_ANTIALIAS_NONE ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8);
if (traps->num_traps > ARRAY_LENGTH (xtraps_stack)) {
xtraps = _cairo_malloc_ab (traps->num_traps, sizeof (XTrapezoid));
if (unlikely (xtraps == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
dx = -dst_x << 16;
dy = -dst_y << 16;
for (i = 0; i < traps->num_traps; i++) {
cairo_trapezoid_t *t = &traps->traps[i];
/* top/bottom will be clamped to surface bounds */
xtraps[i].top = _cairo_fixed_to_16_16(t->top) + dy;
xtraps[i].bottom = _cairo_fixed_to_16_16(t->bottom) + dy;
/* However, all the other coordinates will have been left untouched so
* as not to introduce numerical error. Recompute them if they
* exceed the 16.16 limits.
*/
if (unlikely (line_exceeds_16_16 (&t->left))) {
project_line_x_onto_16_16 (&t->left, t->top, t->bottom,
&xtraps[i].left);
xtraps[i].left.p1.x += dx;
xtraps[i].left.p2.x += dx;
xtraps[i].left.p1.y = xtraps[i].top;
xtraps[i].left.p2.y = xtraps[i].bottom;
} else {
xtraps[i].left.p1.x = _cairo_fixed_to_16_16(t->left.p1.x) + dx;
xtraps[i].left.p1.y = _cairo_fixed_to_16_16(t->left.p1.y) + dy;
xtraps[i].left.p2.x = _cairo_fixed_to_16_16(t->left.p2.x) + dx;
xtraps[i].left.p2.y = _cairo_fixed_to_16_16(t->left.p2.y) + dy;
}
if (unlikely (line_exceeds_16_16 (&t->right))) {
project_line_x_onto_16_16 (&t->right, t->top, t->bottom,
&xtraps[i].right);
xtraps[i].right.p1.x += dx;
xtraps[i].right.p2.x += dx;
xtraps[i].right.p1.y = xtraps[i].top;
xtraps[i].right.p2.y = xtraps[i].bottom;
} else {
xtraps[i].right.p1.x = _cairo_fixed_to_16_16(t->right.p1.x) + dx;
xtraps[i].right.p1.y = _cairo_fixed_to_16_16(t->right.p1.y) + dy;
xtraps[i].right.p2.x = _cairo_fixed_to_16_16(t->right.p2.x) + dx;
xtraps[i].right.p2.y = _cairo_fixed_to_16_16(t->right.p2.y) + dy;
}
}
if (xtraps[0].left.p1.y < xtraps[0].left.p2.y) {
src_x += _cairo_fixed_16_16_floor (xtraps[0].left.p1.x);
src_y += _cairo_fixed_16_16_floor (xtraps[0].left.p1.y);
} else {
src_x += _cairo_fixed_16_16_floor (xtraps[0].left.p2.x);
src_y += _cairo_fixed_16_16_floor (xtraps[0].left.p2.y);
}
src_x += dst_x;
src_y += dst_y;
_cairo_xlib_surface_ensure_picture (dst);
_cairo_xlib_surface_set_precision (dst, antialias);
XRenderCompositeTrapezoids (dst->dpy,
_render_operator (op),
src->picture, dst->picture,
pict_format,
src_x, src_y,
xtraps, traps->num_traps);
if (xtraps != xtraps_stack)
free (xtraps);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
composite_tristrip (void *abstract_dst,
cairo_operator_t op,
cairo_surface_t *abstract_src,
int src_x,
int src_y,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_antialias_t antialias,
cairo_tristrip_t *strip)
{
cairo_xlib_surface_t *dst = abstract_dst;
cairo_xlib_display_t *display = dst->display;
cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src;
XRenderPictFormat *pict_format;
XPointFixed points_stack[CAIRO_STACK_ARRAY_LENGTH (XPointFixed)];
XPointFixed *points = points_stack;
int dx, dy;
int i;
//X_DEBUG ((display->display, "composite_trapezoids (dst=%x)", (unsigned int) dst->drawable));
pict_format =
_cairo_xlib_display_get_xrender_format (display,
antialias == CAIRO_ANTIALIAS_NONE ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8);
if (strip->num_points > ARRAY_LENGTH (points_stack)) {
points = _cairo_malloc_ab (strip->num_points, sizeof (XPointFixed));
if (unlikely (points == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
dx = -dst_x << 16;
dy = -dst_y << 16;
for (i = 0; i < strip->num_points; i++) {
cairo_point_t *p = &strip->points[i];
points[i].x = _cairo_fixed_to_16_16(p->x) + dx;
points[i].y = _cairo_fixed_to_16_16(p->y) + dy;
}
src_x += _cairo_fixed_16_16_floor (points[0].x) + dst_x;
src_y += _cairo_fixed_16_16_floor (points[0].y) + dst_y;
_cairo_xlib_surface_ensure_picture (dst);
_cairo_xlib_surface_set_precision (dst, antialias);
XRenderCompositeTriStrip (dst->dpy,
_render_operator (op),
src->picture, dst->picture,
pict_format,
src_x, src_y,
points, strip->num_points);
if (points != points_stack)
free (points);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
check_composite (const cairo_composite_rectangles_t *extents)
{
cairo_xlib_display_t *display = ((cairo_xlib_surface_t *)extents->surface)->display;
if (! CAIRO_RENDER_SUPPORTS_OPERATOR (display, extents->op))
return CAIRO_INT_STATUS_UNSUPPORTED;
return CAIRO_STATUS_SUCCESS;
}
const cairo_compositor_t *
_cairo_xlib_traps_compositor_get (void)
{
static cairo_traps_compositor_t compositor;
if (compositor.base.delegate == NULL) {
_cairo_traps_compositor_init (&compositor,
_cairo_xlib_mask_compositor_get ());
compositor.acquire = acquire;
compositor.release = release;
compositor.set_clip_region = set_clip_region;
compositor.pattern_to_surface = _cairo_xlib_source_create_for_pattern;
compositor.draw_image_boxes = draw_image_boxes;
compositor.copy_boxes = copy_boxes;
compositor.fill_boxes = fill_boxes;
compositor.check_composite = check_composite;
compositor.composite = composite;
compositor.lerp = lerp;
//compositor.check_composite_boxes = check_composite_boxes;
compositor.composite_boxes = composite_boxes;
//compositor.check_composite_traps = check_composite_traps;
compositor.composite_traps = composite_traps;
//compositor.check_composite_tristrip = check_composite_tristrip;
compositor.composite_tristrip = composite_tristrip;
compositor.check_composite_glyphs = check_composite_glyphs;
compositor.composite_glyphs = composite_glyphs;
}
return &compositor.base;
}
#endif /* !CAIRO_HAS_XLIB_XCB_FUNCTIONS */