blob: 4d6b118dda5846321eab415ba4485e252d4c9460 [file] [log] [blame]
/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
/* 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>
* Joonas Pihlaja <jpihlaja@cc.helsinki.fi>
* Chris Wilson <chris@chris-wilson.co.uk>
*/
/* This compositor renders the shape to a mask using an image surface
* then calls composite.
*/
#include "cairoint.h"
#include "cairo-clip-inline.h"
#include "cairo-compositor-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-pattern-inline.h"
#include "cairo-region-private.h"
#include "cairo-surface-observer-private.h"
#include "cairo-surface-offset-private.h"
#include "cairo-surface-snapshot-private.h"
#include "cairo-surface-subsurface-private.h"
typedef cairo_int_status_t
(*draw_func_t) (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *src,
const cairo_rectangle_int_t *src_sample,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_clip_t *clip);
static void do_unaligned_row(void (*blt)(void *closure,
int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t coverage),
void *closure,
const cairo_box_t *b,
int tx, int y, int h,
uint16_t coverage)
{
int x1 = _cairo_fixed_integer_part (b->p1.x) - tx;
int x2 = _cairo_fixed_integer_part (b->p2.x) - tx;
if (x2 > x1) {
if (! _cairo_fixed_is_integer (b->p1.x)) {
blt(closure, x1, y, 1, h,
coverage * (256 - _cairo_fixed_fractional_part (b->p1.x)));
x1++;
}
if (x2 > x1)
blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8));
if (! _cairo_fixed_is_integer (b->p2.x))
blt(closure, x2, y, 1, h,
coverage * _cairo_fixed_fractional_part (b->p2.x));
} else
blt(closure, x1, y, 1, h,
coverage * (b->p2.x - b->p1.x));
}
static void do_unaligned_box(void (*blt)(void *closure,
int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t coverage),
void *closure,
const cairo_box_t *b, int tx, int ty)
{
int y1 = _cairo_fixed_integer_part (b->p1.y) - ty;
int y2 = _cairo_fixed_integer_part (b->p2.y) - ty;
if (y2 > y1) {
if (! _cairo_fixed_is_integer (b->p1.y)) {
do_unaligned_row(blt, closure, b, tx, y1, 1,
256 - _cairo_fixed_fractional_part (b->p1.y));
y1++;
}
if (y2 > y1)
do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256);
if (! _cairo_fixed_is_integer (b->p2.y))
do_unaligned_row(blt, closure, b, tx, y2, 1,
_cairo_fixed_fractional_part (b->p2.y));
} else
do_unaligned_row(blt, closure, b, tx, y1, 1,
b->p2.y - b->p1.y);
}
struct blt_in {
const cairo_mask_compositor_t *compositor;
cairo_surface_t *dst;
};
static void blt_in(void *closure,
int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t coverage)
{
struct blt_in *info = closure;
cairo_color_t color;
cairo_rectangle_int_t rect;
if (coverage == 0xffff)
return;
rect.x = x;
rect.y = y;
rect.width = w;
rect.height = h;
_cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double) 0xffff);
info->compositor->fill_rectangles (info->dst, CAIRO_OPERATOR_IN,
&color, &rect, 1);
}
static cairo_surface_t *
create_composite_mask (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
void *draw_closure,
draw_func_t draw_func,
draw_func_t mask_func,
const cairo_composite_rectangles_t *extents)
{
cairo_surface_t *surface;
cairo_int_status_t status;
struct blt_in info;
int i;
surface = _cairo_surface_create_scratch (dst, CAIRO_CONTENT_ALPHA,
extents->bounded.width,
extents->bounded.height,
NULL);
if (unlikely (surface->status))
return surface;
status = compositor->acquire (surface);
if (unlikely (status)) {
cairo_surface_destroy (surface);
return _cairo_int_surface_create_in_error (status);
}
if (!surface->is_clear) {
cairo_rectangle_int_t rect;
rect.x = rect.y = 0;
rect.width = extents->bounded.width;
rect.height = extents->bounded.height;
status = compositor->fill_rectangles (surface, CAIRO_OPERATOR_CLEAR,
CAIRO_COLOR_TRANSPARENT,
&rect, 1);
if (unlikely (status))
goto error;
}
if (mask_func) {
status = mask_func (compositor, surface, draw_closure,
CAIRO_OPERATOR_SOURCE, NULL, NULL,
extents->bounded.x, extents->bounded.y,
&extents->bounded, extents->clip);
if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED))
goto out;
}
/* Is it worth setting the clip region here? */
status = draw_func (compositor, surface, draw_closure,
CAIRO_OPERATOR_ADD, NULL, NULL,
extents->bounded.x, extents->bounded.y,
&extents->bounded, NULL);
if (unlikely (status))
goto error;
info.compositor = compositor;
info.dst = surface;
for (i = 0; i < extents->clip->num_boxes; i++) {
cairo_box_t *b = &extents->clip->boxes[i];
if (! _cairo_fixed_is_integer (b->p1.x) ||
! _cairo_fixed_is_integer (b->p1.y) ||
! _cairo_fixed_is_integer (b->p2.x) ||
! _cairo_fixed_is_integer (b->p2.y))
{
do_unaligned_box(blt_in, &info, b,
extents->bounded.x,
extents->bounded.y);
}
}
if (extents->clip->path != NULL) {
status = _cairo_clip_combine_with_surface (extents->clip, surface,
extents->bounded.x,
extents->bounded.y);
if (unlikely (status))
goto error;
}
out:
compositor->release (surface);
surface->is_clear = FALSE;
return surface;
error:
compositor->release (surface);
if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
cairo_surface_destroy (surface);
surface = _cairo_int_surface_create_in_error (status);
}
return surface;
}
/* Handles compositing with a clip surface when the operator allows
* us to combine the clip with the mask
*/
static cairo_status_t
clip_and_composite_with_mask (const cairo_mask_compositor_t *compositor,
void *draw_closure,
draw_func_t draw_func,
draw_func_t mask_func,
cairo_operator_t op,
cairo_pattern_t *pattern,
const cairo_composite_rectangles_t*extents)
{
cairo_surface_t *dst = extents->surface;
cairo_surface_t *mask, *src;
int src_x, src_y;
mask = create_composite_mask (compositor, dst, draw_closure,
draw_func, mask_func,
extents);
if (unlikely (mask->status))
return mask->status;
if (pattern != NULL || dst->content != CAIRO_CONTENT_ALPHA) {
src = compositor->pattern_to_surface (dst,
&extents->source_pattern.base,
FALSE,
&extents->bounded,
&extents->source_sample_area,
&src_x, &src_y);
if (unlikely (src->status)) {
cairo_surface_destroy (mask);
return src->status;
}
compositor->composite (dst, op, src, mask,
extents->bounded.x + src_x,
extents->bounded.y + src_y,
0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
cairo_surface_destroy (src);
} else {
compositor->composite (dst, op, mask, NULL,
0, 0,
0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
}
cairo_surface_destroy (mask);
return CAIRO_STATUS_SUCCESS;
}
static cairo_surface_t *
get_clip_source (const cairo_mask_compositor_t *compositor,
cairo_clip_t *clip,
cairo_surface_t *dst,
const cairo_rectangle_int_t *bounds,
int *out_x, int *out_y)
{
cairo_surface_pattern_t pattern;
cairo_rectangle_int_t r;
cairo_surface_t *surface;
surface = _cairo_clip_get_image (clip, dst, bounds);
if (unlikely (surface->status))
return surface;
_cairo_pattern_init_for_surface (&pattern, surface);
pattern.base.filter = CAIRO_FILTER_NEAREST;
cairo_surface_destroy (surface);
r.x = r.y = 0;
r.width = bounds->width;
r.height = bounds->height;
surface = compositor->pattern_to_surface (dst, &pattern.base, TRUE,
&r, &r, out_x, out_y);
_cairo_pattern_fini (&pattern.base);
*out_x += -bounds->x;
*out_y += -bounds->y;
return surface;
}
/* Handles compositing with a clip surface when we have to do the operation
* in two pieces and combine them together.
*/
static cairo_status_t
clip_and_composite_combine (const cairo_mask_compositor_t *compositor,
void *draw_closure,
draw_func_t draw_func,
cairo_operator_t op,
const cairo_pattern_t *pattern,
const cairo_composite_rectangles_t*extents)
{
cairo_surface_t *dst = extents->surface;
cairo_surface_t *tmp, *clip;
cairo_status_t status;
int clip_x, clip_y;
tmp = _cairo_surface_create_scratch (dst, dst->content,
extents->bounded.width,
extents->bounded.height,
NULL);
if (unlikely (tmp->status))
return tmp->status;
compositor->composite (tmp, CAIRO_OPERATOR_SOURCE, dst, NULL,
extents->bounded.x, extents->bounded.y,
0, 0,
0, 0,
extents->bounded.width, extents->bounded.height);
status = draw_func (compositor, tmp, draw_closure, op,
pattern, &extents->source_sample_area,
extents->bounded.x, extents->bounded.y,
&extents->bounded, NULL);
if (unlikely (status))
goto cleanup;
clip = get_clip_source (compositor,
extents->clip, dst, &extents->bounded,
&clip_x, &clip_y);
if (unlikely ((status = clip->status)))
goto cleanup;
if (dst->is_clear) {
compositor->composite (dst, CAIRO_OPERATOR_SOURCE, tmp, clip,
0, 0,
clip_x, clip_y,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
} else {
/* Punch the clip out of the destination */
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, clip, NULL,
clip_x, clip_y,
0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
/* Now add the two results together */
compositor->composite (dst, CAIRO_OPERATOR_ADD, tmp, clip,
0, 0,
clip_x, clip_y,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
}
cairo_surface_destroy (clip);
cleanup:
cairo_surface_destroy (tmp);
return status;
}
/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's
* defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip))
*/
static cairo_status_t
clip_and_composite_source (const cairo_mask_compositor_t *compositor,
void *draw_closure,
draw_func_t draw_func,
draw_func_t mask_func,
cairo_pattern_t *pattern,
const cairo_composite_rectangles_t *extents)
{
cairo_surface_t *dst = extents->surface;
cairo_surface_t *mask, *src;
int src_x, src_y;
/* Create a surface that is mask IN clip */
mask = create_composite_mask (compositor, dst, draw_closure,
draw_func, mask_func,
extents);
if (unlikely (mask->status))
return mask->status;
src = compositor->pattern_to_surface (dst,
pattern,
FALSE,
&extents->bounded,
&extents->source_sample_area,
&src_x, &src_y);
if (unlikely (src->status)) {
cairo_surface_destroy (mask);
return src->status;
}
if (dst->is_clear) {
compositor->composite (dst, CAIRO_OPERATOR_SOURCE, src, mask,
extents->bounded.x + src_x, extents->bounded.y + src_y,
0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
} else {
/* Compute dest' = dest OUT (mask IN clip) */
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,
0, 0, 0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
/* Now compute (src IN (mask IN clip)) ADD dest' */
compositor->composite (dst, CAIRO_OPERATOR_ADD, src, mask,
extents->bounded.x + src_x, extents->bounded.y + src_y,
0, 0,
extents->bounded.x, extents->bounded.y,
extents->bounded.width, extents->bounded.height);
}
cairo_surface_destroy (src);
cairo_surface_destroy (mask);
return CAIRO_STATUS_SUCCESS;
}
static cairo_bool_t
can_reduce_alpha_op (cairo_operator_t op)
{
int iop = op;
switch (iop) {
case CAIRO_OPERATOR_OVER:
case CAIRO_OPERATOR_SOURCE:
case CAIRO_OPERATOR_ADD:
return TRUE;
default:
return FALSE;
}
}
static cairo_bool_t
reduce_alpha_op (cairo_surface_t *dst,
cairo_operator_t op,
const cairo_pattern_t *pattern)
{
return dst->is_clear &&
dst->content == CAIRO_CONTENT_ALPHA &&
_cairo_pattern_is_opaque_solid (pattern) &&
can_reduce_alpha_op (op);
}
static cairo_status_t
fixup_unbounded (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
const cairo_composite_rectangles_t *extents)
{
cairo_rectangle_int_t rects[4];
int n;
if (extents->bounded.width == extents->unbounded.width &&
extents->bounded.height == extents->unbounded.height)
{
return CAIRO_STATUS_SUCCESS;
}
n = 0;
if (extents->bounded.width == 0 || extents->bounded.height == 0) {
rects[n].x = extents->unbounded.x;
rects[n].width = extents->unbounded.width;
rects[n].y = extents->unbounded.y;
rects[n].height = extents->unbounded.height;
n++;
} else {
/* top */
if (extents->bounded.y != extents->unbounded.y) {
rects[n].x = extents->unbounded.x;
rects[n].width = extents->unbounded.width;
rects[n].y = extents->unbounded.y;
rects[n].height = extents->bounded.y - extents->unbounded.y;
n++;
}
/* left */
if (extents->bounded.x != extents->unbounded.x) {
rects[n].x = extents->unbounded.x;
rects[n].width = extents->bounded.x - extents->unbounded.x;
rects[n].y = extents->bounded.y;
rects[n].height = extents->bounded.height;
n++;
}
/* right */
if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) {
rects[n].x = extents->bounded.x + extents->bounded.width;
rects[n].width = extents->unbounded.x + extents->unbounded.width - rects[n].x;
rects[n].y = extents->bounded.y;
rects[n].height = extents->bounded.height;
n++;
}
/* bottom */
if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) {
rects[n].x = extents->unbounded.x;
rects[n].width = extents->unbounded.width;
rects[n].y = extents->bounded.y + extents->bounded.height;
rects[n].height = extents->unbounded.y + extents->unbounded.height - rects[n].y;
n++;
}
}
return compositor->fill_rectangles (dst, CAIRO_OPERATOR_CLEAR,
CAIRO_COLOR_TRANSPARENT,
rects, n);
}
static cairo_status_t
fixup_unbounded_with_mask (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
const cairo_composite_rectangles_t *extents)
{
cairo_surface_t *mask;
int mask_x, mask_y;
mask = get_clip_source (compositor,
extents->clip, dst, &extents->unbounded,
&mask_x, &mask_y);
if (unlikely (mask->status))
return mask->status;
/* top */
if (extents->bounded.y != extents->unbounded.y) {
int x = extents->unbounded.x;
int y = extents->unbounded.y;
int width = extents->unbounded.width;
int height = extents->bounded.y - y;
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,
x + mask_x, y + mask_y,
0, 0,
x, y,
width, height);
}
/* left */
if (extents->bounded.x != extents->unbounded.x) {
int x = extents->unbounded.x;
int y = extents->bounded.y;
int width = extents->bounded.x - x;
int height = extents->bounded.height;
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,
x + mask_x, y + mask_y,
0, 0,
x, y,
width, height);
}
/* right */
if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) {
int x = extents->bounded.x + extents->bounded.width;
int y = extents->bounded.y;
int width = extents->unbounded.x + extents->unbounded.width - x;
int height = extents->bounded.height;
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,
x + mask_x, y + mask_y,
0, 0,
x, y,
width, height);
}
/* bottom */
if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) {
int x = extents->unbounded.x;
int y = extents->bounded.y + extents->bounded.height;
int width = extents->unbounded.width;
int height = extents->unbounded.y + extents->unbounded.height - y;
compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,
x + mask_x, y + mask_y,
0, 0,
x, y,
width, height);
}
cairo_surface_destroy (mask);
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
fixup_unbounded_boxes (const cairo_mask_compositor_t *compositor,
const cairo_composite_rectangles_t *extents,
cairo_boxes_t *boxes)
{
cairo_surface_t *dst = extents->surface;
cairo_boxes_t clear;
cairo_region_t *clip_region;
cairo_box_t box;
cairo_status_t status;
struct _cairo_boxes_chunk *chunk;
int i;
assert (boxes->is_pixel_aligned);
clip_region = NULL;
if (_cairo_clip_is_region (extents->clip) &&
(clip_region = _cairo_clip_get_region (extents->clip)) &&
cairo_region_contains_rectangle (clip_region,
&extents->bounded) == CAIRO_REGION_OVERLAP_IN)
clip_region = NULL;
if (boxes->num_boxes <= 1 && clip_region == NULL)
return fixup_unbounded (compositor, dst, extents);
_cairo_boxes_init (&clear);
box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width);
box.p1.y = _cairo_fixed_from_int (extents->unbounded.y);
box.p2.x = _cairo_fixed_from_int (extents->unbounded.x);
box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height);
if (clip_region == NULL) {
cairo_boxes_t tmp;
_cairo_boxes_init (&tmp);
status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box);
assert (status == CAIRO_STATUS_SUCCESS);
tmp.chunks.next = &boxes->chunks;
tmp.num_boxes += boxes->num_boxes;
status = _cairo_bentley_ottmann_tessellate_boxes (&tmp,
CAIRO_FILL_RULE_WINDING,
&clear);
tmp.chunks.next = NULL;
} else {
pixman_box32_t *pbox;
pbox = pixman_region32_rectangles (&clip_region->rgn, &i);
_cairo_boxes_limit (&clear, (cairo_box_t *) pbox, i);
status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box);
assert (status == CAIRO_STATUS_SUCCESS);
for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
for (i = 0; i < chunk->count; i++) {
status = _cairo_boxes_add (&clear,
CAIRO_ANTIALIAS_DEFAULT,
&chunk->base[i]);
if (unlikely (status)) {
_cairo_boxes_fini (&clear);
return status;
}
}
}
status = _cairo_bentley_ottmann_tessellate_boxes (&clear,
CAIRO_FILL_RULE_WINDING,
&clear);
}
if (likely (status == CAIRO_STATUS_SUCCESS)) {
status = compositor->fill_boxes (dst,
CAIRO_OPERATOR_CLEAR,
CAIRO_COLOR_TRANSPARENT,
&clear);
}
_cairo_boxes_fini (&clear);
return status;
}
enum {
NEED_CLIP_REGION = 0x1,
NEED_CLIP_SURFACE = 0x2,
FORCE_CLIP_REGION = 0x4,
};
static cairo_bool_t
need_bounded_clip (cairo_composite_rectangles_t *extents)
{
unsigned int flags = NEED_CLIP_REGION;
if (! _cairo_clip_is_region (extents->clip))
flags |= NEED_CLIP_SURFACE;
return flags;
}
static cairo_bool_t
need_unbounded_clip (cairo_composite_rectangles_t *extents)
{
unsigned int flags = 0;
if (! extents->is_bounded) {
flags |= NEED_CLIP_REGION;
if (! _cairo_clip_is_region (extents->clip))
flags |= NEED_CLIP_SURFACE;
}
if (extents->clip->path != NULL)
flags |= NEED_CLIP_SURFACE;
return flags;
}
static cairo_status_t
clip_and_composite (const cairo_mask_compositor_t *compositor,
draw_func_t draw_func,
draw_func_t mask_func,
void *draw_closure,
cairo_composite_rectangles_t*extents,
unsigned int need_clip)
{
cairo_surface_t *dst = extents->surface;
cairo_operator_t op = extents->op;
cairo_pattern_t *src = &extents->source_pattern.base;
cairo_region_t *clip_region = NULL;
cairo_status_t status;
compositor->acquire (dst);
if (need_clip & NEED_CLIP_REGION) {
clip_region = _cairo_clip_get_region (extents->clip);
if ((need_clip & FORCE_CLIP_REGION) == 0 &&
_cairo_composite_rectangles_can_reduce_clip (extents,
extents->clip))
clip_region = NULL;
if (clip_region != NULL) {
status = compositor->set_clip_region (dst, clip_region);
if (unlikely (status)) {
compositor->release (dst);
return status;
}
}
}
if (reduce_alpha_op (dst, op, &extents->source_pattern.base)) {
op = CAIRO_OPERATOR_ADD;
src = NULL;
}
if (op == CAIRO_OPERATOR_SOURCE) {
status = clip_and_composite_source (compositor,
draw_closure, draw_func, mask_func,
src, extents);
} else {
if (op == CAIRO_OPERATOR_CLEAR) {
op = CAIRO_OPERATOR_DEST_OUT;
src = NULL;
}
if (need_clip & NEED_CLIP_SURFACE) {
if (extents->is_bounded) {
status = clip_and_composite_with_mask (compositor,
draw_closure,
draw_func,
mask_func,
op, src, extents);
} else {
status = clip_and_composite_combine (compositor,
draw_closure,
draw_func,
op, src, extents);
}
} else {
status = draw_func (compositor,
dst, draw_closure,
op, src, &extents->source_sample_area,
0, 0,
&extents->bounded,
extents->clip);
}
}
if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) {
if (need_clip & NEED_CLIP_SURFACE)
status = fixup_unbounded_with_mask (compositor, dst, extents);
else
status = fixup_unbounded (compositor, dst, extents);
}
if (clip_region)
compositor->set_clip_region (dst, NULL);
compositor->release (dst);
return status;
}
static cairo_int_status_t
trim_extents_to_boxes (cairo_composite_rectangles_t *extents,
cairo_boxes_t *boxes)
{
cairo_box_t box;
_cairo_boxes_extents (boxes, &box);
return _cairo_composite_rectangles_intersect_mask_extents (extents, &box);
}
static cairo_status_t
upload_boxes (const cairo_mask_compositor_t *compositor,
cairo_composite_rectangles_t *extents,
cairo_boxes_t *boxes)
{
cairo_surface_t *dst = extents->surface;
const cairo_pattern_t *source = &extents->source_pattern.base;
cairo_surface_t *src;
cairo_rectangle_int_t limit;
cairo_int_status_t status;
int tx, ty;
src = _cairo_pattern_get_source ((cairo_surface_pattern_t *)source, &limit);
if (!(src->type == CAIRO_SURFACE_TYPE_IMAGE || src->type == dst->type))
return CAIRO_INT_STATUS_UNSUPPORTED;
if (! _cairo_matrix_is_integer_translation (&source->matrix, &tx, &ty))
return CAIRO_INT_STATUS_UNSUPPORTED;
/* Check that the data is entirely within the image */
if (extents->bounded.x + tx < limit.x || extents->bounded.y + ty < limit.y)
return CAIRO_INT_STATUS_UNSUPPORTED;
if (extents->bounded.x + extents->bounded.width + tx > limit.x + limit.width ||
extents->bounded.y + extents->bounded.height + ty > limit.y + limit.height)
return CAIRO_INT_STATUS_UNSUPPORTED;
tx += limit.x;
ty += limit.y;
if (src->type == CAIRO_SURFACE_TYPE_IMAGE)
status = compositor->draw_image_boxes (dst,
(cairo_image_surface_t *)src,
boxes, tx, ty);
else
status = compositor->copy_boxes (dst, src, boxes, &extents->bounded,
tx, ty);
return status;
}
static cairo_status_t
composite_boxes (const cairo_mask_compositor_t *compositor,
const cairo_composite_rectangles_t *extents,
cairo_boxes_t *boxes)
{
cairo_surface_t *dst = extents->surface;
cairo_operator_t op = extents->op;
const cairo_pattern_t *source = &extents->source_pattern.base;
cairo_bool_t need_clip_mask = extents->clip->path != NULL;
cairo_status_t status;
if (need_clip_mask &&
(! extents->is_bounded || op == CAIRO_OPERATOR_SOURCE))
{
return CAIRO_INT_STATUS_UNSUPPORTED;
}
status = compositor->acquire (dst);
if (unlikely (status))
return status;
if (! need_clip_mask && source->type == CAIRO_PATTERN_TYPE_SOLID) {
const cairo_color_t *color;
color = &((cairo_solid_pattern_t *) source)->color;
status = compositor->fill_boxes (dst, op, color, boxes);
} else {
cairo_surface_t *src, *mask = NULL;
int src_x, src_y;
int mask_x = 0, mask_y = 0;
if (need_clip_mask) {
mask = get_clip_source (compositor,
extents->clip, dst, &extents->bounded,
&mask_x, &mask_y);
if (unlikely (mask->status))
return mask->status;
if (op == CAIRO_OPERATOR_CLEAR) {
source = NULL;
op = CAIRO_OPERATOR_DEST_OUT;
}
}
if (source || mask == NULL) {
src = compositor->pattern_to_surface (dst, source, FALSE,
&extents->bounded,
&extents->source_sample_area,
&src_x, &src_y);
} else {
src = mask;
src_x = mask_x;
src_y = mask_y;
mask = NULL;
}
status = compositor->composite_boxes (dst, op, src, mask,
src_x, src_y,
mask_x, mask_y,
0, 0,
boxes, &extents->bounded);
cairo_surface_destroy (src);
cairo_surface_destroy (mask);
}
if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded)
status = fixup_unbounded_boxes (compositor, extents, boxes);
compositor->release (dst);
return status;
}
static cairo_status_t
clip_and_composite_boxes (const cairo_mask_compositor_t *compositor,
cairo_composite_rectangles_t *extents,
cairo_boxes_t *boxes)
{
cairo_surface_t *dst = extents->surface;
cairo_int_status_t status;
if (boxes->num_boxes == 0) {
if (extents->is_bounded)
return CAIRO_STATUS_SUCCESS;
return fixup_unbounded_boxes (compositor, extents, boxes);
}
if (! boxes->is_pixel_aligned)
return CAIRO_INT_STATUS_UNSUPPORTED;
status = trim_extents_to_boxes (extents, boxes);
if (unlikely (status))
return status;
if (extents->source_pattern.base.type == CAIRO_PATTERN_TYPE_SURFACE &&
extents->clip->path == NULL &&
(extents->op == CAIRO_OPERATOR_SOURCE ||
(dst->is_clear && (extents->op == CAIRO_OPERATOR_OVER ||
extents->op == CAIRO_OPERATOR_ADD))))
{
status = upload_boxes (compositor, extents, boxes);
if (status != CAIRO_INT_STATUS_UNSUPPORTED)
return status;
}
return composite_boxes (compositor, extents, boxes);
}
/* high-level compositor interface */
static cairo_int_status_t
_cairo_mask_compositor_paint (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents)
{
cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;
cairo_boxes_t boxes;
cairo_int_status_t status;
status = compositor->check_composite (extents);
if (unlikely (status))
return status;
_cairo_clip_steal_boxes (extents->clip, &boxes);
status = clip_and_composite_boxes (compositor, extents, &boxes);
_cairo_clip_unsteal_boxes (extents->clip, &boxes);
return status;
}
struct composite_opacity_info {
const cairo_mask_compositor_t *compositor;
uint8_t op;
cairo_surface_t *dst;
cairo_surface_t *src;
int src_x, src_y;
double opacity;
};
static void composite_opacity(void *closure,
int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t coverage)
{
struct composite_opacity_info *info = closure;
const cairo_mask_compositor_t *compositor = info->compositor;
cairo_surface_t *mask;
int mask_x, mask_y;
cairo_color_t color;
cairo_solid_pattern_t solid;
_cairo_color_init_rgba (&color, 0, 0, 0, info->opacity * coverage);
_cairo_pattern_init_solid (&solid, &color);
mask = compositor->pattern_to_surface (info->dst, &solid.base, TRUE,
&_cairo_unbounded_rectangle,
&_cairo_unbounded_rectangle,
&mask_x, &mask_y);
if (likely (mask->status == CAIRO_STATUS_SUCCESS)) {
if (info->src) {
compositor->composite (info->dst, info->op, info->src, mask,
x + info->src_x, y + info->src_y,
mask_x, mask_y,
x, y,
w, h);
} else {
compositor->composite (info->dst, info->op, mask, NULL,
mask_x, mask_y,
0, 0,
x, y,
w, h);
}
}
cairo_surface_destroy (mask);
}
static cairo_int_status_t
composite_opacity_boxes (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *src_pattern,
const cairo_rectangle_int_t *src_sample,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_clip_t *clip)
{
const cairo_solid_pattern_t *mask_pattern = closure;
struct composite_opacity_info info;
int i;
assert (clip);
info.compositor = compositor;
info.op = op;
info.dst = dst;
if (src_pattern != NULL) {
info.src = compositor->pattern_to_surface (dst, src_pattern, FALSE,
extents, src_sample,
&info.src_x, &info.src_y);
if (unlikely (info.src->status))
return info.src->status;
} else
info.src = NULL;
info.opacity = mask_pattern->color.alpha / (double) 0xffff;
/* XXX for lots of boxes create a clip region for the fully opaque areas */
for (i = 0; i < clip->num_boxes; i++)
do_unaligned_box(composite_opacity, &info,
&clip->boxes[i], dst_x, dst_y);
cairo_surface_destroy (info.src);
return CAIRO_STATUS_SUCCESS;
}
struct composite_box_info {
const cairo_mask_compositor_t *compositor;
cairo_surface_t *dst;
cairo_surface_t *src;
int src_x, src_y;
uint8_t op;
};
static void composite_box(void *closure,
int16_t x, int16_t y,
int16_t w, int16_t h,
uint16_t coverage)
{
struct composite_box_info *info = closure;
const cairo_mask_compositor_t *compositor = info->compositor;
if (! CAIRO_ALPHA_SHORT_IS_OPAQUE (coverage)) {
cairo_surface_t *mask;
cairo_color_t color;
cairo_solid_pattern_t solid;
int mask_x, mask_y;
_cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double)0xffff);
_cairo_pattern_init_solid (&solid, &color);
mask = compositor->pattern_to_surface (info->dst, &solid.base, FALSE,
&_cairo_unbounded_rectangle,
&_cairo_unbounded_rectangle,
&mask_x, &mask_y);
if (likely (mask->status == CAIRO_STATUS_SUCCESS)) {
compositor->composite (info->dst, info->op, info->src, mask,
x + info->src_x, y + info->src_y,
mask_x, mask_y,
x, y,
w, h);
}
cairo_surface_destroy (mask);
} else {
compositor->composite (info->dst, info->op, info->src, NULL,
x + info->src_x, y + info->src_y,
0, 0,
x, y,
w, h);
}
}
static cairo_int_status_t
composite_mask_clip_boxes (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *src_pattern,
const cairo_rectangle_int_t *src_sample,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_clip_t *clip)
{
cairo_composite_rectangles_t *composite = closure;
struct composite_box_info info;
int i;
assert (src_pattern == NULL);
assert (op == CAIRO_OPERATOR_SOURCE);
info.compositor = compositor;
info.op = CAIRO_OPERATOR_SOURCE;
info.dst = dst;
info.src = compositor->pattern_to_surface (dst,
&composite->mask_pattern.base,
FALSE, extents,
&composite->mask_sample_area,
&info.src_x, &info.src_y);
if (unlikely (info.src->status))
return info.src->status;
info.src_x += dst_x;
info.src_y += dst_y;
for (i = 0; i < clip->num_boxes; i++)
do_unaligned_box(composite_box, &info, &clip->boxes[i], dst_x, dst_y);
cairo_surface_destroy (info.src);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
composite_mask (const cairo_mask_compositor_t *compositor,
cairo_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *src_pattern,
const cairo_rectangle_int_t *src_sample,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents,
cairo_clip_t *clip)
{
cairo_composite_rectangles_t *composite = closure;
cairo_surface_t *src, *mask;
int src_x, src_y;
int mask_x, mask_y;
if (src_pattern != NULL) {
src = compositor->pattern_to_surface (dst, src_pattern, FALSE,
extents, src_sample,
&src_x, &src_y);
if (unlikely (src->status))
return src->status;
mask = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, TRUE,
extents, &composite->mask_sample_area,
&mask_x, &mask_y);
if (unlikely (mask->status)) {
cairo_surface_destroy (src);
return mask->status;
}
compositor->composite (dst, op, src, mask,
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);
cairo_surface_destroy (mask);
cairo_surface_destroy (src);
} else {
src = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, FALSE,
extents, &composite->mask_sample_area,
&src_x, &src_y);
if (unlikely (src->status))
return src->status;
compositor->composite (dst, op, src, NULL,
extents->x + src_x, extents->y + src_y,
0, 0,
extents->x - dst_x, extents->y - dst_y,
extents->width, extents->height);
cairo_surface_destroy (src);
}
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
_cairo_mask_compositor_mask (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents)
{
const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;
cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
status = compositor->check_composite (extents);
if (unlikely (status))
return status;
if (extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&
extents->clip->path == NULL &&
_cairo_clip_is_region (extents->clip)) {
status = clip_and_composite (compositor,
composite_opacity_boxes,
composite_opacity_boxes,
&extents->mask_pattern.solid,
extents, need_unbounded_clip (extents));
} else {
status = clip_and_composite (compositor,
composite_mask,
extents->clip->path == NULL ? composite_mask_clip_boxes : NULL,
extents,
extents, need_bounded_clip (extents));
}
return status;
}
static cairo_int_status_t
_cairo_mask_compositor_stroke (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents,
const cairo_path_fixed_t *path,
const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
const cairo_matrix_t *ctm_inverse,
double tolerance,
cairo_antialias_t antialias)
{
const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;
cairo_surface_t *mask;
cairo_surface_pattern_t pattern;
cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
status = compositor->check_composite (extents);
if (unlikely (status))
return status;
if (_cairo_path_fixed_stroke_is_rectilinear (path)) {
cairo_boxes_t boxes;
_cairo_boxes_init_with_clip (&boxes, extents->clip);
status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,
style,
ctm,
antialias,
&boxes);
if (likely (status == CAIRO_INT_STATUS_SUCCESS))
status = clip_and_composite_boxes (compositor, extents, &boxes);
_cairo_boxes_fini (&boxes);
}
if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
mask = cairo_surface_create_similar_image (extents->surface,
CAIRO_FORMAT_A8,
extents->bounded.width,
extents->bounded.height);
if (unlikely (mask->status))
return mask->status;
status = _cairo_surface_offset_stroke (mask,
extents->bounded.x,
extents->bounded.y,
CAIRO_OPERATOR_ADD,
&_cairo_pattern_white.base,
path, style, ctm, ctm_inverse,
tolerance, antialias,
extents->clip);
if (unlikely (status)) {
cairo_surface_destroy (mask);
return status;
}
_cairo_pattern_init_for_surface (&pattern, mask);
cairo_surface_destroy (mask);
cairo_matrix_init_translate (&pattern.base.matrix,
-extents->bounded.x,
-extents->bounded.y);
pattern.base.filter = CAIRO_FILTER_NEAREST;
pattern.base.extend = CAIRO_EXTEND_NONE;
status = _cairo_surface_mask (extents->surface,
extents->op,
&extents->source_pattern.base,
&pattern.base,
extents->clip);
_cairo_pattern_fini (&pattern.base);
}
return status;
}
static cairo_int_status_t
_cairo_mask_compositor_fill (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents,
const cairo_path_fixed_t *path,
cairo_fill_rule_t fill_rule,
double tolerance,
cairo_antialias_t antialias)
{
const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;
cairo_surface_t *mask;
cairo_surface_pattern_t pattern;
cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
status = compositor->check_composite (extents);
if (unlikely (status))
return status;
if (_cairo_path_fixed_fill_is_rectilinear (path)) {
cairo_boxes_t boxes;
_cairo_boxes_init_with_clip (&boxes, extents->clip);
status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,
fill_rule,
antialias,
&boxes);
if (likely (status == CAIRO_INT_STATUS_SUCCESS))
status = clip_and_composite_boxes (compositor, extents, &boxes);
_cairo_boxes_fini (&boxes);
}
if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
mask = cairo_surface_create_similar_image (extents->surface,
CAIRO_FORMAT_A8,
extents->bounded.width,
extents->bounded.height);
if (unlikely (mask->status))
return mask->status;
status = _cairo_surface_offset_fill (mask,
extents->bounded.x,
extents->bounded.y,
CAIRO_OPERATOR_ADD,
&_cairo_pattern_white.base,
path, fill_rule, tolerance, antialias,
extents->clip);
if (unlikely (status)) {
cairo_surface_destroy (mask);
return status;
}
_cairo_pattern_init_for_surface (&pattern, mask);
cairo_surface_destroy (mask);
cairo_matrix_init_translate (&pattern.base.matrix,
-extents->bounded.x,
-extents->bounded.y);
pattern.base.filter = CAIRO_FILTER_NEAREST;
pattern.base.extend = CAIRO_EXTEND_NONE;
status = _cairo_surface_mask (extents->surface,
extents->op,
&extents->source_pattern.base,
&pattern.base,
extents->clip);
_cairo_pattern_fini (&pattern.base);
}
return status;
}
static cairo_int_status_t
_cairo_mask_compositor_glyphs (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents,
cairo_scaled_font_t *scaled_font,
cairo_glyph_t *glyphs,
int num_glyphs,
cairo_bool_t overlap)
{
const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;
cairo_surface_t *mask;
cairo_surface_pattern_t pattern;
cairo_int_status_t status;
status = compositor->check_composite (extents);
if (unlikely (status))
return CAIRO_INT_STATUS_UNSUPPORTED;
mask = cairo_surface_create_similar_image (extents->surface,
CAIRO_FORMAT_A8,
extents->bounded.width,
extents->bounded.height);
if (unlikely (mask->status))
return mask->status;
status = _cairo_surface_offset_glyphs (mask,
extents->bounded.x,
extents->bounded.y,
CAIRO_OPERATOR_ADD,
&_cairo_pattern_white.base,
scaled_font, glyphs, num_glyphs,
extents->clip);
if (unlikely (status)) {
cairo_surface_destroy (mask);
return status;
}
_cairo_pattern_init_for_surface (&pattern, mask);
cairo_surface_destroy (mask);
cairo_matrix_init_translate (&pattern.base.matrix,
-extents->bounded.x,
-extents->bounded.y);
pattern.base.filter = CAIRO_FILTER_NEAREST;
pattern.base.extend = CAIRO_EXTEND_NONE;
status = _cairo_surface_mask (extents->surface,
extents->op,
&extents->source_pattern.base,
&pattern.base,
extents->clip);
_cairo_pattern_fini (&pattern.base);
return status;
}
void
_cairo_mask_compositor_init (cairo_mask_compositor_t *compositor,
const cairo_compositor_t *delegate)
{
compositor->base.delegate = delegate;
compositor->base.paint = _cairo_mask_compositor_paint;
compositor->base.mask = _cairo_mask_compositor_mask;
compositor->base.fill = _cairo_mask_compositor_fill;
compositor->base.stroke = _cairo_mask_compositor_stroke;
compositor->base.glyphs = _cairo_mask_compositor_glyphs;
}