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
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)
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)
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;
/* 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);
recording_clip = _cairo_clip_from_boxes (boxes);
status = _cairo_recording_surface_replay_with_clip (unwrap_source (source),
&source->matrix,
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;
}
