SSL cairo-spans-compositor.c   Interaktion und
Portierbarkeitunbekannt

/* -*- 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>
 */

#include "cairoint.h"

#include "cairo-compositor-private.h"
#include "cairo-clip-inline.h"
#include "cairo-clip-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-paginated-private.h"
#include "cairo-pattern-inline.h"
#include "cairo-region-private.h"
#include "cairo-recording-surface-inline.h"
#include "cairo-spans-compositor-private.h"
#include "cairo-surface-subsurface-private.h"
#include "cairo-surface-snapshot-private.h"
#include "cairo-surface-observer-private.h"

typedef struct {
    cairo_polygon_t *polygon;
    cairo_fill_rule_t  fill_rule;
    cairo_antialias_t  antialias;
} composite_spans_info_t;

static cairo_int_status_t
composite_polygon (const cairo_spans_compositor_t *compositor,
     cairo_composite_rectangles_t   *extents,
     cairo_polygon_t   *polygon,
     cairo_fill_rule_t    fill_rule,
     cairo_antialias_t    antialias);

static cairo_int_status_t
composite_boxes (const cairo_spans_compositor_t *compositor,
   cairo_composite_rectangles_t *extents,
   cairo_boxes_t  *boxes);

static cairo_int_status_t
clip_and_composite_polygon (const cairo_spans_compositor_t *compositor,
       cairo_composite_rectangles_t  *extents,
       cairo_polygon_t   *polygon,
       cairo_fill_rule_t    fill_rule,
       cairo_antialias_t    antialias);
static cairo_surface_t *
get_clip_surface (const cairo_spans_compositor_t *compositor,
    cairo_surface_t *dst,
    const cairo_clip_t *clip,
    const cairo_rectangle_int_t *extents)
{
    cairo_composite_rectangles_t composite;
    cairo_surface_t *surface;
    cairo_box_t box;
    cairo_polygon_t polygon;
    const cairo_clip_path_t *clip_path;
    cairo_antialias_t antialias;
    cairo_fill_rule_t fill_rule;
    cairo_int_status_t status;

    assert (clip->path);

    surface = _cairo_surface_create_scratch (dst,
          CAIRO_CONTENT_ALPHA,
          extents->width,
          extents->height,
          CAIRO_COLOR_TRANSPARENT);

    _cairo_box_from_rectangle (&box, extents);
    _cairo_polygon_init (&polygon, &box, 1);

    clip_path = clip->path;
    status = _cairo_path_fixed_fill_to_polygon (&clip_path->path,
      clip_path->tolerance,
      &polygon);
    if (unlikely (status))
 goto cleanup_polygon;

    polygon.num_limits = 0;

    antialias = clip_path->antialias;
    fill_rule = clip_path->fill_rule;

    if (clip->boxes) {
 cairo_polygon_t intersect;
 cairo_boxes_t tmp;

 _cairo_boxes_init_for_array (&tmp, clip->boxes, clip->num_boxes);
 status= _cairo_polygon_init_boxes (&intersect, &tmp);
 if (unlikely (status))
     goto cleanup_polygon;

 status = _cairo_polygon_intersect (&polygon, fill_rule,
        &intersect, CAIRO_FILL_RULE_WINDING);
 _cairo_polygon_fini (&intersect);

 if (unlikely (status))
     goto cleanup_polygon;

 fill_rule = CAIRO_FILL_RULE_WINDING;
    }

    polygon.limits = NULL;
    polygon.num_limits = 0;

    clip_path = clip_path->prev;
    while (clip_path) {
 if (clip_path->antialias == antialias) {
     cairo_polygon_t next;

     _cairo_polygon_init (&next, NULL, 0);
     status = _cairo_path_fixed_fill_to_polygon (&clip_path->path,
       clip_path->tolerance,
       &next);
     if (likely (status == CAIRO_INT_STATUS_SUCCESS))
  status = _cairo_polygon_intersect (&polygon, fill_rule,
         &next, clip_path->fill_rule);
     _cairo_polygon_fini (&next);
     if (unlikely (status))
  goto cleanup_polygon;

     fill_rule = CAIRO_FILL_RULE_WINDING;
 }

 clip_path = clip_path->prev;
    }

    _cairo_polygon_translate (&polygon, -extents->x, -extents->y);
    status = _cairo_composite_rectangles_init_for_polygon (&composite, surface,
          CAIRO_OPERATOR_ADD,
          &_cairo_pattern_white.base,
          &polygon,
          NULL);
    if (unlikely (status))
 goto cleanup_polygon;

    status = composite_polygon (compositor, &composite,
    &polygon, fill_rule, antialias);
    _cairo_composite_rectangles_fini (&composite);
    _cairo_polygon_fini (&polygon);
    if (unlikely (status))
 goto error;

    _cairo_polygon_init (&polygon, &box, 1);

    clip_path = clip->path;
    antialias = clip_path->antialias == CAIRO_ANTIALIAS_DEFAULT ? CAIRO_ANTIALIAS_NONE : CAIRO_ANTIALIAS_DEFAULT;
    clip_path = clip_path->prev;
    while (clip_path) {
 if (clip_path->antialias == antialias) {
     if (polygon.num_edges == 0) {
  status = _cairo_path_fixed_fill_to_polygon (&clip_path->path,
           clip_path->tolerance,
           &polygon);

  fill_rule = clip_path->fill_rule;
  polygon.limits = NULL;
  polygon.num_limits = 0;
     } else {
  cairo_polygon_t next;

  _cairo_polygon_init (&next, NULL, 0);
  status = _cairo_path_fixed_fill_to_polygon (&clip_path->path,
           clip_path->tolerance,
           &next);
  if (likely (status == CAIRO_INT_STATUS_SUCCESS))
      status = _cairo_polygon_intersect (&polygon, fill_rule,
             &next, clip_path->fill_rule);
  _cairo_polygon_fini (&next);
  fill_rule = CAIRO_FILL_RULE_WINDING;
     }
     if (unlikely (status))
  goto error;
 }

 clip_path = clip_path->prev;
    }

    if (polygon.num_edges) {
 _cairo_polygon_translate (&polygon, -extents->x, -extents->y);
 status = _cairo_composite_rectangles_init_for_polygon (&composite, surface,
              CAIRO_OPERATOR_IN,
              &_cairo_pattern_white.base,
              &polygon,
              NULL);
 if (unlikely (status))
     goto cleanup_polygon;

 status = composite_polygon (compositor, &composite,
        &polygon, fill_rule, antialias);
 _cairo_composite_rectangles_fini (&composite);
 _cairo_polygon_fini (&polygon);
 if (unlikely (status))
     goto error;
    }

    return surface;

cleanup_polygon:
    _cairo_polygon_fini (&polygon);
error:
    cairo_surface_destroy (surface);
    return _cairo_int_surface_create_in_error (status);
}

