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