switch to tinyobj and nanovg from assimp and cairo

1 files changed, 0 insertions, 1481 deletions

diff --git a/libs/cairo-1.16.0/src/cairo-mask-compositor.c b/libs/cairo-1.16.0/src/cairo-mask-compositor.c
deleted file mode 100644
index 4d6b118..0000000
--- a/libs/cairo-1.16.0/src/cairo-mask-compositor.c
+++ /dev/null
@@ -1,1481 +0,0 @@
-/* -*- 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;
-}