static cairo_int_status_t
fixup_unbounded_mask (const cairo_spans_compositor_t *compositor,
        const cairo_composite_rectangles_t *extents,
        cairo_boxes_t *boxes)
{
    cairo_composite_rectangles_t composite;
    cairo_surface_t *clip;
    cairo_int_status_t status;

    TRACE((stderr, "%s\n", __FUNCTION__));

    clip = get_clip_surface (compositor, extents->surface, extents->clip,
        &extents->unbounded);
    if (unlikely (clip->status)) {
 if ((cairo_int_status_t)clip->status == CAIRO_INT_STATUS_NOTHING_TO_DO)
     return CAIRO_STATUS_SUCCESS;

 return clip->status;
    }

    status = _cairo_composite_rectangles_init_for_boxes (&composite,
        extents->surface,
        CAIRO_OPERATOR_CLEAR,
        &_cairo_pattern_clear.base,
        boxes,
        NULL);
    if (unlikely (status))
 goto cleanup_clip;

    _cairo_pattern_init_for_surface (&composite.mask_pattern.surface, clip);
    composite.mask_pattern.base.filter = CAIRO_FILTER_NEAREST;
    composite.mask_pattern.base.extend = CAIRO_EXTEND_NONE;

    status = composite_boxes (compositor, &composite, boxes);

    _cairo_pattern_fini (&composite.mask_pattern.base);
    _cairo_composite_rectangles_fini (&composite);

cleanup_clip:
    cairo_surface_destroy (clip);
    return status;
}

