diff options
Diffstat (limited to 'Build/source/libs/cairo/cairo-1.14.2/src/cairo-spans-compositor.c')
-rw-r--r-- | Build/source/libs/cairo/cairo-1.14.2/src/cairo-spans-compositor.c | 1201 |
1 files changed, 0 insertions, 1201 deletions
diff --git a/Build/source/libs/cairo/cairo-1.14.2/src/cairo-spans-compositor.c b/Build/source/libs/cairo/cairo-1.14.2/src/cairo-spans-compositor.c deleted file mode 100644 index efbae254bf4..00000000000 --- a/Build/source/libs/cairo/cairo-1.14.2/src/cairo-spans-compositor.c +++ /dev/null @@ -1,1201 +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> - */ - -#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_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_t limits; - _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; - - 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_t limits; - _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; -} |