static cairo_int_status_t
fixup_unbounded_polygon (const cairo_spans_compositor_t *compositor,
    const cairo_composite_rectangles_t *extents,
    cairo_boxes_t *boxes)
{
    cairo_polygon_t polygon, intersect;
    cairo_composite_rectangles_t composite;
    cairo_fill_rule_t fill_rule;
    cairo_antialias_t antialias;
    cairo_int_status_t status;

    TRACE((stderr, "%s\n", __FUNCTION__));

    /* Can we treat the clip as a regular clear-polygon and use it to fill? */
    status = _cairo_clip_get_polygon (extents->clip, &polygon,
          &fill_rule, &antialias);
    if (status == CAIRO_INT_STATUS_UNSUPPORTED)
 return status;

    status= _cairo_polygon_init_boxes (&intersect, boxes);
    if (unlikely (status))
 goto cleanup_polygon;

    status = _cairo_polygon_intersect (&polygon, fill_rule,
           &intersect, CAIRO_FILL_RULE_WINDING);
    _cairo_polygon_fini (&intersect);

    if (unlikely (status))
 goto cleanup_polygon;

    status = _cairo_composite_rectangles_init_for_polygon (&composite,
          extents->surface,
          CAIRO_OPERATOR_CLEAR,
          &_cairo_pattern_clear.base,
          &polygon,
          NULL);
    if (unlikely (status))
 goto cleanup_polygon;

    status = composite_polygon (compositor, &composite,
    &polygon, fill_rule, antialias);

    _cairo_composite_rectangles_fini (&composite);
cleanup_polygon:
    _cairo_polygon_fini (&polygon);

    return status;
}

static cairo_int_status_t
fixup_unbounded_boxes (const cairo_spans_compositor_t *compositor,
         const cairo_composite_rectangles_t *extents,
         cairo_boxes_t *boxes)
{
    cairo_boxes_t tmp, clear;
    cairo_box_t box;
    cairo_int_status_t status;

    assert (boxes->is_pixel_aligned);

    TRACE ((stderr, "%s\n", __FUNCTION__));
    if (extents->bounded.width  == extents->unbounded.width &&
 extents->bounded.height == extents->unbounded.height)
    {
 return CAIRO_STATUS_SUCCESS;
    }

    /* subtract the drawn boxes from the unbounded area */
    _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 (boxes->num_boxes) {
 _cairo_boxes_init (&tmp);

 status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box);
 assert (status == CAIRO_INT_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;
 if (unlikely (status))
     goto error;
    } else {
 box.p1.x = _cairo_fixed_from_int (extents->unbounded.x);
 box.p2.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width);

 status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box);
 assert (status == CAIRO_INT_STATUS_SUCCESS);
    }

    /* If we have a clip polygon, we need to intersect with that as well */
    if (extents->clip->path) {
 status = fixup_unbounded_polygon (compositor, extents, &clear);
 if (status == CAIRO_INT_STATUS_UNSUPPORTED)
     status = fixup_unbounded_mask (compositor, extents, &clear);
    } else {
 /* Otherwise just intersect with the clip boxes */
 if (extents->clip->num_boxes) {
     _cairo_boxes_init_for_array (&tmp,
      extents->clip->boxes,
      extents->clip->num_boxes);
     status = _cairo_boxes_intersect (&clear, &tmp, &clear);
     if (unlikely (status))
  goto error;
 }

 if (clear.is_pixel_aligned) {
     status = compositor->fill_boxes (extents->surface,
          CAIRO_OPERATOR_CLEAR,
          CAIRO_COLOR_TRANSPARENT,
          &clear);
 } else {
     cairo_composite_rectangles_t composite;

     status = _cairo_composite_rectangles_init_for_boxes (&composite,
         extents->surface,
         CAIRO_OPERATOR_CLEAR,
         &_cairo_pattern_clear.base,
         &clear,
         NULL);
     if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {
  status = composite_boxes (compositor, &composite, &clear);
  _cairo_composite_rectangles_fini (&composite);
     }
 }
    }

error:
    _cairo_boxes_fini (&clear);
    return status;
}

static cairo_surface_t *
unwrap_source (const cairo_pattern_t *pattern)
{
    cairo_rectangle_int_t limit;

    return _cairo_pattern_get_source ((cairo_surface_pattern_t *)pattern,
          &limit);
}

static cairo_bool_t
is_recording_pattern (const cairo_pattern_t *pattern)
{
    cairo_surface_t *surface;

    if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE)
 return FALSE;

    surface = ((const cairo_surface_pattern_t *) pattern)->surface;
    return _cairo_surface_is_recording (surface);
}

static cairo_bool_t
recording_pattern_contains_sample (const cairo_pattern_t *pattern,
       const cairo_rectangle_int_t *sample)
{
    cairo_recording_surface_t *surface;

    if (! is_recording_pattern (pattern))
 return FALSE;

    if (pattern->extend == CAIRO_EXTEND_NONE)
 return TRUE;

    surface = (cairo_recording_surface_t *) unwrap_source (pattern);
    if (surface->unbounded)
 return TRUE;

    return _cairo_rectangle_contains_rectangle (&surface->extents, sample);
}

static cairo_bool_t
op_reduces_to_source (const cairo_composite_rectangles_t *extents,
        cairo_bool_t no_mask)
{
    if (extents->op == CAIRO_OPERATOR_SOURCE)
 return TRUE;

    if (extents->surface->is_clear)
 return extents->op == CAIRO_OPERATOR_OVER || extents->op == CAIRO_OPERATOR_ADD;

    if (no_mask && extents->op == CAIRO_OPERATOR_OVER)
 return _cairo_pattern_is_opaque (&extents->source_pattern.base,
      &extents->source_sample_area);

    return FALSE;
}

static cairo_status_t
upload_boxes (const cairo_spans_compositor_t *compositor,
       const cairo_composite_rectangles_t *extents,
       cairo_boxes_t *boxes)
{
    cairo_surface_t *dst = extents->surface;
    const cairo_surface_pattern_t *source = &extents->source_pattern.surface;
    cairo_surface_t *src;
    cairo_rectangle_int_t limit;
    cairo_int_status_t status;
    int tx, ty;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    src = _cairo_pattern_get_source(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->base.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_bool_t
_clip_is_region (const cairo_clip_t *clip)
{
    int i;

    if (clip->is_region)
 return TRUE;

    if (clip->path)
 return FALSE;

    for (i = 0; i < clip->num_boxes; i++) {
 const cairo_box_t *b = &clip->boxes[i];
 if (!_cairo_fixed_is_integer (b->p1.x | b->p1.y |  b->p2.x | b->p2.y))
     return FALSE;
    }

    return TRUE;
}

static cairo_int_status_t
composite_aligned_boxes (const cairo_spans_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_int_status_t status;
    cairo_bool_t need_clip_mask = ! _clip_is_region (extents->clip);
    cairo_bool_t op_is_source;
    cairo_bool_t no_mask;
    cairo_bool_t inplace;

    TRACE ((stderr, "%s: need_clip_mask=%d, is-bounded=%d\n",
     __FUNCTION__, need_clip_mask, extents->is_bounded));
    if (need_clip_mask && ! extents->is_bounded) {
 TRACE ((stderr, "%s: unsupported clip\n", __FUNCTION__));
 return CAIRO_INT_STATUS_UNSUPPORTED;
    }

    no_mask = extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&
 CAIRO_COLOR_IS_OPAQUE (&extents->mask_pattern.solid.color);
    op_is_source = op_reduces_to_source (extents, no_mask);
    inplace = ! need_clip_mask && op_is_source && no_mask;

    TRACE ((stderr, "%s: op-is-source=%d [op=%d], no-mask=%d, inplace=%d\n",
     __FUNCTION__, op_is_source, op, no_mask, inplace));

    if (op == CAIRO_OPERATOR_SOURCE && (need_clip_mask || ! no_mask)) {
 /* SOURCE with a mask is actually a LERP in cairo semantics */
 if ((compositor->flags & CAIRO_SPANS_COMPOSITOR_HAS_LERP) == 0) {
     TRACE ((stderr, "%s: unsupported lerp\n", __FUNCTION__));
     return CAIRO_INT_STATUS_UNSUPPORTED;
 }
    }

    /* Are we just copying a recording surface? */
    if (inplace &&
 recording_pattern_contains_sample (&extents->source_pattern.base,
        &extents->source_sample_area))
    {
 cairo_clip_t *recording_clip;
 const cairo_pattern_t *source = &extents->source_pattern.base;
 const cairo_matrix_t *m;
 cairo_matrix_t matrix;

 /* XXX could also do tiling repeat modes... */

 /* first clear the area about to be overwritten */
 if (! dst->is_clear) {
     status = compositor->fill_boxes (dst,
          CAIRO_OPERATOR_CLEAR,
          CAIRO_COLOR_TRANSPARENT,
          boxes);
     if (unlikely (status))
  return status;

     dst->is_clear = TRUE;
 }

 m = &source->matrix;
 if (_cairo_surface_has_device_transform (dst)) {
     cairo_matrix_multiply (&matrix,
       &source->matrix,
       &dst->device_transform);
     m = &matrix;
 }

 recording_clip = _cairo_clip_from_boxes (boxes);
 status = _cairo_recording_surface_replay_with_clip (unwrap_source (source),
           m, dst, recording_clip);
 _cairo_clip_destroy (recording_clip);

 return status;
    }

    status = CAIRO_INT_STATUS_UNSUPPORTED;
    if (! need_clip_mask && no_mask && source->type == CAIRO_PATTERN_TYPE_SOLID) {
 const cairo_color_t *color;

 color = &((cairo_solid_pattern_t *) source)->color;
 if (op_is_source)
     op = CAIRO_OPERATOR_SOURCE;
 status = compositor->fill_boxes (dst, op, color, boxes);
    } else if (inplace && source->type == CAIRO_PATTERN_TYPE_SURFACE) {
 status = upload_boxes (compositor, extents, boxes);
    }
    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
 cairo_surface_t *src;
 cairo_surface_t *mask = NULL;
 int src_x, src_y;
 int mask_x = 0, mask_y = 0;

 /* All typical cases will have been resolved before now... */
 if (need_clip_mask) {
     mask = get_clip_surface (compositor, dst, extents->clip,
         &extents->bounded);
     if (unlikely (mask->status))
  return mask->status;

     mask_x = -extents->bounded.x;
     mask_y = -extents->bounded.y;
 }

 /* XXX but this is still ugly */
 if (! no_mask) {
     src = compositor->pattern_to_surface (dst,
        &extents->mask_pattern.base,
        TRUE,
        &extents->bounded,
        &extents->mask_sample_area,
        &src_x, &src_y);
     if (unlikely (src->status)) {
  cairo_surface_destroy (mask);
  return src->status;
     }

     if (mask != NULL) {
  status = compositor->composite_boxes (mask, CAIRO_OPERATOR_IN,
            src, NULL,
            src_x, src_y,
            0, 0,
            mask_x, mask_y,
            boxes, &extents->bounded);

  cairo_surface_destroy (src);
     } else {
  mask = src;
  mask_x = src_x;
  mask_y = src_y;
     }
 }

 src = compositor->pattern_to_surface (dst, source, FALSE,
           &extents->bounded,
           &extents->source_sample_area,
           &src_x, &src_y);
 if (likely (src->status == CAIRO_STATUS_SUCCESS)) {
     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);
 } else
     status = src->status;

 cairo_surface_destroy (mask);
    }

    if (status == CAIRO_INT_STATUS_SUCCESS && ! extents->is_bounded)
 status = fixup_unbounded_boxes (compositor, extents, boxes);

    return status;
}

static cairo_bool_t
composite_needs_clip (const cairo_composite_rectangles_t *composite,
        const cairo_box_t *extents)
{
    return !_cairo_clip_contains_box (composite->clip, extents);
}

static cairo_int_status_t
composite_boxes (const cairo_spans_compositor_t *compositor,
   cairo_composite_rectangles_t *extents,
   cairo_boxes_t  *boxes)
{
    cairo_abstract_span_renderer_t renderer;
    cairo_rectangular_scan_converter_t converter;
    const struct _cairo_boxes_chunk *chunk;
    cairo_int_status_t status;
    cairo_box_t box;

    TRACE ((stderr, "%s\n", __FUNCTION__));
    _cairo_box_from_rectangle (&box, &extents->unbounded);
    if (composite_needs_clip (extents, &box)) {
 TRACE ((stderr, "%s: unsupported clip\n", __FUNCTION__));
 return CAIRO_INT_STATUS_UNSUPPORTED;
    }

    _cairo_rectangular_scan_converter_init (&converter, &extents->unbounded);
    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
 const cairo_box_t *box = chunk->base;
 int i;

 for (i = 0; i < chunk->count; i++) {
     status = _cairo_rectangular_scan_converter_add_box (&converter, &box[i], 1);
     if (unlikely (status))
  goto cleanup_converter;
 }
    }

    status = compositor->renderer_init (&renderer, extents,
     CAIRO_ANTIALIAS_DEFAULT, FALSE);
    if (likely (status == CAIRO_INT_STATUS_SUCCESS))
 status = converter.base.generate (&converter.base, &renderer.base);
    compositor->renderer_fini (&renderer, status);

cleanup_converter:
    converter.base.destroy (&converter.base);
    return status;
}

static cairo_int_status_t
composite_polygon (const cairo_spans_compositor_t *compositor,
     cairo_composite_rectangles_t   *extents,
     cairo_polygon_t   *polygon,
     cairo_fill_rule_t    fill_rule,
     cairo_antialias_t    antialias)
{
    cairo_abstract_span_renderer_t renderer;
    cairo_scan_converter_t *converter;
    cairo_bool_t needs_clip;
    cairo_int_status_t status;

    if (extents->is_bounded)
 needs_clip = extents->clip->path != NULL;
    else
 needs_clip = !_clip_is_region (extents->clip) || extents->clip->num_boxes > 1;
    TRACE ((stderr, "%s - needs_clip=%d\n", __FUNCTION__, needs_clip));
    if (needs_clip) {
 TRACE ((stderr, "%s: unsupported clip\n", __FUNCTION__));
 return CAIRO_INT_STATUS_UNSUPPORTED;
 converter = _cairo_clip_tor_scan_converter_create (extents->clip,
          polygon,
          fill_rule, antialias);
    } else {
 const cairo_rectangle_int_t *r = &extents->unbounded;

 if (antialias == CAIRO_ANTIALIAS_FAST) {
     converter = _cairo_tor22_scan_converter_create (r->x, r->y,
           r->x + r->width,
           r->y + r->height,
           fill_rule, antialias);
     status = _cairo_tor22_scan_converter_add_polygon (converter, polygon);
 } else if (antialias == CAIRO_ANTIALIAS_NONE) {
     converter = _cairo_mono_scan_converter_create (r->x, r->y,
          r->x + r->width,
          r->y + r->height,
          fill_rule);
     status = _cairo_mono_scan_converter_add_polygon (converter, polygon);
 } else {
     converter = _cairo_tor_scan_converter_create (r->x, r->y,
         r->x + r->width,
         r->y + r->height,
         fill_rule, antialias);
     status = _cairo_tor_scan_converter_add_polygon (converter, polygon);
 }
    }
    if (unlikely (status))
 goto cleanup_converter;

    status = compositor->renderer_init (&renderer, extents,
     antialias, needs_clip);
    if (likely (status == CAIRO_INT_STATUS_SUCCESS))
 status = converter->generate (converter, &renderer.base);
    compositor->renderer_fini (&renderer, status);

cleanup_converter:
    converter->destroy (converter);
    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_int_status_t
trim_extents_to_polygon (cairo_composite_rectangles_t *extents,
    cairo_polygon_t *polygon)
{
    return _cairo_composite_rectangles_intersect_mask_extents (extents,
              &polygon->extents);
}

static cairo_int_status_t
clip_and_composite_boxes (const cairo_spans_compositor_t *compositor,
     cairo_composite_rectangles_t  *extents,
     cairo_boxes_t    *boxes)
{
    cairo_int_status_t status;
    cairo_polygon_t polygon;

    TRACE ((stderr, "%s\n", __FUNCTION__));
    status = trim_extents_to_boxes (extents, boxes);
    if (unlikely (status))
 return status;

    if (boxes->num_boxes == 0) {
 if (extents->is_bounded)
     return CAIRO_STATUS_SUCCESS;

 return fixup_unbounded_boxes (compositor, extents, boxes);
    }

    /* Can we reduce drawing through a clip-mask to simply drawing the clip? */
    if (extents->clip->path != NULL && extents->is_bounded) {
 cairo_polygon_t polygon;
 cairo_fill_rule_t fill_rule;
 cairo_antialias_t antialias;
 cairo_clip_t *clip;

 clip = _cairo_clip_copy (extents->clip);
 clip = _cairo_clip_intersect_boxes (clip, boxes);
 if (_cairo_clip_is_all_clipped (clip))
     return CAIRO_INT_STATUS_NOTHING_TO_DO;

 status = _cairo_clip_get_polygon (clip, &polygon,
       &fill_rule, &antialias);
 _cairo_clip_path_destroy (clip->path);
 clip->path = NULL;
 if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {
     cairo_clip_t *saved_clip = extents->clip;
     extents->clip = clip;

     status = clip_and_composite_polygon (compositor, extents, &polygon,
       fill_rule, antialias);

     clip = extents->clip;
     extents->clip = saved_clip;

     _cairo_polygon_fini (&polygon);
 }
 _cairo_clip_destroy (clip);

 if (status != CAIRO_INT_STATUS_UNSUPPORTED)
     return status;
    }

    if (boxes->is_pixel_aligned) {
 status = composite_aligned_boxes (compositor, extents, boxes);
 if (status != CAIRO_INT_STATUS_UNSUPPORTED)
     return status;
    }

    status = composite_boxes (compositor, extents, boxes);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
 return status;

    status = _cairo_polygon_init_boxes (&polygon, boxes);
    if (unlikely (status))
 return status;

    status = composite_polygon (compositor, extents, &polygon,
    CAIRO_FILL_RULE_WINDING,
    CAIRO_ANTIALIAS_DEFAULT);
    _cairo_polygon_fini (&polygon);

    return status;
}

static cairo_int_status_t
clip_and_composite_polygon (const cairo_spans_compositor_t *compositor,
       cairo_composite_rectangles_t  *extents,
       cairo_polygon_t   *polygon,
       cairo_fill_rule_t    fill_rule,
       cairo_antialias_t    antialias)
{
    cairo_int_status_t status;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    /* XXX simply uses polygon limits.point extemities, tessellation? */
    status = trim_extents_to_polygon (extents, polygon);
    if (unlikely (status))
 return status;

    if (_cairo_polygon_is_empty (polygon)) {
 cairo_boxes_t boxes;

 if (extents->is_bounded)
     return CAIRO_STATUS_SUCCESS;

 _cairo_boxes_init (&boxes);
 extents->bounded.width = extents->bounded.height = 0;
 return fixup_unbounded_boxes (compositor, extents, &boxes);
    }

    if (extents->is_bounded && extents->clip->path) {
 cairo_polygon_t clipper;
 cairo_antialias_t clip_antialias;
 cairo_fill_rule_t clip_fill_rule;

 TRACE((stderr, "%s - combining shape with clip polygon\n",
        __FUNCTION__));

 status = _cairo_clip_get_polygon (extents->clip,
       &clipper,
       &clip_fill_rule,
       &clip_antialias);
 if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {
     cairo_clip_t *old_clip;

     if (clip_antialias == antialias) {
  status = _cairo_polygon_intersect (polygon, fill_rule,
         &clipper, clip_fill_rule);
  _cairo_polygon_fini (&clipper);
  if (unlikely (status))
      return status;

  old_clip = extents->clip;
  extents->clip = _cairo_clip_copy_region (extents->clip);
  _cairo_clip_destroy (old_clip);

  status = trim_extents_to_polygon (extents, polygon);
  if (unlikely (status))
      return status;

  fill_rule = CAIRO_FILL_RULE_WINDING;
     } else {
  _cairo_polygon_fini (&clipper);
     }
 }
    }

    return composite_polygon (compositor, extents,
         polygon, fill_rule, antialias);
}

/* high-level compositor interface */

static cairo_int_status_t
_cairo_spans_compositor_paint (const cairo_compositor_t  *_compositor,
          cairo_composite_rectangles_t *extents)
{
    const cairo_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor;
    cairo_boxes_t boxes;
    cairo_int_status_t status;

    TRACE ((stderr, "%s\n", __FUNCTION__));
    _cairo_clip_steal_boxes (extents->clip, &boxes);
    status = clip_and_composite_boxes (compositor, extents, &boxes);
    _cairo_clip_unsteal_boxes (extents->clip, &boxes);

    return status;
}

static cairo_int_status_t
_cairo_spans_compositor_mask (const cairo_compositor_t  *_compositor,
         cairo_composite_rectangles_t *extents)
{
    const cairo_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor;
    cairo_int_status_t status;
    cairo_boxes_t boxes;

    TRACE ((stderr, "%s\n", __FUNCTION__));
    _cairo_clip_steal_boxes (extents->clip, &boxes);
    status = clip_and_composite_boxes (compositor, extents, &boxes);
    _cairo_clip_unsteal_boxes (extents->clip, &boxes);

    return status;
}

static cairo_int_status_t
_cairo_spans_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_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor;
    cairo_int_status_t status;

    TRACE ((stderr, "%s\n", __FUNCTION__));
    TRACE_ (_cairo_debug_print_path (stderr, path));
    TRACE_ (_cairo_debug_print_clip (stderr, extents->clip));

    status = CAIRO_INT_STATUS_UNSUPPORTED;
    if (_cairo_path_fixed_stroke_is_rectilinear (path)) {
 cairo_boxes_t boxes;

 _cairo_boxes_init (&boxes);
 if (! _cairo_clip_contains_rectangle (extents->clip, &extents->mask))
     _cairo_boxes_limit (&boxes,
    extents->clip->boxes,
    extents->clip->num_boxes);

 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) {
 cairo_polygon_t polygon;
 cairo_box_t limits;
 cairo_fill_rule_t fill_rule = CAIRO_FILL_RULE_WINDING;

 if (! _cairo_rectangle_contains_rectangle (&extents->unbounded,
         &extents->mask))
 {
     if (extents->clip->num_boxes == 1) {
  _cairo_polygon_init (&polygon, extents->clip->boxes, 1);
     } else {
  _cairo_box_from_rectangle (&limits, &extents->unbounded);
  _cairo_polygon_init (&polygon, &limits, 1);
     }
 }
 else
 {
     _cairo_polygon_init (&polygon, NULL, 0);
 }
 status = _cairo_path_fixed_stroke_to_polygon (path,
            style,
            ctm, ctm_inverse,
            tolerance,
            &polygon);
 TRACE_ (_cairo_debug_print_polygon (stderr, &polygon));
 polygon.num_limits = 0;

 if (status == CAIRO_INT_STATUS_SUCCESS && extents->clip->num_boxes > 1) {
     status = _cairo_polygon_intersect_with_boxes (&polygon, &fill_rule,
         extents->clip->boxes,
         extents->clip->num_boxes);
 }
 if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {
     cairo_clip_t *saved_clip = extents->clip;

     if (extents->is_bounded) {
  extents->clip = _cairo_clip_copy_path (extents->clip);
  extents->clip = _cairo_clip_intersect_box(extents->clip,
         &polygon.extents);
     }

     status = clip_and_composite_polygon (compositor, extents, &polygon,
       fill_rule, antialias);

     if (extents->is_bounded) {
  _cairo_clip_destroy (extents->clip);
  extents->clip = saved_clip;
     }
 }
 _cairo_polygon_fini (&polygon);
    }

    return status;
}

static cairo_int_status_t
_cairo_spans_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_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor;
    cairo_int_status_t status;

    TRACE((stderr, "%s op=%d, antialias=%d\n", __FUNCTION__, extents->op, antialias));

    status = CAIRO_INT_STATUS_UNSUPPORTED;
    if (_cairo_path_fixed_fill_is_rectilinear (path)) {
 cairo_boxes_t boxes;

 TRACE((stderr, "%s - rectilinear\n", __FUNCTION__));

 _cairo_boxes_init (&boxes);
 if (! _cairo_clip_contains_rectangle (extents->clip, &extents->mask))
     _cairo_boxes_limit (&boxes,
    extents->clip->boxes,
    extents->clip->num_boxes);
 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) {
 cairo_polygon_t polygon;
 cairo_box_t limits;

 TRACE((stderr, "%s - polygon\n", __FUNCTION__));

 if (! _cairo_rectangle_contains_rectangle (&extents->unbounded,
         &extents->mask))
 {
     TRACE((stderr, "%s - clipping to bounds\n", __FUNCTION__));
     if (extents->clip->num_boxes == 1) {
  _cairo_polygon_init (&polygon, extents->clip->boxes, 1);
     } else {
  _cairo_box_from_rectangle (&limits, &extents->unbounded);
  _cairo_polygon_init (&polygon, &limits, 1);
     }
 }
 else
 {
     _cairo_polygon_init (&polygon, NULL, 0);
 }

 status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon);
 TRACE_ (_cairo_debug_print_polygon (stderr, &polygon));
 polygon.num_limits = 0;

 if (status == CAIRO_INT_STATUS_SUCCESS && extents->clip->num_boxes > 1) {
     TRACE((stderr, "%s - polygon intersect with %d clip boxes\n",
     __FUNCTION__, extents->clip->num_boxes));
     status = _cairo_polygon_intersect_with_boxes (&polygon, &fill_rule,
         extents->clip->boxes,
         extents->clip->num_boxes);
 }
 TRACE_ (_cairo_debug_print_polygon (stderr, &polygon));
 if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {
     cairo_clip_t *saved_clip = extents->clip;

     if (extents->is_bounded) {
  TRACE((stderr, "%s - polygon discard clip boxes\n",
         __FUNCTION__));
  extents->clip = _cairo_clip_copy_path (extents->clip);
  extents->clip = _cairo_clip_intersect_box(extents->clip,
         &polygon.extents);
     }

     status = clip_and_composite_polygon (compositor, extents, &polygon,
       fill_rule, antialias);

     if (extents->is_bounded) {
  _cairo_clip_destroy (extents->clip);
  extents->clip = saved_clip;
     }
 }
 _cairo_polygon_fini (&polygon);

 TRACE((stderr, "%s - polygon status=%d\n", __FUNCTION__, status));
    }

    return status;
}

void
_cairo_spans_compositor_init (cairo_spans_compositor_t *compositor,
         const cairo_compositor_t  *delegate)
{
    compositor->base.delegate = delegate;

    compositor->base.paint  = _cairo_spans_compositor_paint;
    compositor->base.mask   = _cairo_spans_compositor_mask;
    compositor->base.fill   = _cairo_spans_compositor_fill;
    compositor->base.stroke = _cairo_spans_compositor_stroke;
    compositor->base.glyphs = NULL;
}