Logo Search packages:      
Sourcecode: cairo version File versions  Download package

cairo-image-surface.c

/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
/* cairo - a vector graphics library with display and print output
 *
 * Copyright © 2003 University of Southern California
 * Copyright © 2009,2010 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>
 *    Chris Wilson <chris@chris-wilson.co.uk>
 */

#include "cairoint.h"

#include "cairo-boxes-private.h"
#include "cairo-clip-private.h"
#include "cairo-composite-rectangles-private.h"
#include "cairo-error-private.h"
#include "cairo-region-private.h"
#include "cairo-scaled-font-private.h"
#include "cairo-surface-snapshot-private.h"
#include "cairo-surface-subsurface-private.h"

/* Limit on the width / height of an image surface in pixels.  This is
 * mainly determined by coordinates of things sent to pixman at the
 * moment being in 16.16 format. */
#define MAX_IMAGE_SIZE 32767
#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */

/**
 * SECTION:cairo-image
 * @Title: Image Surfaces
 * @Short_Description: Rendering to memory buffers
 * @See_Also: #cairo_surface_t
 *
 * Image surfaces provide the ability to render to memory buffers
 * either allocated by cairo or by the calling code.  The supported
 * image formats are those defined in #cairo_format_t.
 */

/**
 * CAIRO_HAS_IMAGE_SURFACE:
 *
 * Defined if the image surface backend is available.
 * The image surface backend is always built in.
 * This macro was added for completeness in cairo 1.8.
 *
 * @Since: 1.8
 */

static cairo_int_status_t
_cairo_image_surface_fill (void *dst,
                     cairo_operator_t            op,
                     const cairo_pattern_t      *source,
                     cairo_path_fixed_t   *path,
                     cairo_fill_rule_t           fill_rule,
                     double                tolerance,
                     cairo_antialias_t           antialias,
                     cairo_clip_t         *clip);

static pixman_image_t *
_pixman_image_for_solid (const cairo_solid_pattern_t *pattern);

static cairo_bool_t
_cairo_image_surface_is_size_valid (int width, int height)
{
    return 0 <= width  &&  width <= MAX_IMAGE_SIZE &&
         0 <= height && height <= MAX_IMAGE_SIZE;
}

cairo_format_t
_cairo_format_from_pixman_format (pixman_format_code_t pixman_format)
{
    switch (pixman_format) {
    case PIXMAN_a8r8g8b8:
      return CAIRO_FORMAT_ARGB32;
    case PIXMAN_x8r8g8b8:
      return CAIRO_FORMAT_RGB24;
    case PIXMAN_a8:
      return CAIRO_FORMAT_A8;
    case PIXMAN_a1:
      return CAIRO_FORMAT_A1;
    case PIXMAN_r5g6b5:
      return CAIRO_FORMAT_RGB16_565;
    case PIXMAN_a8b8g8r8: case PIXMAN_x8b8g8r8: case PIXMAN_r8g8b8:
    case PIXMAN_b8g8r8:   case PIXMAN_b5g6r5:
    case PIXMAN_a1r5g5b5: case PIXMAN_x1r5g5b5: case PIXMAN_a1b5g5r5:
    case PIXMAN_x1b5g5r5: case PIXMAN_a4r4g4b4: case PIXMAN_x4r4g4b4:
    case PIXMAN_a4b4g4r4: case PIXMAN_x4b4g4r4: case PIXMAN_r3g3b2:
    case PIXMAN_b2g3r3:   case PIXMAN_a2r2g2b2: case PIXMAN_a2b2g2r2:
    case PIXMAN_c8:       case PIXMAN_g8:       case PIXMAN_x4a4:
    case PIXMAN_a4:       case PIXMAN_r1g2b1:   case PIXMAN_b1g2r1:
    case PIXMAN_a1r1g1b1: case PIXMAN_a1b1g1r1: case PIXMAN_c4:
    case PIXMAN_g4:       case PIXMAN_g1:
    case PIXMAN_yuy2:     case PIXMAN_yv12:
    case PIXMAN_b8g8r8x8:
    case PIXMAN_b8g8r8a8:
    case PIXMAN_x2b10g10r10:
    case PIXMAN_a2b10g10r10:
    case PIXMAN_x2r10g10b10:
    case PIXMAN_a2r10g10b10:
    default:
      return CAIRO_FORMAT_INVALID;
    }

    return CAIRO_FORMAT_INVALID;
}

cairo_content_t
_cairo_content_from_pixman_format (pixman_format_code_t pixman_format)
{
    cairo_content_t content;

    content = 0;
    if (PIXMAN_FORMAT_RGB (pixman_format))
      content |= CAIRO_CONTENT_COLOR;
    if (PIXMAN_FORMAT_A (pixman_format))
      content |= CAIRO_CONTENT_ALPHA;

    return content;
}

cairo_surface_t *
_cairo_image_surface_create_for_pixman_image (pixman_image_t            *pixman_image,
                                    pixman_format_code_t     pixman_format)
{
    cairo_image_surface_t *surface;
    int width = pixman_image_get_width (pixman_image);
    int height = pixman_image_get_height (pixman_image);

    surface = malloc (sizeof (cairo_image_surface_t));
    if (unlikely (surface == NULL))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

    _cairo_surface_init (&surface->base,
                   &_cairo_image_surface_backend,
                   NULL, /* device */
                   _cairo_content_from_pixman_format (pixman_format));

    surface->pixman_image = pixman_image;

    surface->pixman_format = pixman_format;
    surface->format = _cairo_format_from_pixman_format (pixman_format);
    surface->data = (uint8_t *) pixman_image_get_data (pixman_image);
    surface->owns_data = FALSE;
    surface->transparency = CAIRO_IMAGE_UNKNOWN;

    surface->width = width;
    surface->height = height;
    surface->stride = pixman_image_get_stride (pixman_image);
    surface->depth = pixman_image_get_depth (pixman_image);

    return &surface->base;
}

cairo_bool_t
_pixman_format_from_masks (cairo_format_masks_t *masks,
                     pixman_format_code_t *format_ret)
{
    pixman_format_code_t format;
    int format_type;
    int a, r, g, b;
    cairo_format_masks_t format_masks;

    a = _cairo_popcount (masks->alpha_mask);
    r = _cairo_popcount (masks->red_mask);
    g = _cairo_popcount (masks->green_mask);
    b = _cairo_popcount (masks->blue_mask);

    if (masks->red_mask) {
      if (masks->red_mask > masks->blue_mask)
          format_type = PIXMAN_TYPE_ARGB;
      else
          format_type = PIXMAN_TYPE_ABGR;
    } else if (masks->alpha_mask) {
      format_type = PIXMAN_TYPE_A;
    } else {
      return FALSE;
    }

    format = PIXMAN_FORMAT (masks->bpp, format_type, a, r, g, b);

    if (! pixman_format_supported_destination (format))
      return FALSE;

    /* Sanity check that we got out of PIXMAN_FORMAT exactly what we
     * expected. This avoid any problems from something bizarre like
     * alpha in the least-significant bits, or insane channel order,
     * or whatever. */
     if (!_pixman_format_to_masks (format, &format_masks) ||
         masks->bpp        != format_masks.bpp            ||
       masks->red_mask   != format_masks.red_mask       ||
       masks->green_mask != format_masks.green_mask     ||
       masks->blue_mask  != format_masks.blue_mask)
     {
       return FALSE;
     }

    *format_ret = format;
    return TRUE;
}

/* A mask consisting of N bits set to 1. */
#define MASK(N) ((1UL << (N))-1)

cairo_bool_t
_pixman_format_to_masks (pixman_format_code_t    format,
                   cairo_format_masks_t   *masks)
{
    int a, r, g, b;

    masks->bpp = PIXMAN_FORMAT_BPP (format);

    /* Number of bits in each channel */
    a = PIXMAN_FORMAT_A (format);
    r = PIXMAN_FORMAT_R (format);
    g = PIXMAN_FORMAT_G (format);
    b = PIXMAN_FORMAT_B (format);

    switch (PIXMAN_FORMAT_TYPE (format)) {
    case PIXMAN_TYPE_ARGB:
        masks->alpha_mask = MASK (a) << (r + g + b);
        masks->red_mask   = MASK (r) << (g + b);
        masks->green_mask = MASK (g) << (b);
        masks->blue_mask  = MASK (b);
        return TRUE;
    case PIXMAN_TYPE_ABGR:
        masks->alpha_mask = MASK (a) << (b + g + r);
        masks->blue_mask  = MASK (b) << (g + r);
        masks->green_mask = MASK (g) << (r);
        masks->red_mask   = MASK (r);
        return TRUE;
#ifdef PIXMAN_TYPE_BGRA
    case PIXMAN_TYPE_BGRA:
        masks->blue_mask  = MASK (b) << (masks->bpp - b);
        masks->green_mask = MASK (g) << (masks->bpp - b - g);
        masks->red_mask   = MASK (r) << (masks->bpp - b - g - r);
        masks->alpha_mask = MASK (a);
        return TRUE;
#endif
    case PIXMAN_TYPE_A:
        masks->alpha_mask = MASK (a);
        masks->red_mask   = 0;
        masks->green_mask = 0;
        masks->blue_mask  = 0;
        return TRUE;
    case PIXMAN_TYPE_OTHER:
    case PIXMAN_TYPE_COLOR:
    case PIXMAN_TYPE_GRAY:
    case PIXMAN_TYPE_YUY2:
    case PIXMAN_TYPE_YV12:
    default:
        masks->alpha_mask = 0;
        masks->red_mask   = 0;
        masks->green_mask = 0;
        masks->blue_mask  = 0;
        return FALSE;
    }
}

pixman_format_code_t
_cairo_format_to_pixman_format_code (cairo_format_t format)
{
    pixman_format_code_t ret;
    switch (format) {
    case CAIRO_FORMAT_A1:
      ret = PIXMAN_a1;
      break;
    case CAIRO_FORMAT_A8:
      ret = PIXMAN_a8;
      break;
    case CAIRO_FORMAT_RGB24:
      ret = PIXMAN_x8r8g8b8;
      break;
    case CAIRO_FORMAT_RGB16_565:
      ret = PIXMAN_r5g6b5;
      break;
    case CAIRO_FORMAT_ARGB32:
    case CAIRO_FORMAT_INVALID:
    default:
      ret = PIXMAN_a8r8g8b8;
      break;
    }
    return ret;
}

cairo_surface_t *
_cairo_image_surface_create_with_pixman_format (unsigned char           *data,
                                    pixman_format_code_t     pixman_format,
                                    int                width,
                                    int                height,
                                    int                stride)
{
    cairo_surface_t *surface;
    pixman_image_t *pixman_image;

    if (! _cairo_image_surface_is_size_valid (width, height))
    {
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
    }

    pixman_image = pixman_image_create_bits (pixman_format, width, height,
                                   (uint32_t *) data, stride);

    if (unlikely (pixman_image == NULL))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

    surface = _cairo_image_surface_create_for_pixman_image (pixman_image,
                                              pixman_format);
    if (unlikely (surface->status)) {
      pixman_image_unref (pixman_image);
      return surface;
    }

    /* we can not make any assumptions about the initial state of user data */
    surface->is_clear = data == NULL;
    return surface;
}

/**
 * cairo_image_surface_create:
 * @format: format of pixels in the surface to create
 * @width: width of the surface, in pixels
 * @height: height of the surface, in pixels
 *
 * Creates an image surface of the specified format and
 * dimensions. Initially the surface contents are all
 * 0. (Specifically, within each pixel, each color or alpha channel
 * belonging to format will be 0. The contents of bits within a pixel,
 * but not belonging to the given format are undefined).
 *
 * Return value: a pointer to the newly created surface. The caller
 * owns the surface and should call cairo_surface_destroy() when done
 * with it.
 *
 * This function always returns a valid pointer, but it will return a
 * pointer to a "nil" surface if an error such as out of memory
 * occurs. You can use cairo_surface_status() to check for this.
 **/
cairo_surface_t *
cairo_image_surface_create (cairo_format_t      format,
                      int                 width,
                      int                 height)
{
    pixman_format_code_t pixman_format;

    if (! CAIRO_FORMAT_VALID (format))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));

    pixman_format = _cairo_format_to_pixman_format_code (format);

    return _cairo_image_surface_create_with_pixman_format (NULL, pixman_format,
                                             width, height, -1);
}
slim_hidden_def (cairo_image_surface_create);

cairo_surface_t *
_cairo_image_surface_create_with_content (cairo_content_t   content,
                                int             width,
                                int             height)
{
    return cairo_image_surface_create (_cairo_format_from_content (content),
                               width, height);
}

/**
 * cairo_format_stride_for_width:
 * @format: A #cairo_format_t value
 * @width: The desired width of an image surface to be created.
 *
 * This function provides a stride value that will respect all
 * alignment requirements of the accelerated image-rendering code
 * within cairo. Typical usage will be of the form:
 *
 * <informalexample><programlisting>
 * int stride;
 * unsigned char *data;
 * #cairo_surface_t *surface;
 *
 * stride = cairo_format_stride_for_width (format, width);
 * data = malloc (stride * height);
 * surface = cairo_image_surface_create_for_data (data, format,
 *                                    width, height,
 *                                    stride);
 * </programlisting></informalexample>
 *
 * Return value: the appropriate stride to use given the desired
 * format and width, or -1 if either the format is invalid or the width
 * too large.
 *
 * Since: 1.6
 **/
int
cairo_format_stride_for_width (cairo_format_t   format,
                         int        width)
{
    int bpp;

    if (! CAIRO_FORMAT_VALID (format)) {
      _cairo_error_throw (CAIRO_STATUS_INVALID_FORMAT);
      return -1;
    }

    bpp = _cairo_format_bits_per_pixel (format);
    if ((unsigned) (width) >= (INT32_MAX - 7) / (unsigned) (bpp))
      return -1;

    return CAIRO_STRIDE_FOR_WIDTH_BPP (width, bpp);
}
slim_hidden_def (cairo_format_stride_for_width);

/**
 * cairo_image_surface_create_for_data:
 * @data: a pointer to a buffer supplied by the application in which
 *     to write contents. This pointer must be suitably aligned for any
 *     kind of variable, (for example, a pointer returned by malloc).
 * @format: the format of pixels in the buffer
 * @width: the width of the image to be stored in the buffer
 * @height: the height of the image to be stored in the buffer
 * @stride: the number of bytes between the start of rows in the
 *     buffer as allocated. This value should always be computed by
 *     cairo_format_stride_for_width() before allocating the data
 *     buffer.
 *
 * Creates an image surface for the provided pixel data. The output
 * buffer must be kept around until the #cairo_surface_t is destroyed
 * or cairo_surface_finish() is called on the surface.  The initial
 * contents of @data will be used as the initial image contents; you
 * must explicitly clear the buffer, using, for example,
 * cairo_rectangle() and cairo_fill() if you want it cleared.
 *
 * Note that the stride may be larger than
 * width*bytes_per_pixel to provide proper alignment for each pixel
 * and row. This alignment is required to allow high-performance rendering
 * within cairo. The correct way to obtain a legal stride value is to
 * call cairo_format_stride_for_width() with the desired format and
 * maximum image width value, and then use the resulting stride value
 * to allocate the data and to create the image surface. See
 * cairo_format_stride_for_width() for example code.
 *
 * Return value: a pointer to the newly created surface. The caller
 * owns the surface and should call cairo_surface_destroy() when done
 * with it.
 *
 * This function always returns a valid pointer, but it will return a
 * pointer to a "nil" surface in the case of an error such as out of
 * memory or an invalid stride value. In case of invalid stride value
 * the error status of the returned surface will be
 * %CAIRO_STATUS_INVALID_STRIDE.  You can use
 * cairo_surface_status() to check for this.
 *
 * See cairo_surface_set_user_data() for a means of attaching a
 * destroy-notification fallback to the surface if necessary.
 **/
cairo_surface_t *
cairo_image_surface_create_for_data (unsigned char     *data,
                             cairo_format_t     format,
                             int          width,
                             int          height,
                             int          stride)
{
    pixman_format_code_t pixman_format;
    int minstride;

    if (! CAIRO_FORMAT_VALID (format))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));

    if ((stride & (CAIRO_STRIDE_ALIGNMENT-1)) != 0)
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE));

    if (! _cairo_image_surface_is_size_valid (width, height))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));

    minstride = cairo_format_stride_for_width (format, width);
    if (stride < 0) {
      if (stride > -minstride) {
          return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE));
      }
    } else {
      if (stride < minstride) {
          return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE));
      }
    }

    pixman_format = _cairo_format_to_pixman_format_code (format);
    return _cairo_image_surface_create_with_pixman_format (data,
                                             pixman_format,
                                             width, height,
                                             stride);
}
slim_hidden_def (cairo_image_surface_create_for_data);

/**
 * cairo_image_surface_get_data:
 * @surface: a #cairo_image_surface_t
 *
 * Get a pointer to the data of the image surface, for direct
 * inspection or modification.
 *
 * Return value: a pointer to the image data of this surface or %NULL
 * if @surface is not an image surface, or if cairo_surface_finish()
 * has been called.
 *
 * Since: 1.2
 **/
unsigned char *
cairo_image_surface_get_data (cairo_surface_t *surface)
{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (! _cairo_surface_is_image (surface)) {
      _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
      return NULL;
    }

    return image_surface->data;
}
slim_hidden_def (cairo_image_surface_get_data);

/**
 * cairo_image_surface_get_format:
 * @surface: a #cairo_image_surface_t
 *
 * Get the format of the surface.
 *
 * Return value: the format of the surface
 *
 * Since: 1.2
 **/
cairo_format_t
cairo_image_surface_get_format (cairo_surface_t *surface)
{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (! _cairo_surface_is_image (surface)) {
      _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
      return CAIRO_FORMAT_INVALID;
    }

    return image_surface->format;
}
slim_hidden_def (cairo_image_surface_get_format);

/**
 * cairo_image_surface_get_width:
 * @surface: a #cairo_image_surface_t
 *
 * Get the width of the image surface in pixels.
 *
 * Return value: the width of the surface in pixels.
 **/
int
cairo_image_surface_get_width (cairo_surface_t *surface)
{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (! _cairo_surface_is_image (surface)) {
      _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
      return 0;
    }

    return image_surface->width;
}
slim_hidden_def (cairo_image_surface_get_width);

/**
 * cairo_image_surface_get_height:
 * @surface: a #cairo_image_surface_t
 *
 * Get the height of the image surface in pixels.
 *
 * Return value: the height of the surface in pixels.
 **/
int
cairo_image_surface_get_height (cairo_surface_t *surface)
{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (! _cairo_surface_is_image (surface)) {
      _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
      return 0;
    }

    return image_surface->height;
}
slim_hidden_def (cairo_image_surface_get_height);

/**
 * cairo_image_surface_get_stride:
 * @surface: a #cairo_image_surface_t
 *
 * Get the stride of the image surface in bytes
 *
 * Return value: the stride of the image surface in bytes (or 0 if
 * @surface is not an image surface). The stride is the distance in
 * bytes from the beginning of one row of the image data to the
 * beginning of the next row.
 *
 * Since: 1.2
 **/
int
cairo_image_surface_get_stride (cairo_surface_t *surface)
{

    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (! _cairo_surface_is_image (surface)) {
      _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
      return 0;
    }

    return image_surface->stride;
}
slim_hidden_def (cairo_image_surface_get_stride);

cairo_format_t
_cairo_format_from_content (cairo_content_t content)
{
    switch (content) {
    case CAIRO_CONTENT_COLOR:
      return CAIRO_FORMAT_RGB24;
    case CAIRO_CONTENT_ALPHA:
      return CAIRO_FORMAT_A8;
    case CAIRO_CONTENT_COLOR_ALPHA:
      return CAIRO_FORMAT_ARGB32;
    }

    ASSERT_NOT_REACHED;
    return CAIRO_FORMAT_INVALID;
}

cairo_content_t
_cairo_content_from_format (cairo_format_t format)
{
    switch (format) {
    case CAIRO_FORMAT_ARGB32:
      return CAIRO_CONTENT_COLOR_ALPHA;
    case CAIRO_FORMAT_RGB24:
      return CAIRO_CONTENT_COLOR;
    case CAIRO_FORMAT_RGB16_565:
      return CAIRO_CONTENT_COLOR;
    case CAIRO_FORMAT_A8:
    case CAIRO_FORMAT_A1:
      return CAIRO_CONTENT_ALPHA;
    case CAIRO_FORMAT_INVALID:
      break;
    }

    ASSERT_NOT_REACHED;
    return CAIRO_CONTENT_COLOR_ALPHA;
}

int
_cairo_format_bits_per_pixel (cairo_format_t format)
{
    switch (format) {
    case CAIRO_FORMAT_ARGB32:
      return 32;
    case CAIRO_FORMAT_RGB24:
      return 32;
    case CAIRO_FORMAT_RGB16_565:
      return 16;
    case CAIRO_FORMAT_A8:
      return 8;
    case CAIRO_FORMAT_A1:
      return 1;
    case CAIRO_FORMAT_INVALID:
    default:
      ASSERT_NOT_REACHED;
      return 0;
    }
}

static cairo_surface_t *
_cairo_image_surface_create_similar (void        *abstract_other,
                             cairo_content_t    content,
                             int          width,
                             int          height)
{
    cairo_image_surface_t *other = abstract_other;

    if (! _cairo_image_surface_is_size_valid (width, height))
      return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));

    if (content == other->base.content) {
      return _cairo_image_surface_create_with_pixman_format (NULL,
                                                 other->pixman_format,
                                                 width, height,
                                                 0);
    }

    return _cairo_image_surface_create_with_content (content,
                                         width, height);
}

static cairo_status_t
_cairo_image_surface_finish (void *abstract_surface)
{
    cairo_image_surface_t *surface = abstract_surface;

    if (surface->pixman_image) {
      pixman_image_unref (surface->pixman_image);
      surface->pixman_image = NULL;
    }

    if (surface->owns_data) {
      free (surface->data);
      surface->data = NULL;
    }

    return CAIRO_STATUS_SUCCESS;
}

void
_cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface)
{
    surface->owns_data = TRUE;
}

static cairo_status_t
_cairo_image_surface_acquire_source_image (void                    *abstract_surface,
                                 cairo_image_surface_t  **image_out,
                                 void                   **image_extra)
{
    *image_out = abstract_surface;
    *image_extra = NULL;

    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_image_surface_release_source_image (void                   *abstract_surface,
                                 cairo_image_surface_t  *image,
                                 void                   *image_extra)
{
}

/* XXX: I think we should fix pixman to match the names/order of the
 * cairo operators, but that will likely be better done at the same
 * time the X server is ported to pixman, (which will change a lot of
 * things in pixman I think).
 */
static pixman_op_t
_pixman_operator (cairo_operator_t op)
{
    switch (op) {
    case CAIRO_OPERATOR_CLEAR:
      return PIXMAN_OP_CLEAR;

    case CAIRO_OPERATOR_SOURCE:
      return PIXMAN_OP_SRC;
    case CAIRO_OPERATOR_OVER:
      return PIXMAN_OP_OVER;
    case CAIRO_OPERATOR_IN:
      return PIXMAN_OP_IN;
    case CAIRO_OPERATOR_OUT:
      return PIXMAN_OP_OUT;
    case CAIRO_OPERATOR_ATOP:
      return PIXMAN_OP_ATOP;

    case CAIRO_OPERATOR_DEST:
      return PIXMAN_OP_DST;
    case CAIRO_OPERATOR_DEST_OVER:
      return PIXMAN_OP_OVER_REVERSE;
    case CAIRO_OPERATOR_DEST_IN:
      return PIXMAN_OP_IN_REVERSE;
    case CAIRO_OPERATOR_DEST_OUT:
      return PIXMAN_OP_OUT_REVERSE;
    case CAIRO_OPERATOR_DEST_ATOP:
      return PIXMAN_OP_ATOP_REVERSE;

    case CAIRO_OPERATOR_XOR:
      return PIXMAN_OP_XOR;
    case CAIRO_OPERATOR_ADD:
      return PIXMAN_OP_ADD;
    case CAIRO_OPERATOR_SATURATE:
      return PIXMAN_OP_SATURATE;

    case CAIRO_OPERATOR_MULTIPLY:
      return PIXMAN_OP_MULTIPLY;
    case CAIRO_OPERATOR_SCREEN:
      return PIXMAN_OP_SCREEN;
    case CAIRO_OPERATOR_OVERLAY:
      return PIXMAN_OP_OVERLAY;
    case CAIRO_OPERATOR_DARKEN:
      return PIXMAN_OP_DARKEN;
    case CAIRO_OPERATOR_LIGHTEN:
      return PIXMAN_OP_LIGHTEN;
    case CAIRO_OPERATOR_COLOR_DODGE:
      return PIXMAN_OP_COLOR_DODGE;
    case CAIRO_OPERATOR_COLOR_BURN:
      return PIXMAN_OP_COLOR_BURN;
    case CAIRO_OPERATOR_HARD_LIGHT:
      return PIXMAN_OP_HARD_LIGHT;
    case CAIRO_OPERATOR_SOFT_LIGHT:
      return PIXMAN_OP_SOFT_LIGHT;
    case CAIRO_OPERATOR_DIFFERENCE:
      return PIXMAN_OP_DIFFERENCE;
    case CAIRO_OPERATOR_EXCLUSION:
      return PIXMAN_OP_EXCLUSION;
    case CAIRO_OPERATOR_HSL_HUE:
      return PIXMAN_OP_HSL_HUE;
    case CAIRO_OPERATOR_HSL_SATURATION:
      return PIXMAN_OP_HSL_SATURATION;
    case CAIRO_OPERATOR_HSL_COLOR:
      return PIXMAN_OP_HSL_COLOR;
    case CAIRO_OPERATOR_HSL_LUMINOSITY:
      return PIXMAN_OP_HSL_LUMINOSITY;

    default:
      ASSERT_NOT_REACHED;
      return PIXMAN_OP_OVER;
    }
}

static cairo_status_t
_cairo_image_surface_set_clip_region (cairo_image_surface_t *surface,
                              cairo_region_t *region)
{
    if (! pixman_image_set_clip_region32 (surface->pixman_image, &region->rgn))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_image_surface_unset_clip_region (cairo_image_surface_t *surface)
{
    pixman_image_set_clip_region32 (surface->pixman_image, NULL);
}

static double
_pixman_nearest_sample (double d)
{
    return ceil (d - .5);
}

static cairo_bool_t
_nearest_sample (cairo_filter_t filter, double *tx, double *ty)
{
    if (filter == CAIRO_FILTER_FAST || filter == CAIRO_FILTER_NEAREST) {
      *tx = _pixman_nearest_sample (*tx);
      *ty = _pixman_nearest_sample (*ty);
    } else {
      if (*tx != floor (*tx) || *ty != floor (*ty))
          return FALSE;
    }
    return fabs (*tx) < PIXMAN_MAX_INT && fabs (*ty) < PIXMAN_MAX_INT;
}

#if HAS_ATOMIC_OPS
static pixman_image_t *
_pixman_transparent_image (void)
{
    static pixman_image_t *__pixman_transparent_image;
    pixman_image_t *image;

    image = __pixman_transparent_image;
    if (unlikely (image == NULL)) {
      pixman_color_t color;

      color.red   = 0x00;
      color.green = 0x00;
      color.blue  = 0x00;
      color.alpha = 0x00;

      image = pixman_image_create_solid_fill (&color);
      if (unlikely (image == NULL))
          return NULL;

      if (_cairo_atomic_ptr_cmpxchg (&__pixman_transparent_image,
                               NULL, image))
      {
          pixman_image_ref (image);
      }
    } else {
      pixman_image_ref (image);
    }

    return image;
}

static pixman_image_t *
_pixman_black_image (void)
{
    static pixman_image_t *__pixman_black_image;
    pixman_image_t *image;

    image = __pixman_black_image;
    if (unlikely (image == NULL)) {
      pixman_color_t color;

      color.red   = 0x00;
      color.green = 0x00;
      color.blue  = 0x00;
      color.alpha = 0xffff;

      image = pixman_image_create_solid_fill (&color);
      if (unlikely (image == NULL))
          return NULL;

      if (_cairo_atomic_ptr_cmpxchg (&__pixman_black_image,
                               NULL, image))
      {
          pixman_image_ref (image);
      }
    } else {
      pixman_image_ref (image);
    }

    return image;
}

static pixman_image_t *
_pixman_white_image (void)
{
    static pixman_image_t *__pixman_white_image;
    pixman_image_t *image;

    image = __pixman_white_image;
    if (unlikely (image == NULL)) {
      pixman_color_t color;

      color.red   = 0xffff;
      color.green = 0xffff;
      color.blue  = 0xffff;
      color.alpha = 0xffff;

      image = pixman_image_create_solid_fill (&color);
      if (unlikely (image == NULL))
          return NULL;

      if (_cairo_atomic_ptr_cmpxchg (&__pixman_white_image,
                               NULL, image))
      {
          pixman_image_ref (image);
      }
    } else {
      pixman_image_ref (image);
    }

    return image;
}
#else
static pixman_image_t *
_pixman_transparent_image (void)
{
    return _pixman_image_for_solid (&_cairo_pattern_clear);
}
static pixman_image_t *
_pixman_black_image (void)
{
    return _pixman_image_for_solid (&_cairo_pattern_black);
}
static pixman_image_t *
_pixman_white_image (void)
{
    return _pixman_image_for_solid (&_cairo_pattern_white);
}
#endif

static uint32_t
hars_petruska_f54_1_random (void)
{
#define rol(x,k) ((x << k) | (x >> (32-k)))
    static uint32_t x;
    return x = (x ^ rol (x, 5) ^ rol (x, 24)) + 0x37798849;
#undef rol
}

static pixman_image_t *
_pixman_image_for_solid (const cairo_solid_pattern_t *pattern)
{
    static struct {
      cairo_color_t color;
      pixman_image_t *image;
    } cache[16];
    static int n_cached;
    pixman_color_t color;
    pixman_image_t *image;
    int i;

#if HAS_ATOMIC_OPS
    if (pattern->color.alpha_short <= 0x00ff)
      return _pixman_transparent_image ();

    if (pattern->color.alpha_short >= 0xff00) {
      if (pattern->color.red_short <= 0x00ff &&
          pattern->color.green_short <= 0x00ff &&
          pattern->color.blue_short <= 0x00ff)
      {
          return _pixman_black_image ();
      }

      if (pattern->color.red_short >= 0xff00 &&
          pattern->color.green_short >= 0xff00 &&
          pattern->color.blue_short >= 0xff00)
      {
          return _pixman_white_image ();
      }
    }
#endif

    CAIRO_MUTEX_LOCK (_cairo_image_solid_cache_mutex);
    for (i = 0; i < n_cached; i++) {
      if (_cairo_color_equal (&cache[i].color, &pattern->color)) {
          image = pixman_image_ref (cache[i].image);
          goto UNLOCK;
      }
    }

    color.red   = pattern->color.red_short;
    color.green = pattern->color.green_short;
    color.blue  = pattern->color.blue_short;
    color.alpha = pattern->color.alpha_short;

    image = pixman_image_create_solid_fill (&color);
    if (image == NULL)
      goto UNLOCK;

    if (n_cached < ARRAY_LENGTH (cache)) {
      i = n_cached++;
    } else {
      i = hars_petruska_f54_1_random () % ARRAY_LENGTH (cache);
      pixman_image_unref (cache[i].image);
    }
    cache[i].image = pixman_image_ref (image);
    cache[i].color = pattern->color;

UNLOCK:
    CAIRO_MUTEX_UNLOCK (_cairo_image_solid_cache_mutex);
    return image;
}

static pixman_image_t *
_pixman_image_for_gradient (const cairo_gradient_pattern_t *pattern,
                      const cairo_rectangle_int_t *extents,
                      int *ix, int *iy)
{
    pixman_image_t        *pixman_image;
    pixman_gradient_stop_t pixman_stops_static[2];
    pixman_gradient_stop_t *pixman_stops = pixman_stops_static;
    cairo_matrix_t matrix = pattern->base.matrix;
    double tx, ty;
    unsigned int i;

    if (pattern->n_stops > ARRAY_LENGTH(pixman_stops_static)) {
      pixman_stops = _cairo_malloc_ab (pattern->n_stops,
                               sizeof(pixman_gradient_stop_t));
      if (unlikely (pixman_stops == NULL))
          return NULL;
    }

    for (i = 0; i < pattern->n_stops; i++) {
      pixman_stops[i].x = _cairo_fixed_16_16_from_double (pattern->stops[i].offset);
      pixman_stops[i].color.red   = pattern->stops[i].color.red_short;
      pixman_stops[i].color.green = pattern->stops[i].color.green_short;
      pixman_stops[i].color.blue  = pattern->stops[i].color.blue_short;
      pixman_stops[i].color.alpha = pattern->stops[i].color.alpha_short;
    }

    if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) {
      cairo_linear_pattern_t *linear = (cairo_linear_pattern_t *) pattern;
      pixman_point_fixed_t p1, p2;
      cairo_fixed_t xdim, ydim;

      xdim = fabs (linear->p2.x - linear->p1.x);
      ydim = fabs (linear->p2.y - linear->p1.y);

      /*
       * Transform the matrix to avoid overflow when converting between
       * cairo_fixed_t and pixman_fixed_t (without incurring performance
       * loss when the transformation is unnecessary).
       *
       * XXX: Consider converting out-of-range co-ordinates and transforms.
       * Having a function to compute the required transformation to
       * "normalize" a given bounding box would be generally useful -
       * cf linear patterns, gradient patterns, surface patterns...
       */
      if (_cairo_fixed_integer_ceil (xdim) > PIXMAN_MAX_INT ||
          _cairo_fixed_integer_ceil (ydim) > PIXMAN_MAX_INT)
      {
          double sf;

          if (xdim > ydim)
            sf = PIXMAN_MAX_INT / _cairo_fixed_to_double (xdim);
          else
            sf = PIXMAN_MAX_INT / _cairo_fixed_to_double (ydim);

          p1.x = _cairo_fixed_16_16_from_double (_cairo_fixed_to_double (linear->p1.x) * sf);
          p1.y = _cairo_fixed_16_16_from_double (_cairo_fixed_to_double (linear->p1.y) * sf);
          p2.x = _cairo_fixed_16_16_from_double (_cairo_fixed_to_double (linear->p2.x) * sf);
          p2.y = _cairo_fixed_16_16_from_double (_cairo_fixed_to_double (linear->p2.y) * sf);

          cairo_matrix_scale (&matrix, sf, sf);
      }
      else
      {
          p1.x = _cairo_fixed_to_16_16 (linear->p1.x);
          p1.y = _cairo_fixed_to_16_16 (linear->p1.y);
          p2.x = _cairo_fixed_to_16_16 (linear->p2.x);
          p2.y = _cairo_fixed_to_16_16 (linear->p2.y);
      }

      pixman_image = pixman_image_create_linear_gradient (&p1, &p2,
                                              pixman_stops,
                                              pattern->n_stops);
    } else {
      cairo_radial_pattern_t *radial = (cairo_radial_pattern_t *) pattern;
      pixman_point_fixed_t c1, c2;
      pixman_fixed_t r1, r2;

      c1.x = _cairo_fixed_to_16_16 (radial->c1.x);
      c1.y = _cairo_fixed_to_16_16 (radial->c1.y);
      r1   = _cairo_fixed_to_16_16 (radial->r1);

      c2.x = _cairo_fixed_to_16_16 (radial->c2.x);
      c2.y = _cairo_fixed_to_16_16 (radial->c2.y);
      r2   = _cairo_fixed_to_16_16 (radial->r2);

      pixman_image = pixman_image_create_radial_gradient (&c1, &c2, r1, r2,
                                              pixman_stops,
                                              pattern->n_stops);
    }

    if (pixman_stops != pixman_stops_static)
      free (pixman_stops);

    if (unlikely (pixman_image == NULL))
      return NULL;

    tx = pattern->base.matrix.x0;
    ty = pattern->base.matrix.y0;
    if (! _cairo_matrix_is_translation (&pattern->base.matrix) ||
      ! _nearest_sample (pattern->base.filter, &tx, &ty))
    {
      pixman_transform_t pixman_transform;

      if (tx != 0. || ty != 0.) {
          cairo_matrix_t m, inv;
          cairo_status_t status;
          double x, y;

          /* pixman also limits the [xy]_offset to 16 bits so evenly
           * spread the bits between the two.
           */
          inv = pattern->base.matrix;
          status = cairo_matrix_invert (&inv);
          assert (status == CAIRO_STATUS_SUCCESS);

          x = floor (inv.x0 / 2);
          y = floor (inv.y0 / 2);
          tx = -x;
          ty = -y;
          cairo_matrix_init_translate (&inv, x, y);
          cairo_matrix_multiply (&m, &inv, &pattern->base.matrix);
          _cairo_matrix_to_pixman_matrix (&m, &pixman_transform,
                                  extents->x + extents->width/2.,
                                  extents->y + extents->height/2.);
      } else {
          tx = ty = 0;
          _cairo_matrix_to_pixman_matrix (&pattern->base.matrix,
                                  &pixman_transform,
                                  extents->x + extents->width/2.,
                                  extents->y + extents->height/2.);
      }

      if (! pixman_image_set_transform (pixman_image, &pixman_transform)) {
          pixman_image_unref (pixman_image);
          return NULL;
      }
    }
    *ix = tx;
    *iy = ty;

    {
      pixman_repeat_t pixman_repeat;

      switch (pattern->base.extend) {
      default:
      case CAIRO_EXTEND_NONE:
          pixman_repeat = PIXMAN_REPEAT_NONE;
          break;
      case CAIRO_EXTEND_REPEAT:
          pixman_repeat = PIXMAN_REPEAT_NORMAL;
          break;
      case CAIRO_EXTEND_REFLECT:
          pixman_repeat = PIXMAN_REPEAT_REFLECT;
          break;
      case CAIRO_EXTEND_PAD:
          pixman_repeat = PIXMAN_REPEAT_PAD;
          break;
      }

      pixman_image_set_repeat (pixman_image, pixman_repeat);
    }

    return pixman_image;
}

01228 struct acquire_source_cleanup {
    cairo_surface_t *surface;
    cairo_image_surface_t *image;
    void *image_extra;
};

static void
_acquire_source_cleanup (pixman_image_t *pixman_image,
                   void *closure)
{
    struct acquire_source_cleanup *data = closure;

    _cairo_surface_release_source_image (data->surface,
                               data->image,
                               data->image_extra);
    free (data);
}

static cairo_filter_t
sampled_area (const cairo_surface_pattern_t *pattern,
            const cairo_rectangle_int_t *extents,
            cairo_rectangle_int_t *sample)
{
    cairo_filter_t filter;
    double x1, x2, y1, y2;
    double pad;

    x1 = extents->x;
    y1 = extents->y;
    x2 = extents->x + (int) extents->width;
    y2 = extents->y + (int) extents->height;

    _cairo_matrix_transform_bounding_box (&pattern->base.matrix,
                                          &x1, &y1, &x2, &y2,
                                          NULL);

    filter = _cairo_pattern_analyze_filter (&pattern->base, &pad);
    sample->x = floor (x1 - pad);
    sample->y = floor (y1 - pad);
    sample->width  = ceil (x2 + pad) - sample->x;
    sample->height = ceil (y2 + pad) - sample->y;

    return filter;
}

static uint16_t
expand_channel (uint16_t v, uint32_t bits)
{
    int offset = 16 - bits;
    while (offset > 0) {
      v |= v >> bits;
      offset -= bits;
      bits += bits;
    }
    return v;
}

static pixman_image_t *
_pixel_to_solid (cairo_image_surface_t *image, int x, int y)
{
    uint32_t pixel;
    pixman_color_t color;

    switch (image->format) {
    default:
    case CAIRO_FORMAT_INVALID:
      ASSERT_NOT_REACHED;
      return NULL;

    case CAIRO_FORMAT_A1:
      pixel = *(uint8_t *) (image->data + y * image->stride + x/8);
      return pixel & (1 << (x&7)) ? _pixman_white_image () : _pixman_transparent_image ();

    case CAIRO_FORMAT_A8:
      color.alpha = *(uint8_t *) (image->data + y * image->stride + x);
      color.alpha |= color.alpha << 8;
      if (color.alpha == 0)
          return _pixman_transparent_image ();

      color.red = color.green = color.blue = 0;
      return pixman_image_create_solid_fill (&color);

    case CAIRO_FORMAT_RGB16_565:
      pixel = *(uint16_t *) (image->data + y * image->stride + 2 * x);
      if (pixel == 0)
          return _pixman_black_image ();
      if (pixel == 0xffff)
          return _pixman_white_image ();

      color.alpha = 0xffff;
      color.red = expand_channel ((pixel >> 11 & 0x1f) << 11, 5);
      color.green = expand_channel ((pixel >> 5 & 0x3f) << 10, 6);
      color.blue = expand_channel ((pixel & 0x1f) << 11, 5);
      return pixman_image_create_solid_fill (&color);

    case CAIRO_FORMAT_ARGB32:
    case CAIRO_FORMAT_RGB24:
      pixel = *(uint32_t *) (image->data + y * image->stride + 4 * x);
      color.alpha = image->format == CAIRO_FORMAT_ARGB32 ? (pixel >> 24) | (pixel >> 16 & 0xff00) : 0xffff;
      if (color.alpha == 0)
          return _pixman_transparent_image ();
      if (pixel == 0xffffffff)
          return _pixman_white_image ();
      if (color.alpha == 0xffff && (pixel & 0xffffff) == 0)
          return _pixman_black_image ();

      color.red = (pixel >> 16 & 0xff) | (pixel >> 8 & 0xff00);
      color.green = (pixel >> 8 & 0xff) | (pixel & 0xff00);
      color.blue = (pixel & 0xff) | (pixel << 8 & 0xff00);
      return pixman_image_create_solid_fill (&color);
    }
}

static pixman_image_t *
_pixman_image_for_surface (const cairo_surface_pattern_t *pattern,
                     cairo_bool_t is_mask,
                     const cairo_rectangle_int_t *extents,
                     int *ix, int *iy)
{
    pixman_image_t *pixman_image;
    cairo_rectangle_int_t sample;
    cairo_extend_t extend;
    cairo_filter_t filter;
    double tx, ty;

    tx = pattern->base.matrix.x0;
    ty = pattern->base.matrix.y0;

    extend = pattern->base.extend;
    filter = sampled_area (pattern, extents, &sample);

    pixman_image = NULL;
    if (pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE &&
      (! is_mask || ! pattern->base.has_component_alpha ||
       (pattern->surface->content & CAIRO_CONTENT_COLOR) == 0))
    {
      cairo_image_surface_t *source = (cairo_image_surface_t *) pattern->surface;
      cairo_surface_type_t type;

      if (source->base.backend->type == CAIRO_INTERNAL_SURFACE_TYPE_SNAPSHOT)
          source = (cairo_image_surface_t *) ((cairo_surface_snapshot_t *) pattern->surface)->target;

      type = source->base.backend->type;
      if (type == CAIRO_SURFACE_TYPE_IMAGE) {
          if (extend != CAIRO_EXTEND_NONE &&
            sample.x >= 0 &&
            sample.y >= 0 &&
            sample.x + sample.width  <= source->width &&
            sample.y + sample.height <= source->height)
          {
            extend = CAIRO_EXTEND_NONE;
          }

          if (sample.width == 1 && sample.height == 1) {
            if (sample.x < 0 ||
                sample.y < 0 ||
                sample.x >= source->width ||
                sample.y >= source->height)
            {
                if (extend == CAIRO_EXTEND_NONE)
                  return _pixman_transparent_image ();
            }
            else
            {
                return _pixel_to_solid (source, sample.x, sample.y);
            }
          }

          /* avoid allocating a 'pattern' image if we can reuse the original */
          if (extend == CAIRO_EXTEND_NONE &&
            _cairo_matrix_is_translation (&pattern->base.matrix) &&
            _nearest_sample (filter, &tx, &ty))
          {
            *ix = tx;
            *iy = ty;
            return pixman_image_ref (source->pixman_image);
          }

          pixman_image = pixman_image_create_bits (source->pixman_format,
                                         source->width,
                                         source->height,
                                         (uint32_t *) source->data,
                                         source->stride);
          if (unlikely (pixman_image == NULL))
            return NULL;
      } else if (type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
          cairo_surface_subsurface_t *sub;
          cairo_bool_t is_contained = FALSE;

          sub = (cairo_surface_subsurface_t *) source;
          source = (cairo_image_surface_t *) sub->target;

          if (sample.x >= 0 &&
            sample.y >= 0 &&
            sample.x + sample.width  <= sub->extents.width &&
            sample.y + sample.height <= sub->extents.height)
          {
            is_contained = TRUE;
          }

          if (sample.width == 1 && sample.height == 1) {
            if (is_contained) {
                return _pixel_to_solid (source,
                                  sub->extents.x + sample.x,
                                  sub->extents.y + sample.y);
            } else {
                if (extend == CAIRO_EXTEND_NONE)
                  return _pixman_transparent_image ();
            }
          }

          if (is_contained &&
            _cairo_matrix_is_translation (&pattern->base.matrix) &&
            _nearest_sample (filter, &tx, &ty))
          {
            *ix = tx + sub->extents.x;
            *iy = ty + sub->extents.y;
            return pixman_image_ref (source->pixman_image);
          }

          /* Avoid sub-byte offsets, force a copy in that case. */
          if (PIXMAN_FORMAT_BPP (source->pixman_format) >= 8) {
            pixman_image = pixman_image_create_bits (source->pixman_format,
                                           sub->extents.width,
                                           sub->extents.height,
                                           (uint32_t *) (source->data + sub->extents.x * PIXMAN_FORMAT_BPP(source->pixman_format)/8 + sub->extents.y * source->stride),
                                           source->stride);
            if (unlikely (pixman_image == NULL))
                return NULL;
          }
      }
    }

    if (pixman_image == NULL) {
      struct acquire_source_cleanup *cleanup;
      cairo_image_surface_t *image;
      void *extra;
      cairo_status_t status;

      status = _cairo_surface_acquire_source_image (pattern->surface, &image, &extra);
      if (unlikely (status))
          return NULL;

      if (sample.width == 1 && sample.height == 1) {
          if (sample.x < 0 ||
            sample.y < 0 ||
            sample.x >= image->width ||
            sample.y >= image->height)
          {
            if (extend == CAIRO_EXTEND_NONE) {
                pixman_image = _pixman_transparent_image ();
                _cairo_surface_release_source_image (pattern->surface, image, extra);
                return pixman_image;
            }
          }
          else
          {
            pixman_image = _pixel_to_solid (image, sample.x, sample.y);
            _cairo_surface_release_source_image (pattern->surface, image, extra);
            return pixman_image;
          }
      }

      pixman_image = pixman_image_create_bits (image->pixman_format,
                                     image->width,
                                     image->height,
                                     (uint32_t *) image->data,
                                     image->stride);
      if (unlikely (pixman_image == NULL)) {
          _cairo_surface_release_source_image (pattern->surface, image, extra);
          return NULL;
      }

      cleanup = malloc (sizeof (*cleanup));
      if (unlikely (cleanup == NULL)) {
          _cairo_surface_release_source_image (pattern->surface, image, extra);
          pixman_image_unref (pixman_image);
          return NULL;
      }

      cleanup->surface = pattern->surface;
      cleanup->image = image;
      cleanup->image_extra = extra;
      pixman_image_set_destroy_function (pixman_image,
                                 _acquire_source_cleanup, cleanup);
    }

    if (! _cairo_matrix_is_translation (&pattern->base.matrix) ||
      ! _nearest_sample (filter, &tx, &ty))
    {
      pixman_transform_t pixman_transform;
      cairo_matrix_t m;

      m = pattern->base.matrix;
      if (m.x0 != 0. || m.y0 != 0.) {
          cairo_matrix_t inv;
          cairo_status_t status;
          double x, y;

          /* pixman also limits the [xy]_offset to 16 bits so evenly
           * spread the bits between the two.
           */
          inv = m;
          status = cairo_matrix_invert (&inv);
          assert (status == CAIRO_STATUS_SUCCESS);

          x = floor (inv.x0 / 2);
          y = floor (inv.y0 / 2);
          tx = -x;
          ty = -y;
          cairo_matrix_init_translate (&inv, x, y);
          cairo_matrix_multiply (&m, &inv, &m);
      } else {
          tx = ty = 0;
      }

      _cairo_matrix_to_pixman_matrix (&m, &pixman_transform,
                              extents->x + extents->width/2.,
                              extents->y + extents->height/2.);
      if (! pixman_image_set_transform (pixman_image, &pixman_transform)) {
          pixman_image_unref (pixman_image);
          return NULL;
      }
    }
    *ix = tx;
    *iy = ty;

    if (_cairo_matrix_has_unity_scale (&pattern->base.matrix) &&
      tx == pattern->base.matrix.x0 &&
      ty == pattern->base.matrix.y0)
    {
      pixman_image_set_filter (pixman_image, PIXMAN_FILTER_NEAREST, NULL, 0);
    }
    else
    {
      pixman_filter_t pixman_filter;

      switch (filter) {
      case CAIRO_FILTER_FAST:
          pixman_filter = PIXMAN_FILTER_FAST;
          break;
      case CAIRO_FILTER_GOOD:
          pixman_filter = PIXMAN_FILTER_GOOD;
          break;
      case CAIRO_FILTER_BEST:
          pixman_filter = PIXMAN_FILTER_BEST;
          break;
      case CAIRO_FILTER_NEAREST:
          pixman_filter = PIXMAN_FILTER_NEAREST;
          break;
      case CAIRO_FILTER_BILINEAR:
          pixman_filter = PIXMAN_FILTER_BILINEAR;
          break;
      case CAIRO_FILTER_GAUSSIAN:
          /* XXX: The GAUSSIAN value has no implementation in cairo
           * whatsoever, so it was really a mistake to have it in the
           * API. We could fix this by officially deprecating it, or
           * else inventing semantics and providing an actual
           * implementation for it. */
      default:
          pixman_filter = PIXMAN_FILTER_BEST;
      }

      pixman_image_set_filter (pixman_image, pixman_filter, NULL, 0);
    }

    {
      pixman_repeat_t pixman_repeat;

      switch (extend) {
      default:
      case CAIRO_EXTEND_NONE:
          pixman_repeat = PIXMAN_REPEAT_NONE;
          break;
      case CAIRO_EXTEND_REPEAT:
          pixman_repeat = PIXMAN_REPEAT_NORMAL;
          break;
      case CAIRO_EXTEND_REFLECT:
          pixman_repeat = PIXMAN_REPEAT_REFLECT;
          break;
      case CAIRO_EXTEND_PAD:
          pixman_repeat = PIXMAN_REPEAT_PAD;
          break;
      }

      pixman_image_set_repeat (pixman_image, pixman_repeat);
    }

    if (pattern->base.has_component_alpha)
      pixman_image_set_component_alpha (pixman_image, TRUE);

    return pixman_image;
}

static pixman_image_t *
_pixman_image_for_pattern (const cairo_pattern_t *pattern,
                     cairo_bool_t is_mask,
                     const cairo_rectangle_int_t *extents,
                     int *tx, int *ty)
{
    *tx = *ty = 0;

    if (pattern == NULL)
      return _pixman_white_image ();

    switch (pattern->type) {
    default:
      ASSERT_NOT_REACHED;
    case CAIRO_PATTERN_TYPE_SOLID:
      return _pixman_image_for_solid ((const cairo_solid_pattern_t *) pattern);

    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_LINEAR:
      return _pixman_image_for_gradient ((const cairo_gradient_pattern_t *) pattern,
                                 extents, tx, ty);

    case CAIRO_PATTERN_TYPE_SURFACE:
      return _pixman_image_for_surface ((const cairo_surface_pattern_t *) pattern,
                                is_mask, extents, tx, ty);
    }
}

static cairo_status_t
_cairo_image_surface_fixup_unbounded (cairo_image_surface_t *dst,
                              const cairo_composite_rectangles_t *rects,
                              cairo_clip_t *clip)
{
    pixman_image_t *mask = NULL;
    pixman_box32_t boxes[4];
    int i, mask_x = 0, mask_y = 0, n_boxes = 0;

    if (clip != NULL) {
      cairo_surface_t *clip_surface;
      int clip_x, clip_y;

      clip_surface = _cairo_clip_get_surface (clip, &dst->base, &clip_x, &clip_y);
      if (unlikely (clip_surface->status))
          return clip_surface->status;

      mask = ((cairo_image_surface_t *) clip_surface)->pixman_image;
      mask_x = -clip_x;
      mask_y = -clip_y;
    } else {
      if (rects->bounded.width  == rects->unbounded.width &&
          rects->bounded.height == rects->unbounded.height)
      {
          return CAIRO_STATUS_SUCCESS;
      }
    }

    /* wholly unbounded? */
    if (rects->bounded.width == 0 || rects->bounded.height == 0) {
      int x = rects->unbounded.x;
      int y = rects->unbounded.y;
      int width = rects->unbounded.width;
      int height = rects->unbounded.height;

      if (mask != NULL) {
          pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE,
                                      mask, NULL, dst->pixman_image,
                                      x + mask_x, y + mask_y,
                                      0, 0,
                                      x, y,
                                      width, height);
      } else {
            pixman_color_t color = { 0, };
            pixman_box32_t box = { x, y, x + width, y + height };

            if (! pixman_image_fill_boxes (PIXMAN_OP_CLEAR,
                                 dst->pixman_image,
                                 &color,
                                 1, &box))
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      }

      return CAIRO_STATUS_SUCCESS;
    }

    /* top */
    if (rects->bounded.y != rects->unbounded.y) {
        boxes[n_boxes].x1 = rects->unbounded.x;
        boxes[n_boxes].y1 = rects->unbounded.y;
        boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width;
        boxes[n_boxes].y2 = rects->bounded.y;
        n_boxes++;
    }

    /* left */
    if (rects->bounded.x != rects->unbounded.x) {
        boxes[n_boxes].x1 = rects->unbounded.x;
        boxes[n_boxes].y1 = rects->bounded.y;
        boxes[n_boxes].x2 = rects->bounded.x;
        boxes[n_boxes].y2 = rects->bounded.y + rects->bounded.height;
        n_boxes++;
    }

    /* right */
    if (rects->bounded.x + rects->bounded.width != rects->unbounded.x + rects->unbounded.width) {
        boxes[n_boxes].x1 = rects->bounded.x + rects->bounded.width;
        boxes[n_boxes].y1 = rects->bounded.y;
        boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width;
        boxes[n_boxes].y2 = rects->bounded.y + rects->bounded.height;
        n_boxes++;
    }

    /* bottom */
    if (rects->bounded.y + rects->bounded.height != rects->unbounded.y + rects->unbounded.height) {
        boxes[n_boxes].x1 = rects->unbounded.x;
        boxes[n_boxes].y1 = rects->bounded.y + rects->bounded.height;
        boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width;
        boxes[n_boxes].y2 = rects->unbounded.y + rects->unbounded.height;
        n_boxes++;
    }

    if (mask != NULL) {
        for (i = 0; i < n_boxes; i++) {
            pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE,
                                      mask, NULL, dst->pixman_image,
                                      boxes[i].x1 + mask_x, boxes[i].y1 + mask_y,
                                      0, 0,
                                      boxes[i].x1, boxes[i].y1,
                                      boxes[i].x2 - boxes[i].x1, boxes[i].y2 - boxes[i].y1);
        }
    } else {
        pixman_color_t color = { 0, };

        if (! pixman_image_fill_boxes (PIXMAN_OP_CLEAR,
                               dst->pixman_image,
                               &color,
                               n_boxes,
                               boxes))
      {
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      }
    }

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_image_surface_fixup_unbounded_boxes (cairo_image_surface_t *dst,
                                  const cairo_composite_rectangles_t *extents,
                                  cairo_region_t *clip_region,
                                  cairo_boxes_t *boxes)
{
    cairo_boxes_t clear;
    cairo_box_t box;
    cairo_status_t status;
    struct _cairo_boxes_chunk *chunk;
    int i;

    if (boxes->num_boxes <= 1 && clip_region == NULL)
      return _cairo_image_surface_fixup_unbounded (dst, extents, NULL);

    _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, &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, &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, &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)) {
      for (chunk = &clear.chunks; chunk != NULL; chunk = chunk->next) {
          for (i = 0; i < chunk->count; i++) {
            int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x);
            int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
            int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
            int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);

            pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t),
                       PIXMAN_FORMAT_BPP (dst->pixman_format),
                       x1, y1, x2 - x1, y2 - y1,
                       0);
          }
      }
    }

    _cairo_boxes_fini (&clear);

    return status;
}

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_image_surface_t *dst,
             cairo_operator_t op,
             const cairo_pattern_t *pattern)
{
    return dst->base.is_clear &&
         dst->base.content == CAIRO_CONTENT_ALPHA &&
         _cairo_pattern_is_opaque_solid (pattern) &&
         can_reduce_alpha_op (op);
}

/* low level compositor */
typedef cairo_status_t
(*image_draw_func_t) (void                      *closure,
                  pixman_image_t                *dst,
                  pixman_format_code_t           dst_format,
                  cairo_operator_t               op,
                  const cairo_pattern_t         *src,
                  int                      dst_x,
                  int                      dst_y,
                  const cairo_rectangle_int_t   *extents,
                  cairo_region_t                *clip_region);

static pixman_image_t *
_create_composite_mask_pattern (cairo_clip_t                  *clip,
                        image_draw_func_t              draw_func,
                        void                          *draw_closure,
                        cairo_image_surface_t         *dst,
                        const cairo_rectangle_int_t   *extents)
{
    cairo_region_t *clip_region = NULL;
    pixman_image_t *mask;
    cairo_status_t status;
    cairo_bool_t need_clip_surface = FALSE;

    if (clip != NULL) {
      status = _cairo_clip_get_region (clip, &clip_region);
      assert (! _cairo_status_is_error (status));

      /* The all-clipped state should never propagate this far. */
      assert (status != CAIRO_INT_STATUS_NOTHING_TO_DO);

      need_clip_surface = status == CAIRO_INT_STATUS_UNSUPPORTED;

      if (clip_region != NULL && cairo_region_num_rectangles (clip_region) == 1)
          clip_region = NULL;
    }

    mask = pixman_image_create_bits (PIXMAN_a8, extents->width, extents->height,
                             NULL, 0);
    if (unlikely (mask == NULL))
      return NULL;

    /* Is it worth setting the clip region here? */
    if (clip_region != NULL) {
      pixman_bool_t ret;

      pixman_region32_translate (&clip_region->rgn, -extents->x, -extents->y);
      ret = pixman_image_set_clip_region32 (mask, &clip_region->rgn);
      pixman_region32_translate (&clip_region->rgn, extents->x, extents->y);

      if (! ret) {
          pixman_image_unref (mask);
          return NULL;
      }
    }

    status = draw_func (draw_closure,
                  mask, PIXMAN_a8,
                  CAIRO_OPERATOR_ADD, NULL,
                  extents->x, extents->y,
                  extents, NULL);
    if (unlikely (status)) {
      pixman_image_unref (mask);
      return NULL;
    }

    if (need_clip_surface) {
      cairo_surface_t *tmp;

      tmp = _cairo_image_surface_create_for_pixman_image (mask, PIXMAN_a8);
      if (unlikely (tmp->status)) {
          pixman_image_unref (mask);
          return NULL;
      }

      pixman_image_ref (mask);

      status = _cairo_clip_combine_with_surface (clip, tmp, extents->x, extents->y);
      cairo_surface_destroy (tmp);
      if (unlikely (status)) {
          pixman_image_unref (mask);
          return NULL;
      }
    }

    if (clip_region != NULL)
      pixman_image_set_clip_region (mask, NULL);

    return mask;
}

/* 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 (cairo_clip_t                  *clip,
                         cairo_operator_t               op,
                         const cairo_pattern_t         *pattern,
                         image_draw_func_t              draw_func,
                         void                          *draw_closure,
                         cairo_image_surface_t         *dst,
                         const cairo_rectangle_int_t   *extents)
{
    pixman_image_t *mask;

    mask = _create_composite_mask_pattern (clip, draw_func, draw_closure, dst, extents);
    if (unlikely (mask == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    if (pattern == NULL) {
      if (dst->pixman_format == PIXMAN_a8) {
          pixman_image_composite32 (_pixman_operator (op),
                                      mask, NULL, dst->pixman_image,
                                      0, 0, 0, 0,
                                      extents->x,      extents->y,
                                      extents->width,  extents->height);
      } else {
          pixman_image_t *src;

          src = _pixman_white_image ();
          if (unlikely (src == NULL)) {
            pixman_image_unref (mask);
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
          }

          pixman_image_composite32 (_pixman_operator (op),
                                      src, mask, dst->pixman_image,
                                      0, 0, 0, 0,
                                      extents->x,      extents->y,
                                      extents->width,  extents->height);
          pixman_image_unref (src);
      }
    } else {
      pixman_image_t *src;
      int src_x, src_y;

      src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
      if (unlikely (src == NULL)) {
          pixman_image_unref (mask);
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      }

      pixman_image_composite32 (_pixman_operator (op),
                                  src, mask, dst->pixman_image,
                                  extents->x + src_x,  extents->y + src_y,
                                  0, 0,
                                  extents->x,          extents->y,
                                  extents->width,      extents->height);
      pixman_image_unref (src);
    }

    pixman_image_unref (mask);

    return CAIRO_STATUS_SUCCESS;
}

/* 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 (cairo_clip_t                  *clip,
                       cairo_operator_t               op,
                       const cairo_pattern_t         *src,
                       image_draw_func_t              draw_func,
                       void                          *draw_closure,
                       cairo_image_surface_t               *dst,
                       const cairo_rectangle_int_t   *extents)
{
    pixman_image_t *tmp;
    cairo_surface_t *clip_surface;
    int clip_x, clip_y;
    cairo_status_t status;

    tmp  = pixman_image_create_bits (dst->pixman_format,
                             extents->width, extents->height,
                             NULL, 0);
    if (unlikely (tmp == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    if (src == NULL) {
      status = (*draw_func) (draw_closure,
                         tmp, dst->pixman_format,
                         CAIRO_OPERATOR_ADD, NULL,
                         extents->x, extents->y,
                         extents, NULL);
    } else {
      /* Initialize the temporary surface from the destination surface */
      if (! dst->base.is_clear) {
          pixman_image_composite32 (PIXMAN_OP_SRC,
                                      dst->pixman_image, NULL, tmp,
                                      extents->x, extents->y,
                                      0, 0,
                                      0, 0,
                                      extents->width, extents->height);
      }

      status = (*draw_func) (draw_closure,
                         tmp, dst->pixman_format,
                         op, src,
                         extents->x, extents->y,
                         extents, NULL);
    }
    if (unlikely (status))
      goto CLEANUP_SURFACE;

    assert (clip->path != NULL);
    clip_surface = _cairo_clip_get_surface (clip, &dst->base, &clip_x, &clip_y);
    if (unlikely (clip_surface->status))
      goto CLEANUP_SURFACE;

    if (! dst->base.is_clear) {
#if PIXMAN_HAS_OP_LERP
      pixman_image_composite32 (PIXMAN_OP_LERP,
                                  tmp,
                                  ((cairo_image_surface_t *) clip_surface)->pixman_image,
                                  dst->pixman_image,
                                  0, 0,
                                  extents->x - clip_x,
                                  extents->y - clip_y,
                                  extents->x, extents->y,
                                  extents->width, extents->height);
#else
      /* Punch the clip out of the destination */
      pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE,
                                  ((cairo_image_surface_t *) clip_surface)->pixman_image,
                                  NULL, dst->pixman_image,
                                  extents->x - clip_x,
                                  extents->y - clip_y,
                                  0, 0,
                                  extents->x, extents->y,
                                  extents->width, extents->height);

      /* Now add the two results together */
      pixman_image_composite32 (PIXMAN_OP_ADD,
                                  tmp,
                                  ((cairo_image_surface_t *) clip_surface)->pixman_image,
                                  dst->pixman_image,
                                  0, 0,
                                  extents->x - clip_x,
                                  extents->y - clip_y,
                                  extents->x, extents->y,
                                  extents->width, extents->height);
#endif
    } else {
      pixman_image_composite32 (PIXMAN_OP_SRC,
                                  tmp,
                                  ((cairo_image_surface_t *) clip_surface)->pixman_image,
                                  dst->pixman_image,
                                  0, 0,
                                  extents->x - clip_x,
                                  extents->y - clip_y,
                                  extents->x, extents->y,
                                  extents->width, extents->height);
    }

 CLEANUP_SURFACE:
    pixman_image_unref (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 (cairo_clip_t                  *clip,
                      const cairo_pattern_t         *pattern,
                      image_draw_func_t              draw_func,
                      void                          *draw_closure,
                      cairo_image_surface_t         *dst,
                      const cairo_rectangle_int_t   *extents)
{
    pixman_image_t *mask, *src;
    int src_x, src_y;

    if (pattern == NULL) {
      cairo_region_t *clip_region;
      cairo_status_t status;

      status = draw_func (draw_closure,
                      dst->pixman_image, dst->pixman_format,
                      CAIRO_OPERATOR_SOURCE, NULL,
                      extents->x, extents->y,
                      extents, NULL);
      if (unlikely (status))
          return status;

      if (_cairo_clip_get_region (clip, &clip_region) == CAIRO_INT_STATUS_UNSUPPORTED)
          status = _cairo_clip_combine_with_surface (clip, &dst->base, 0, 0);

      return status;
    }

    /* Create a surface that is mask IN clip */
    mask = _create_composite_mask_pattern (clip, draw_func, draw_closure, dst, extents);
    if (unlikely (mask == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
    if (unlikely (src == NULL)) {
      pixman_image_unref (mask);
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    if (! dst->base.is_clear) {
#if PIXMAN_HAS_OP_LERP
      pixman_image_composite32 (PIXMAN_OP_LERP,
                                  src, mask, dst->pixman_image,
                                  extents->x + src_x, extents->y + src_y,
                                  0, 0,
                                  extents->x,     extents->y,
                                  extents->width, extents->height);
#else
      /* Compute dest' = dest OUT (mask IN clip) */
      pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE,
                                  mask, NULL, dst->pixman_image,
                                  0, 0, 0, 0,
                                  extents->x,     extents->y,
                                  extents->width, extents->height);

      /* Now compute (src IN (mask IN clip)) ADD dest' */
      pixman_image_composite32 (PIXMAN_OP_ADD,
                                  src, mask, dst->pixman_image,
                                  extents->x + src_x, extents->y + src_y,
                                  0, 0,
                                  extents->x,     extents->y,
                                  extents->width, extents->height);
#endif
    } else {
      pixman_image_composite32 (PIXMAN_OP_SRC,
                                  src, mask, dst->pixman_image,
                                  extents->x + src_x, extents->y + src_y,
                                  0, 0,
                                  extents->x,     extents->y,
                                  extents->width, extents->height);
    }

    pixman_image_unref (src);
    pixman_image_unref (mask);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_clip_and_composite (cairo_image_surface_t      *dst,
                 cairo_operator_t          op,
                 const cairo_pattern_t    *src,
                 image_draw_func_t         draw_func,
                 void               *draw_closure,
                 cairo_composite_rectangles_t*extents,
                 cairo_clip_t       *clip)
{
    cairo_status_t status;
    cairo_region_t *clip_region = NULL;
    cairo_bool_t need_clip_surface = FALSE;

    if (clip != NULL) {
      status = _cairo_clip_get_region (clip, &clip_region);
      if (unlikely (status == CAIRO_INT_STATUS_NOTHING_TO_DO))
          return CAIRO_STATUS_SUCCESS;
      if (unlikely (_cairo_status_is_error (status)))
          return status;

      need_clip_surface = status == CAIRO_INT_STATUS_UNSUPPORTED;

      if (clip_region != NULL) {
          cairo_rectangle_int_t rect;
          cairo_bool_t is_empty;

          cairo_region_get_extents (clip_region, &rect);
          is_empty = ! _cairo_rectangle_intersect (&extents->unbounded, &rect);
          if (unlikely (is_empty))
            return CAIRO_STATUS_SUCCESS;

          is_empty = ! _cairo_rectangle_intersect (&extents->bounded, &rect);
          if (unlikely (is_empty && extents->is_bounded))
            return CAIRO_STATUS_SUCCESS;

          if (cairo_region_num_rectangles (clip_region) == 1)
            clip_region = NULL;
      }
    }

    if (clip_region != NULL) {
      status = _cairo_image_surface_set_clip_region (dst, clip_region);
      if (unlikely (status))
          return status;
    }

    if (reduce_alpha_op (dst, op, src)) {
      op = CAIRO_OPERATOR_ADD;
      src = NULL;
    }

    if (op == CAIRO_OPERATOR_SOURCE) {
      status = _clip_and_composite_source (clip, src,
                                   draw_func, draw_closure,
                                   dst, &extents->bounded);
    } else {
      if (op == CAIRO_OPERATOR_CLEAR) {
          src = NULL;
          op = CAIRO_OPERATOR_DEST_OUT;
      }

      if (need_clip_surface) {
          if (extents->is_bounded) {
            status = _clip_and_composite_with_mask (clip, op, src,
                                          draw_func, draw_closure,
                                          dst, &extents->bounded);
          } else {
            status = _clip_and_composite_combine (clip, op, src,
                                          draw_func, draw_closure,
                                          dst, &extents->bounded);
          }
      } else {
          status = draw_func (draw_closure,
                        dst->pixman_image, dst->pixman_format,
                        op, src,
                        0, 0,
                        &extents->bounded,
                        clip_region);
      }
    }

    if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) {
      status = _cairo_image_surface_fixup_unbounded (dst, extents,
                                           need_clip_surface ? clip : NULL);
    }

    if (clip_region != NULL)
      _cairo_image_surface_unset_clip_region (dst);

    return status;
}

#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768)
#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767)

static cairo_bool_t
_line_exceeds_16_16 (const cairo_line_t *line)
{
    return
      line->p1.x <= CAIRO_FIXED_16_16_MIN ||
      line->p1.x >= CAIRO_FIXED_16_16_MAX ||

      line->p2.x <= CAIRO_FIXED_16_16_MIN ||
      line->p2.x >= CAIRO_FIXED_16_16_MAX ||

      line->p1.y <= CAIRO_FIXED_16_16_MIN ||
      line->p1.y >= CAIRO_FIXED_16_16_MAX ||

      line->p2.y <= CAIRO_FIXED_16_16_MIN ||
      line->p2.y >= CAIRO_FIXED_16_16_MAX;
}

static void
_project_line_x_onto_16_16 (const cairo_line_t *line,
                      cairo_fixed_t top,
                      cairo_fixed_t bottom,
                      pixman_line_fixed_t *out)
{
    cairo_point_double_t p1, p2;
    double m;

    p1.x = _cairo_fixed_to_double (line->p1.x);
    p1.y = _cairo_fixed_to_double (line->p1.y);

    p2.x = _cairo_fixed_to_double (line->p2.x);
    p2.y = _cairo_fixed_to_double (line->p2.y);

    m = (p2.x - p1.x) / (p2.y - p1.y);
    out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y));
    out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y));
}


02351 typedef struct {
    cairo_trapezoid_t *traps;
    int num_traps;
    cairo_antialias_t antialias;
} composite_traps_info_t;

static void
_pixman_image_add_traps (pixman_image_t *image,
                   int dst_x, int dst_y,
                   composite_traps_info_t *info)
{
    cairo_trapezoid_t *t = info->traps;
    int num_traps = info->num_traps;
    while (num_traps--) {
      pixman_trapezoid_t trap;

      /* top/bottom will be clamped to surface bounds */
      trap.top = _cairo_fixed_to_16_16 (t->top);
      trap.bottom = _cairo_fixed_to_16_16 (t->bottom);

      /* However, all the other coordinates will have been left untouched so
       * as not to introduce numerical error. Recompute them if they
       * exceed the 16.16 limits.
       */
      if (unlikely (_line_exceeds_16_16 (&t->left))) {
          _project_line_x_onto_16_16 (&t->left, t->top, t->bottom, &trap.left);
          trap.left.p1.y = trap.top;
          trap.left.p2.y = trap.bottom;
      } else {
          trap.left.p1.x = _cairo_fixed_to_16_16 (t->left.p1.x);
          trap.left.p1.y = _cairo_fixed_to_16_16 (t->left.p1.y);
          trap.left.p2.x = _cairo_fixed_to_16_16 (t->left.p2.x);
          trap.left.p2.y = _cairo_fixed_to_16_16 (t->left.p2.y);
      }

      if (unlikely (_line_exceeds_16_16 (&t->right))) {
          _project_line_x_onto_16_16 (&t->right, t->top, t->bottom, &trap.right);
          trap.right.p1.y = trap.top;
          trap.right.p2.y = trap.bottom;
      } else {
          trap.right.p1.x = _cairo_fixed_to_16_16 (t->right.p1.x);
          trap.right.p1.y = _cairo_fixed_to_16_16 (t->right.p1.y);
          trap.right.p2.x = _cairo_fixed_to_16_16 (t->right.p2.x);
          trap.right.p2.y = _cairo_fixed_to_16_16 (t->right.p2.y);
      }

      pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y);

      t++;
    }
}

static cairo_status_t
_composite_traps (void                          *closure,
              pixman_image_t        *dst,
              pixman_format_code_t         dst_format,
              cairo_operator_t               op,
              const cairo_pattern_t         *pattern,
              int                            dst_x,
              int                            dst_y,
              const cairo_rectangle_int_t   *extents,
              cairo_region_t        *clip_region)
{
    composite_traps_info_t *info = closure;
    pixman_image_t *src, *mask;
    pixman_format_code_t format;
    int src_x = 0, src_y = 0;
    cairo_status_t status;

    /* Special case adding trapezoids onto a mask surface; we want to avoid
     * creating an intermediate temporary mask unnecessarily.
     *
     * We make the assumption here that the portion of the trapezoids
     * contained within the surface is bounded by [dst_x,dst_y,width,height];
     * the Cairo core code passes bounds based on the trapezoid extents.
     */
    format = info->antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8;
    if (dst_format == format &&
      (pattern == NULL ||
       (op == CAIRO_OPERATOR_ADD && _cairo_pattern_is_opaque_solid (pattern))))
    {
      _pixman_image_add_traps (dst, dst_x, dst_y, info);
      return CAIRO_STATUS_SUCCESS;
    }

    src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
    if (unlikely (src == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    mask = pixman_image_create_bits (format, extents->width, extents->height,
                             NULL, 0);
    if (unlikely (mask == NULL)) {
      status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
      goto CLEANUP_SOURCE;
    }

    _pixman_image_add_traps (mask, extents->x, extents->y, info);
    pixman_image_composite32 (_pixman_operator (op),
                              src, mask, dst,
                              extents->x + src_x, extents->y + src_y,
                              0, 0,
                              extents->x - dst_x, extents->y - dst_y,
                              extents->width, extents->height);

    pixman_image_unref (mask);

    status = CAIRO_STATUS_SUCCESS;
 CLEANUP_SOURCE:
    pixman_image_unref (src);

    return status;
}

static inline uint32_t
color_to_uint32 (const cairo_color_t *color)
{
    return
        (color->alpha_short >> 8 << 24) |
        (color->red_short >> 8 << 16)   |
        (color->green_short & 0xff00)   |
        (color->blue_short >> 8);
}

static inline cairo_bool_t
color_to_pixel (const cairo_color_t *color,
                pixman_format_code_t       format,
                uint32_t            *pixel)
{
    uint32_t c;

    if (!(format == PIXMAN_a8r8g8b8     ||
          format == PIXMAN_x8r8g8b8     ||
          format == PIXMAN_a8b8g8r8     ||
          format == PIXMAN_x8b8g8r8     ||
          format == PIXMAN_b8g8r8a8     ||
          format == PIXMAN_b8g8r8x8     ||
          format == PIXMAN_r5g6b5       ||
          format == PIXMAN_b5g6r5       ||
          format == PIXMAN_a8))
    {
      return FALSE;
    }

    c = color_to_uint32 (color);

    if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_ABGR) {
      c = ((c & 0xff000000) >>  0) |
          ((c & 0x00ff0000) >> 16) |
          ((c & 0x0000ff00) >>  0) |
          ((c & 0x000000ff) << 16);
    }

    if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_BGRA) {
      c = ((c & 0xff000000) >> 24) |
          ((c & 0x00ff0000) >>  8) |
          ((c & 0x0000ff00) <<  8) |
          ((c & 0x000000ff) << 24);
    }

    if (format == PIXMAN_a8) {
      c = c >> 24;
    } else if (format == PIXMAN_r5g6b5 || format == PIXMAN_b5g6r5) {
      c = ((((c) >> 3) & 0x001f) |
           (((c) >> 5) & 0x07e0) |
           (((c) >> 8) & 0xf800));
    }

    *pixel = c;
    return TRUE;
}

static inline cairo_bool_t
pattern_to_pixel (const cairo_solid_pattern_t *solid,
              cairo_operator_t op,
              pixman_format_code_t format,
              uint32_t *pixel)
{
    if (op == CAIRO_OPERATOR_CLEAR) {
      *pixel = 0;
      return TRUE;
    }

    if (solid->base.type != CAIRO_PATTERN_TYPE_SOLID)
      return FALSE;

    if (op == CAIRO_OPERATOR_OVER) {
      if (solid->color.alpha_short >= 0xff00)
          op = CAIRO_OPERATOR_SOURCE;
    }

    if (op != CAIRO_OPERATOR_SOURCE)
      return FALSE;

    return color_to_pixel (&solid->color, format, pixel);
}

02547 typedef struct _fill_span {
    cairo_span_renderer_t base;

    uint8_t *mask_data;
    pixman_image_t *src, *dst, *mask;
} fill_span_renderer_t;

static cairo_status_t
_fill_span (void *abstract_renderer,
          int y, int height,
          const cairo_half_open_span_t *spans,
          unsigned num_spans)
{
    fill_span_renderer_t *renderer = abstract_renderer;
    uint8_t *row;
    unsigned i;

    if (num_spans == 0)
      return CAIRO_STATUS_SUCCESS;

    row = renderer->mask_data - spans[0].x;
    for (i = 0; i < num_spans - 1; i++) {
      /* We implement setting the most common single pixel wide
       * span case to avoid the overhead of a memset call.
       * Open coding setting longer spans didn't show a
       * noticeable improvement over memset.
       */
      if (spans[i+1].x == spans[i].x + 1) {
          row[spans[i].x] = spans[i].coverage;
      } else {
          memset (row + spans[i].x,
                spans[i].coverage,
                spans[i+1].x - spans[i].x);
      }
    }

    do {
      pixman_image_composite32 (PIXMAN_OP_OVER,
                                  renderer->src, renderer->mask, renderer->dst,
                                  0, 0, 0, 0,
                                  spans[0].x, y++,
                                  spans[i].x - spans[0].x, 1);
    } while (--height);

    return CAIRO_STATUS_SUCCESS;
}

/* avoid using region code to re-validate boxes */
static cairo_status_t
_fill_unaligned_boxes (cairo_image_surface_t *dst,
                   const cairo_pattern_t *pattern,
                   uint32_t pixel,
                   const cairo_boxes_t *boxes,
                   const cairo_composite_rectangles_t *extents)
{
    uint8_t buf[CAIRO_STACK_BUFFER_SIZE];
    fill_span_renderer_t renderer;
    cairo_rectangular_scan_converter_t converter;
    const struct _cairo_boxes_chunk *chunk;
    cairo_status_t status;
    int i;

    /* XXX
     * using composite for fill:
     *   spiral-box-nonalign-evenodd-fill.512    2201957    2.202
     *   spiral-box-nonalign-nonzero-fill.512     336726    0.337
     *   spiral-box-pixalign-evenodd-fill.512     352256    0.352
     *   spiral-box-pixalign-nonzero-fill.512     147056    0.147
     * using fill:
     *   spiral-box-nonalign-evenodd-fill.512    3174565    3.175
     *   spiral-box-nonalign-nonzero-fill.512     182710    0.183
     *   spiral-box-pixalign-evenodd-fill.512     353863    0.354
     *   spiral-box-pixalign-nonzero-fill.512     147402    0.147
     *
     * cairo-perf-trace seems to favour using fill.
     */

    renderer.base.render_rows = _fill_span;
    renderer.dst = dst->pixman_image;

    if ((unsigned) extents->bounded.width <= sizeof (buf)) {
      renderer.mask = pixman_image_create_bits (PIXMAN_a8,
                                      extents->bounded.width, 1,
                                      (uint32_t *) buf,
                                      sizeof (buf));
    } else {
      renderer.mask = pixman_image_create_bits (PIXMAN_a8,
                                      extents->bounded.width, 1,
                                      NULL,  0);
    }
    if (unlikely (renderer.mask == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    renderer.mask_data = (uint8_t *) pixman_image_get_data (renderer.mask);

    renderer.src = _pixman_image_for_solid ((const cairo_solid_pattern_t *) pattern);
    if (unlikely (renderer.src == NULL)) {
      status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
      goto CLEANUP_MASK;
    }

    _cairo_rectangular_scan_converter_init (&converter, &extents->bounded);

    /* first blit any aligned part of the boxes */
    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
      const cairo_box_t *box = chunk->base;

      for (i = 0; i < chunk->count; i++) {
          int x1 = _cairo_fixed_integer_ceil (box[i].p1.x);
          int y1 = _cairo_fixed_integer_ceil (box[i].p1.y);
          int x2 = _cairo_fixed_integer_floor (box[i].p2.x);
          int y2 = _cairo_fixed_integer_floor (box[i].p2.y);

          if (x2 > x1 && y2 > y1) {
            cairo_box_t b;

            pixman_fill ((uint32_t *) dst->data,
                       dst->stride / sizeof (uint32_t),
                       PIXMAN_FORMAT_BPP (dst->pixman_format),
                       x1, y1, x2 - x1, y2 - y1,
                       pixel);

            /* top */
            if (! _cairo_fixed_is_integer (box[i].p1.y)) {
                b.p1.x = box[i].p1.x;
                b.p1.y = box[i].p1.y;
                b.p2.x = box[i].p2.x;
                b.p2.y = _cairo_fixed_from_int (y1);

                status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1);
                if (unlikely (status))
                  goto CLEANUP_CONVERTER;
            }

            /* left */
            if (! _cairo_fixed_is_integer (box[i].p1.x)) {
                b.p1.x = box[i].p1.x;
                b.p1.y = box[i].p1.y;
                b.p2.x = _cairo_fixed_from_int (x1);
                b.p2.y = box[i].p2.y;

                status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1);
                if (unlikely (status))
                  goto CLEANUP_CONVERTER;
            }

            /* right */
            if (! _cairo_fixed_is_integer (box[i].p2.x)) {
                b.p1.x = _cairo_fixed_from_int (x2);
                b.p1.y = box[i].p1.y;
                b.p2.x = box[i].p2.x;
                b.p2.y = box[i].p2.y;

                status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1);
                if (unlikely (status))
                  goto CLEANUP_CONVERTER;
            }

            /* bottom */
            if (! _cairo_fixed_is_integer (box[i].p2.y)) {
                b.p1.x = box[i].p1.x;
                b.p1.y = _cairo_fixed_from_int (y2);
                b.p2.x = box[i].p2.x;
                b.p2.y = box[i].p2.y;

                status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1);
                if (unlikely (status))
                  goto CLEANUP_CONVERTER;
            }
          } else {
            status = _cairo_rectangular_scan_converter_add_box (&converter, &box[i], 1);
            if (unlikely (status))
                goto CLEANUP_CONVERTER;
          }
      }
    }

    status = converter.base.generate (&converter.base, &renderer.base);

  CLEANUP_CONVERTER:
    converter.base.destroy (&converter.base);
    pixman_image_unref (renderer.src);
  CLEANUP_MASK:
    pixman_image_unref (renderer.mask);

    return status;
}

02735 typedef struct _cairo_image_surface_span_renderer {
    cairo_span_renderer_t base;

    uint8_t *mask_data;
    uint32_t mask_stride;
} cairo_image_surface_span_renderer_t;

static cairo_status_t
_cairo_image_surface_span (void *abstract_renderer,
                     int y, int height,
                     const cairo_half_open_span_t *spans,
                     unsigned num_spans)
{
    cairo_image_surface_span_renderer_t *renderer = abstract_renderer;
    uint8_t *row;
    unsigned i;

    if (num_spans == 0)
      return CAIRO_STATUS_SUCCESS;

    /* XXX will it be quicker to repeat the sparse memset,
     * or perform a simpler memcpy?
     * The fairly dense spiral benchmarks suggests that the sparse
     * memset is a win there as well.
     */
    row = renderer->mask_data + y * renderer->mask_stride;
    do {
      for (i = 0; i < num_spans - 1; i++) {
          if (! spans[i].coverage)
            continue;

          /* We implement setting rendering the most common single
           * pixel wide span case to avoid the overhead of a memset
           * call.  Open coding setting longer spans didn't show a
           * noticeable improvement over memset. */
          if (spans[i+1].x == spans[i].x + 1) {
            row[spans[i].x] = spans[i].coverage;
          } else {
            memset (row + spans[i].x,
                  spans[i].coverage,
                  spans[i+1].x - spans[i].x);
          }
      }
      row += renderer->mask_stride;
    } while (--height);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_composite_unaligned_boxes (cairo_image_surface_t *dst,
                      cairo_operator_t op,
                      const cairo_pattern_t *pattern,
                      const cairo_boxes_t *boxes,
                      const cairo_composite_rectangles_t *extents)
{
    uint8_t buf[CAIRO_STACK_BUFFER_SIZE];
    cairo_image_surface_span_renderer_t renderer;
    cairo_rectangular_scan_converter_t converter;
    pixman_image_t *mask, *src;
    cairo_status_t status;
    const struct _cairo_boxes_chunk *chunk;
    int i, src_x, src_y;

    i = CAIRO_STRIDE_FOR_WIDTH_BPP (extents->bounded.width, 8) * extents->bounded.height;
    if ((unsigned) i <= sizeof (buf)) {
      mask = pixman_image_create_bits (PIXMAN_a8,
                               extents->bounded.width,
                               extents->bounded.height,
                               (uint32_t *) buf,
                               CAIRO_STRIDE_FOR_WIDTH_BPP (extents->bounded.width, 8));
      memset (buf, 0, i);
    } else {
      mask = pixman_image_create_bits (PIXMAN_a8,
                               extents->bounded.width,
                               extents->bounded.height,
                               NULL,  0);
    }
    if (unlikely (mask == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    renderer.base.render_rows = _cairo_image_surface_span;
    renderer.mask_stride = pixman_image_get_stride (mask);
    renderer.mask_data = (uint8_t *) pixman_image_get_data (mask);
    renderer.mask_data -= extents->bounded.y * renderer.mask_stride + extents->bounded.x;

    _cairo_rectangular_scan_converter_init (&converter, &extents->bounded);

    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
      const cairo_box_t *box = chunk->base;

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

    status = converter.base.generate (&converter.base, &renderer.base);
    if (unlikely (status))
      goto CLEANUP;

    src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, &src_x, &src_y);
    if (unlikely (src == NULL)) {
      status =  _cairo_error (CAIRO_STATUS_NO_MEMORY);
      goto CLEANUP;
    }

    pixman_image_composite32 (_pixman_operator (op),
                              src, mask, dst->pixman_image,
                              extents->bounded.x + src_x, extents->bounded.y + src_y,
                              0, 0,
                              extents->bounded.x, extents->bounded.y,
                              extents->bounded.width, extents->bounded.height);
    pixman_image_unref (src);

  CLEANUP:
    converter.base.destroy (&converter.base);
    pixman_image_unref (mask);

    return status;
}

static cairo_status_t
_composite_boxes (cairo_image_surface_t *dst,
              cairo_operator_t op,
              const cairo_pattern_t *pattern,
              cairo_boxes_t *boxes,
              cairo_antialias_t antialias,
              cairo_clip_t *clip,
              const cairo_composite_rectangles_t *extents)
{
    cairo_region_t *clip_region = NULL;
    cairo_bool_t need_clip_mask = FALSE;
    cairo_status_t status;
    struct _cairo_boxes_chunk *chunk;
    uint32_t pixel;
    int i;

    if (clip != NULL) {
      status = _cairo_clip_get_region (clip, &clip_region);
      need_clip_mask = status == CAIRO_INT_STATUS_UNSUPPORTED;
      if (need_clip_mask &&
          (op == CAIRO_OPERATOR_SOURCE || ! extents->is_bounded))
      {
          return CAIRO_INT_STATUS_UNSUPPORTED;
      }

      if (clip_region != NULL && cairo_region_num_rectangles (clip_region) == 1)
          clip_region = NULL;
    }

    if (antialias != CAIRO_ANTIALIAS_NONE) {
      if (! boxes->is_pixel_aligned) {
          if (need_clip_mask)
            return CAIRO_INT_STATUS_UNSUPPORTED;

          if (pattern_to_pixel ((cairo_solid_pattern_t *) pattern, op,
                          dst->pixman_format, &pixel))
          {
            return _fill_unaligned_boxes (dst, pattern, pixel, boxes, extents);
          }
          else
          {
            return _composite_unaligned_boxes (dst, op, pattern, boxes, extents);
          }
      }
    }

    status = CAIRO_STATUS_SUCCESS;
    if (! need_clip_mask &&
      pattern_to_pixel ((cairo_solid_pattern_t *) pattern, op, dst->pixman_format,
                    &pixel))
    {
      for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
          cairo_box_t *box = chunk->base;

          for (i = 0; i < chunk->count; i++) {
            int x1 = _cairo_fixed_integer_round_down (box[i].p1.x);
            int y1 = _cairo_fixed_integer_round_down (box[i].p1.y);
            int x2 = _cairo_fixed_integer_round_down (box[i].p2.x);
            int y2 = _cairo_fixed_integer_round_down (box[i].p2.y);

            if (x2 == x1 || y2 == y1)
                continue;

            pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t),
                       PIXMAN_FORMAT_BPP (dst->pixman_format),
                       x1, y1, x2 - x1, y2 - y1,
                       pixel);
          }
      }
    }
    else
    {
      pixman_image_t *src = NULL, *mask = NULL;
      int src_x, src_y, mask_x = 0, mask_y = 0;
      pixman_op_t pixman_op = _pixman_operator (op);

      if (need_clip_mask) {
          cairo_surface_t *clip_surface;
          int clip_x, clip_y;

          clip_surface = _cairo_clip_get_surface (clip, &dst->base, &clip_x, &clip_y);
          if (unlikely (clip_surface->status))
            return clip_surface->status;

          mask_x = -clip_x;
          mask_y = -clip_y;

          if (op == CAIRO_OPERATOR_CLEAR) {
            pattern = NULL;
            pixman_op = PIXMAN_OP_OUT_REVERSE;
          }

          mask = ((cairo_image_surface_t *) clip_surface)->pixman_image;
      }

      if (pattern != NULL) {
          src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, &src_x, &src_y);
          if (unlikely (src == NULL))
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      } else {
          src = mask;
          src_x = mask_x;
          src_y = mask_y;
          mask = NULL;
      }

      for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
          const cairo_box_t *box = chunk->base;

          for (i = 0; i < chunk->count; i++) {
            int x1 = _cairo_fixed_integer_round_down (box[i].p1.x);
            int y1 = _cairo_fixed_integer_round_down (box[i].p1.y);
            int x2 = _cairo_fixed_integer_round_down (box[i].p2.x);
            int y2 = _cairo_fixed_integer_round_down (box[i].p2.y);

            if (x2 == x1 || y2 == y1)
                continue;

            pixman_image_composite32 (pixman_op,
                                          src, mask, dst->pixman_image,
                                          x1 + src_x,  y1 + src_y,
                                          x1 + mask_x, y1 + mask_y,
                                          x1, y1,
                                          x2 - x1, y2 - y1);
          }
      }

      if (pattern != NULL)
          pixman_image_unref (src);

      if (! extents->is_bounded) {
          status =
            _cairo_image_surface_fixup_unbounded_boxes (dst, extents,
                                              clip_region, boxes);
      }
    }

    return status;
}

static cairo_status_t
_clip_and_composite_boxes (cairo_image_surface_t *dst,
                     cairo_operator_t op,
                     const cairo_pattern_t *src,
                     cairo_boxes_t *boxes,
                     cairo_antialias_t antialias,
                     cairo_composite_rectangles_t *extents,
                     cairo_clip_t *clip)
{
    cairo_traps_t traps;
    cairo_status_t status;
    composite_traps_info_t info;

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

    /* Use a fast path if the boxes are pixel aligned */
    status = _composite_boxes (dst, op, src, boxes, antialias, clip, extents);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
      return status;

    /* Otherwise render via a mask and composite in the usual fashion.  */
    status = _cairo_traps_init_boxes (&traps, boxes);
    if (unlikely (status))
      return status;

    info.num_traps = traps.num_traps;
    info.traps = traps.traps;
    info.antialias = antialias;
    status = _clip_and_composite (dst, op, src,
                          _composite_traps, &info,
                          extents, clip);

    _cairo_traps_fini (&traps);
    return status;
}

static cairo_bool_t
_mono_edge_is_vertical (const cairo_line_t *line)
{
    return _cairo_fixed_integer_round_down (line->p1.x) == _cairo_fixed_integer_round_down (line->p2.x);
}

static cairo_bool_t
_traps_are_pixel_aligned (cairo_traps_t *traps,
                    cairo_antialias_t antialias)
{
    int i;

    if (antialias == CAIRO_ANTIALIAS_NONE) {
      for (i = 0; i < traps->num_traps; i++) {
          if (! _mono_edge_is_vertical (&traps->traps[i].left)   ||
            ! _mono_edge_is_vertical (&traps->traps[i].right))
          {
            traps->maybe_region = FALSE;
            return FALSE;
          }
      }
    } else {
      for (i = 0; i < traps->num_traps; i++) {
          if (traps->traps[i].left.p1.x != traps->traps[i].left.p2.x   ||
            traps->traps[i].right.p1.x != traps->traps[i].right.p2.x ||
            ! _cairo_fixed_is_integer (traps->traps[i].top)          ||
            ! _cairo_fixed_is_integer (traps->traps[i].bottom)       ||
            ! _cairo_fixed_is_integer (traps->traps[i].left.p1.x)    ||
            ! _cairo_fixed_is_integer (traps->traps[i].right.p1.x))
          {
            traps->maybe_region = FALSE;
            return FALSE;
          }
      }
    }

    return TRUE;
}

static void
_boxes_for_traps (cairo_boxes_t *boxes,
              cairo_traps_t *traps,
              cairo_antialias_t antialias)
{
    int i;

    _cairo_boxes_init (boxes);

    boxes->num_boxes    = traps->num_traps;
    boxes->chunks.base  = (cairo_box_t *) traps->traps;
    boxes->chunks.count = traps->num_traps;
    boxes->chunks.size  = traps->num_traps;

    if (antialias != CAIRO_ANTIALIAS_NONE) {
      for (i = 0; i < traps->num_traps; i++) {
          /* Note the traps and boxes alias so we need to take the local copies first. */
          cairo_fixed_t x1 = traps->traps[i].left.p1.x;
          cairo_fixed_t x2 = traps->traps[i].right.p1.x;
          cairo_fixed_t y1 = traps->traps[i].top;
          cairo_fixed_t y2 = traps->traps[i].bottom;

          boxes->chunks.base[i].p1.x = x1;
          boxes->chunks.base[i].p1.y = y1;
          boxes->chunks.base[i].p2.x = x2;
          boxes->chunks.base[i].p2.y = y2;

          if (boxes->is_pixel_aligned) {
            boxes->is_pixel_aligned =
                _cairo_fixed_is_integer (x1) && _cairo_fixed_is_integer (y1) &&
                _cairo_fixed_is_integer (x2) && _cairo_fixed_is_integer (y2);
          }
      }
    } else {
      boxes->is_pixel_aligned = TRUE;

      for (i = 0; i < traps->num_traps; i++) {
          /* Note the traps and boxes alias so we need to take the local copies first. */
          cairo_fixed_t x1 = traps->traps[i].left.p1.x;
          cairo_fixed_t x2 = traps->traps[i].right.p1.x;
          cairo_fixed_t y1 = traps->traps[i].top;
          cairo_fixed_t y2 = traps->traps[i].bottom;

          /* round down here to match Pixman's behavior when using traps. */
          boxes->chunks.base[i].p1.x = _cairo_fixed_round_down (x1);
          boxes->chunks.base[i].p1.y = _cairo_fixed_round_down (y1);
          boxes->chunks.base[i].p2.x = _cairo_fixed_round_down (x2);
          boxes->chunks.base[i].p2.y = _cairo_fixed_round_down (y2);
      }
    }
}

static cairo_status_t
_clip_and_composite_trapezoids (cairo_image_surface_t *dst,
                        cairo_operator_t op,
                        const cairo_pattern_t *src,
                        cairo_traps_t *traps,
                        cairo_antialias_t antialias,
                        cairo_composite_rectangles_t *extents,
                        cairo_clip_t *clip)
{
    composite_traps_info_t info;
    cairo_bool_t need_clip_surface = FALSE;
    cairo_status_t status;

    if (traps->num_traps == 0 && extents->is_bounded)
      return CAIRO_STATUS_SUCCESS;

    if (clip != NULL) {
      cairo_region_t *clip_region;

      status = _cairo_clip_get_region (clip, &clip_region);
      need_clip_surface = status == CAIRO_INT_STATUS_UNSUPPORTED;
    }

    if (traps->has_intersections) {
      if (traps->is_rectangular)
          status = _cairo_bentley_ottmann_tessellate_rectangular_traps (traps, CAIRO_FILL_RULE_WINDING);
      else if (traps->is_rectilinear)
          status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (traps, CAIRO_FILL_RULE_WINDING);
      else
          status = _cairo_bentley_ottmann_tessellate_traps (traps, CAIRO_FILL_RULE_WINDING);
      if (unlikely (status))
          return status;
    }

    /* Use a fast path if the trapezoids consist of a simple region,
     * but we can only do this if we do not have a clip surface, or can
     * substitute the mask with the clip.
     */
    if (traps->maybe_region && _traps_are_pixel_aligned (traps, antialias) &&
      (! need_clip_surface ||
       (extents->is_bounded && op != CAIRO_OPERATOR_SOURCE)))
    {
      cairo_boxes_t boxes;

      _boxes_for_traps (&boxes, traps, antialias);
      return _clip_and_composite_boxes (dst, op, src,
                                &boxes, antialias,
                                extents, clip);
    }

    /* No fast path, exclude self-intersections and clip trapezoids. */
    /* Otherwise render the trapezoids to a mask and composite in the usual
     * fashion.
     */
    info.traps = traps->traps;
    info.num_traps = traps->num_traps;
    info.antialias = antialias;
    return _clip_and_composite (dst, op, src,
                        _composite_traps, &info,
                        extents, clip);
}

static cairo_clip_path_t *
_clip_get_single_path (cairo_clip_t *clip)
{
    cairo_clip_path_t *iter = clip->path;
    cairo_clip_path_t *path = NULL;

    do {
      if ((iter->flags & CAIRO_CLIP_PATH_IS_BOX) == 0) {
          if (path != NULL)
            return FALSE;

          path = iter;
      }
      iter = iter->prev;
    } while (iter != NULL);

    return path;
}

/* high level image interface */

static cairo_int_status_t
_cairo_image_surface_paint (void                *abstract_surface,
                      cairo_operator_t           op,
                      const cairo_pattern_t     *source,
                      cairo_clip_t        *clip)
{
    cairo_image_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_clip_path_t *clip_path;
    cairo_clip_t local_clip;
    cairo_bool_t have_clip = FALSE;
    cairo_box_t boxes_stack[32], *clip_boxes = boxes_stack;
    int num_boxes = ARRAY_LENGTH (boxes_stack);
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_paint (&extents,
                                           surface->width,
                                           surface->height,
                                           op, source,
                                           clip);
    if (unlikely (status))
      return status;

    if (_cairo_clip_contains_extents (clip, &extents))
      clip = NULL;

    if (clip != NULL) {
      clip = _cairo_clip_init_copy (&local_clip, clip);
      have_clip = TRUE;
    }

    status = _cairo_clip_to_boxes (&clip, &extents, &clip_boxes, &num_boxes);
    if (unlikely (status)) {
      if (have_clip)
          _cairo_clip_fini (&local_clip);

      return status;
    }

    /* If the clip cannot be reduced to a set of boxes, we will need to
     * use a clipmask. Paint is special as it is the only operation that
     * does not implicitly use a mask, so we may be able to reduce this
     * operation to a fill...
     */
    if (clip != NULL &&
      extents.is_bounded &&
      (clip_path = _clip_get_single_path (clip)) != NULL)
    {
      status = _cairo_image_surface_fill (surface, op, source,
                                  &clip_path->path,
                                  clip_path->fill_rule,
                                  clip_path->tolerance,
                                  clip_path->antialias,
                                  NULL);
    }
    else
    {
      cairo_boxes_t boxes;

      _cairo_boxes_init_for_array (&boxes, clip_boxes, num_boxes);
      status = _clip_and_composite_boxes (surface, op, source,
                                  &boxes, CAIRO_ANTIALIAS_DEFAULT,
                                  &extents, clip);
    }

    if (clip_boxes != boxes_stack)
      free (clip_boxes);

    if (have_clip)
      _cairo_clip_fini (&local_clip);

    return status;
}

static cairo_status_t
_composite_mask (void                     *closure,
             pixman_image_t               *dst,
             pixman_format_code_t          dst_format,
             cairo_operator_t        op,
             const cairo_pattern_t        *src_pattern,
             int                     dst_x,
             int                     dst_y,
             const cairo_rectangle_int_t  *extents,
             cairo_region_t               *clip_region)
{
    const cairo_pattern_t *mask_pattern = closure;
    pixman_image_t *src, *mask = NULL;
    int src_x = 0, src_y = 0;
    int mask_x = 0, mask_y = 0;

    if (src_pattern != NULL) {
      src = _pixman_image_for_pattern (src_pattern, FALSE, extents, &src_x, &src_y);
      if (unlikely (src == NULL))
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);

      mask = _pixman_image_for_pattern (mask_pattern, TRUE, extents, &mask_x, &mask_y);
      if (unlikely (mask == NULL)) {
          pixman_image_unref (src);
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      }

      if (mask_pattern->has_component_alpha)
          pixman_image_set_component_alpha (mask, TRUE);
    } else {
      src = _pixman_image_for_pattern (mask_pattern, FALSE, extents, &src_x, &src_y);
      if (unlikely (src == NULL))
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    pixman_image_composite32 (_pixman_operator (op), src, mask, dst,
                              extents->x + src_x,  extents->y + src_y,
                              extents->x + mask_x, extents->y + mask_y,
                              extents->x - dst_x,  extents->y - dst_y,
                              extents->width,      extents->height);

    if (mask != NULL)
      pixman_image_unref (mask);
    pixman_image_unref (src);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_image_surface_mask (void                       *abstract_surface,
                     cairo_operator_t            op,
                     const cairo_pattern_t      *source,
                     const cairo_pattern_t      *mask,
                     cairo_clip_t               *clip)
{
    cairo_image_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_clip_t local_clip;
    cairo_bool_t have_clip = FALSE;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_mask (&extents,
                                          surface->width, surface->height,
                                          op, source, mask, clip);
    if (unlikely (status))
      return status;

    if (_cairo_clip_contains_extents (clip, &extents))
      clip = NULL;

    if (clip != NULL && extents.is_bounded) {
      clip = _cairo_clip_init_copy (&local_clip, clip);
      status = _cairo_clip_rectangle (clip, &extents.bounded);
      if (unlikely (status)) {
          _cairo_clip_fini (&local_clip);
          return status;
      }

      have_clip = TRUE;
    }

    status = _clip_and_composite (surface, op, source,
                          _composite_mask, (void *) mask,
                          &extents, clip);

    if (have_clip)
      _cairo_clip_fini (&local_clip);

    return status;
}

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

//#define USE_BOTOR_SCAN_CONVERTER
static cairo_status_t
_composite_spans (void                          *closure,
              pixman_image_t        *dst,
              pixman_format_code_t         dst_format,
              cairo_operator_t               op,
              const cairo_pattern_t         *pattern,
              int                            dst_x,
              int                            dst_y,
              const cairo_rectangle_int_t   *extents,
              cairo_region_t        *clip_region)
{
    uint8_t mask_buf[CAIRO_STACK_BUFFER_SIZE];
    composite_spans_info_t *info = closure;
    cairo_image_surface_span_renderer_t renderer;
#if USE_BOTOR_SCAN_CONVERTER
    cairo_box_t box;
    cairo_botor_scan_converter_t converter;
#else
    cairo_scan_converter_t *converter;
#endif
    pixman_image_t *mask;
    cairo_status_t status;

#if USE_BOTOR_SCAN_CONVERTER
    box.p1.x = _cairo_fixed_from_int (extents->x);
    box.p1.y = _cairo_fixed_from_int (extents->y);
    box.p2.x = _cairo_fixed_from_int (extents->x + extents->width);
    box.p2.y = _cairo_fixed_from_int (extents->y + extents->height);
    _cairo_botor_scan_converter_init (&converter, &box, info->fill_rule);
    status = converter.base.add_polygon (&converter.base, info->polygon);
#else
    converter = _cairo_tor_scan_converter_create (extents->x, extents->y,
                                      extents->x + extents->width,
                                      extents->y + extents->height,
                                      info->fill_rule);
    status = converter->add_polygon (converter, info->polygon);
#endif
    if (unlikely (status))
      goto CLEANUP_CONVERTER;

    /* TODO: support rendering to A1 surfaces (or: go add span
     * compositing to pixman.) */

    if (pattern == NULL && dst_format == PIXMAN_a8) {
      mask = dst;
      dst = NULL;
    } else {
      int stride = CAIRO_STRIDE_FOR_WIDTH_BPP (extents->width, 8);
      uint8_t *data = mask_buf;

      if (extents->height * stride <= (int) sizeof (mask_buf))
          memset (data, 0, extents->height * stride);
      else
          data = NULL, stride = 0;

      mask = pixman_image_create_bits (PIXMAN_a8,
                               extents->width,
                               extents->height,
                               (uint32_t *) data,
                               stride);
      if (unlikely (mask == NULL)) {
          status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
          goto CLEANUP_CONVERTER;
      }
    }

    renderer.base.render_rows = _cairo_image_surface_span;
    renderer.mask_stride = pixman_image_get_stride (mask);
    renderer.mask_data = (uint8_t *) pixman_image_get_data (mask);
    if (dst != NULL)
      renderer.mask_data -= extents->y * renderer.mask_stride + extents->x;
    else
      renderer.mask_data -= dst_y * renderer.mask_stride + dst_x;

#if USE_BOTOR_SCAN_CONVERTER
    status = converter.base.generate (&converter.base, &renderer.base);
#else
    status = converter->generate (converter, &renderer.base);
#endif
    if (unlikely (status))
      goto CLEANUP_RENDERER;

    if (dst != NULL) {
      pixman_image_t *src;
      int src_x, src_y;

      src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
      if (unlikely (src == NULL)) {
          status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
          goto CLEANUP_RENDERER;
      }

      pixman_image_composite32 (_pixman_operator (op), src, mask, dst,
                                  extents->x + src_x, extents->y + src_y,
                                  0, 0, /* mask.x, mask.y */
                                  extents->x - dst_x, extents->y - dst_y,
                                  extents->width, extents->height);
      pixman_image_unref (src);
    }

 CLEANUP_RENDERER:
    if (dst != NULL)
      pixman_image_unref (mask);
 CLEANUP_CONVERTER:
#if USE_BOTOR_SCAN_CONVERTER
    converter.base.destroy (&converter.base);
#else
    converter->destroy (converter);
#endif
    return status;
}

static cairo_status_t
_clip_and_composite_polygon (cairo_image_surface_t *dst,
                       cairo_operator_t op,
                       const cairo_pattern_t *src,
                       cairo_polygon_t *polygon,
                       cairo_fill_rule_t fill_rule,
                       cairo_antialias_t antialias,
                       cairo_composite_rectangles_t *extents,
                       cairo_clip_t *clip)
{
    cairo_status_t status;

    if (polygon->num_edges == 0) {
      cairo_traps_t traps;

      if (extents->is_bounded)
          return CAIRO_STATUS_SUCCESS;

      _cairo_traps_init (&traps);
      status = _clip_and_composite_trapezoids (dst, op, src,
                                     &traps, antialias,
                                     extents, clip);
      _cairo_traps_fini (&traps);

      return status;
    }

    _cairo_box_round_to_rectangle (&polygon->extents, &extents->mask);
    if (! _cairo_rectangle_intersect (&extents->bounded, &extents->mask))
      return CAIRO_STATUS_SUCCESS;

    if (antialias != CAIRO_ANTIALIAS_NONE) {
      composite_spans_info_t info;

      info.polygon = polygon;
      info.fill_rule = fill_rule;
      info.antialias = antialias;

      status = _clip_and_composite (dst, op, src,
                              _composite_spans, &info,
                              extents, clip);
    } else {
      cairo_traps_t traps;

      _cairo_traps_init (&traps);

      /* Fall back to trapezoid fills. */
      status = _cairo_bentley_ottmann_tessellate_polygon (&traps,
                                              polygon,
                                              fill_rule);
      if (likely (status == CAIRO_STATUS_SUCCESS)) {
          status = _clip_and_composite_trapezoids (dst, op, src,
                                         &traps, antialias,
                                         extents, clip);
      }

      _cairo_traps_fini (&traps);
    }

    return status;
}

static cairo_int_status_t
_cairo_image_surface_stroke (void               *abstract_surface,
                       cairo_operator_t          op,
                       const cairo_pattern_t    *source,
                       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,
                       cairo_clip_t       *clip)
{
    cairo_image_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_box_t boxes_stack[32], *clip_boxes = boxes_stack;
    int num_boxes = ARRAY_LENGTH (boxes_stack);
    cairo_clip_t local_clip;
    cairo_bool_t have_clip = FALSE;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_stroke (&extents,
                                            surface->width,
                                            surface->height,
                                            op, source,
                                            path, style, ctm,
                                            clip);
    if (unlikely (status))
      return status;

    if (_cairo_clip_contains_extents (clip, &extents))
      clip = NULL;

    if (clip != NULL) {
      clip = _cairo_clip_init_copy (&local_clip, clip);
      have_clip = TRUE;
    }

    status = _cairo_clip_to_boxes (&clip, &extents, &clip_boxes, &num_boxes);
    if (unlikely (status)) {
      if (have_clip)
          _cairo_clip_fini (&local_clip);

      return status;
    }

    status = CAIRO_INT_STATUS_UNSUPPORTED;
    if (path->is_rectilinear) {
      cairo_boxes_t boxes;

      _cairo_boxes_init (&boxes);
      _cairo_boxes_limit (&boxes, clip_boxes, num_boxes);

      status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,
                                                style,
                                                ctm,
                                                &boxes);
      if (likely (status == CAIRO_STATUS_SUCCESS)) {
          status = _clip_and_composite_boxes (surface, op, source,
                                    &boxes, antialias,
                                    &extents, clip);
      }

      _cairo_boxes_fini (&boxes);
    }

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
      cairo_polygon_t polygon;

      _cairo_polygon_init (&polygon);
      _cairo_polygon_limit (&polygon, clip_boxes, num_boxes);

      status = _cairo_path_fixed_stroke_to_polygon (path,
                                          style,
                                          ctm, ctm_inverse,
                                          tolerance,
                                          &polygon);
      if (likely (status == CAIRO_STATUS_SUCCESS)) {
          status = _clip_and_composite_polygon (surface, op, source, &polygon,
                                      CAIRO_FILL_RULE_WINDING, antialias,
                                      &extents, clip);
      }

      _cairo_polygon_fini (&polygon);
    }

    if (clip_boxes != boxes_stack)
      free (clip_boxes);

    if (have_clip)
      _cairo_clip_fini (&local_clip);

    return status;
}

static cairo_int_status_t
_cairo_image_surface_fill (void                       *abstract_surface,
                     cairo_operator_t            op,
                     const cairo_pattern_t      *source,
                     cairo_path_fixed_t         *path,
                     cairo_fill_rule_t           fill_rule,
                     double                tolerance,
                     cairo_antialias_t           antialias,
                     cairo_clip_t               *clip)
{
    cairo_image_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_box_t boxes_stack[32], *clip_boxes = boxes_stack;
    cairo_clip_t local_clip;
    cairo_bool_t have_clip = FALSE;
    int num_boxes = ARRAY_LENGTH (boxes_stack);
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_fill (&extents,
                                          surface->width,
                                          surface->height,
                                          op, source, path,
                                          clip);
    if (unlikely (status))
      return status;

    if (_cairo_clip_contains_extents (clip, &extents))
      clip = NULL;

    if (extents.is_bounded && clip != NULL) {
      cairo_clip_path_t *clip_path;

      if (((clip_path = _clip_get_single_path (clip)) != NULL) &&
          _cairo_path_fixed_equal (&clip_path->path, path))
      {
          clip = NULL;
      }
    }

    if (clip != NULL) {
      clip = _cairo_clip_init_copy (&local_clip, clip);
      have_clip = TRUE;
    }

    status = _cairo_clip_to_boxes (&clip, &extents, &clip_boxes, &num_boxes);
    if (unlikely (status)) {
      if (have_clip)
          _cairo_clip_fini (&local_clip);

      return status;
    }

    if (_cairo_path_fixed_is_rectilinear_fill (path)) {
      cairo_boxes_t boxes;

      _cairo_boxes_init (&boxes);
      _cairo_boxes_limit (&boxes, clip_boxes, num_boxes);

      status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,
                                                fill_rule,
                                                &boxes);
      if (likely (status == CAIRO_STATUS_SUCCESS)) {
          status = _clip_and_composite_boxes (surface, op, source,
                                    &boxes, antialias,
                                    &extents, clip);
      }

      _cairo_boxes_fini (&boxes);
    } else {
      cairo_polygon_t polygon;

      assert (! path->is_empty_fill);

      _cairo_polygon_init (&polygon);
      _cairo_polygon_limit (&polygon, clip_boxes, num_boxes);

      status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon);
      if (likely (status == CAIRO_STATUS_SUCCESS)) {
          status = _clip_and_composite_polygon (surface, op, source, &polygon,
                                      fill_rule, antialias,
                                      &extents, clip);
      }

      _cairo_polygon_fini (&polygon);
    }

    if (clip_boxes != boxes_stack)
      free (clip_boxes);

    if (have_clip)
      _cairo_clip_fini (&local_clip);

    return status;
}

03744 typedef struct {
    cairo_scaled_font_t *font;
    cairo_glyph_t *glyphs;
    int num_glyphs;
} composite_glyphs_info_t;

static cairo_status_t
_composite_glyphs_via_mask (void                *closure,
                      pixman_image_t            *dst,
                      pixman_format_code_t       dst_format,
                      cairo_operator_t           op,
                      const cairo_pattern_t     *pattern,
                      int                        dst_x,
                      int                        dst_y,
                      const cairo_rectangle_int_t     *extents,
                      cairo_region_t            *clip_region)
{
    composite_glyphs_info_t *info = closure;
    cairo_scaled_font_t *font = info->font;
    cairo_glyph_t *glyphs = info->glyphs;
    int num_glyphs = info->num_glyphs;
    pixman_image_t *mask = NULL;
    pixman_image_t *src;
    pixman_image_t *white;
    pixman_format_code_t mask_format = 0; /* silence gcc */
    cairo_status_t status;
    int src_x, src_y;
    int i;

    src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
    if (unlikely (src == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    white = _pixman_white_image ();
    if (unlikely (white == NULL)) {
      pixman_image_unref (src);
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    _cairo_scaled_font_freeze_cache (font);

    for (i = 0; i < num_glyphs; i++) {
      int x, y;
      cairo_image_surface_t *glyph_surface;
      cairo_scaled_glyph_t *scaled_glyph;

      status = _cairo_scaled_glyph_lookup (font, glyphs[i].index,
                                   CAIRO_SCALED_GLYPH_INFO_SURFACE,
                                   &scaled_glyph);

      if (unlikely (status))
          goto CLEANUP;

      glyph_surface = scaled_glyph->surface;

      if (glyph_surface->width == 0 || glyph_surface->height == 0)
          continue;

      /* To start, create the mask using the format from the first
       * glyph. Later we'll deal with different formats. */
      if (mask == NULL) {
          mask_format = glyph_surface->pixman_format;
          mask = pixman_image_create_bits (mask_format,
                                   extents->width, extents->height,
                                   NULL, 0);
          if (unlikely (mask == NULL)) {
            status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
            goto CLEANUP;
          }

          if (PIXMAN_FORMAT_RGB (mask_format))
            pixman_image_set_component_alpha (mask, TRUE);
      }

      /* If we have glyphs of different formats, we "upgrade" the mask
       * to the wider of the formats. */
      if (glyph_surface->pixman_format != mask_format &&
          PIXMAN_FORMAT_BPP (mask_format) <
          PIXMAN_FORMAT_BPP (glyph_surface->pixman_format))
      {
          pixman_image_t *new_mask;

          mask_format = glyph_surface->pixman_format;
          new_mask = pixman_image_create_bits (mask_format,
                                     extents->width, extents->height,
                                     NULL, 0);
          if (unlikely (new_mask == NULL)) {
            status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
            goto CLEANUP;
          }

          pixman_image_composite32 (PIXMAN_OP_SRC,
                                      white, mask, new_mask,
                                      0, 0, 0, 0, 0, 0,
                                      extents->width, extents->height);

          pixman_image_unref (mask);
          mask = new_mask;
          if (PIXMAN_FORMAT_RGB (mask_format))
            pixman_image_set_component_alpha (mask, TRUE);
      }

      /* round glyph locations to the nearest pixel */
      /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */
      x = _cairo_lround (glyphs[i].x -
                     glyph_surface->base.device_transform.x0);
      y = _cairo_lround (glyphs[i].y -
                     glyph_surface->base.device_transform.y0);
      if (glyph_surface->pixman_format == mask_format) {
          pixman_image_composite32 (PIXMAN_OP_ADD,
                                      glyph_surface->pixman_image, NULL, mask,
                                      0, 0, 0, 0,
                                      x - extents->x, y - extents->y,
                                      glyph_surface->width,
                                      glyph_surface->height);
      } else {
          pixman_image_composite32 (PIXMAN_OP_ADD,
                                      white, glyph_surface->pixman_image, mask,
                                      0, 0, 0, 0,
                                      x - extents->x, y - extents->y,
                                      glyph_surface->width,
                                      glyph_surface->height);
      }
    }

    pixman_image_composite32 (_pixman_operator (op),
                              src, mask, dst,
                              extents->x + src_x, extents->y + src_y,
                              0, 0,
                              extents->x - dst_x, extents->y - dst_y,
                              extents->width,     extents->height);

CLEANUP:
    _cairo_scaled_font_thaw_cache (font);
    if (mask != NULL)
      pixman_image_unref (mask);
    pixman_image_unref (src);
    pixman_image_unref (white);

    return status;
}

static cairo_status_t
_composite_glyphs (void                   *closure,
               pixman_image_t       *dst,
               pixman_format_code_t        dst_format,
               cairo_operator_t            op,
               const cairo_pattern_t      *pattern,
               int                         dst_x,
               int                         dst_y,
               const cairo_rectangle_int_t      *extents,
               cairo_region_t       *clip_region)
{
    composite_glyphs_info_t *info = closure;
    cairo_scaled_glyph_t *glyph_cache[64];
    pixman_op_t pixman_op = _pixman_operator (op);
    pixman_image_t *src = NULL;
    int src_x = 0, src_y = 0;
    cairo_status_t status;
    int i;

    if (pattern != NULL) {
      src = _pixman_image_for_pattern (pattern, FALSE, extents, &src_x, &src_y);
      src_x -= dst_x;
      src_y -= dst_y;
    } else {
      src = _pixman_white_image ();
    }
    if (unlikely (src == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    memset (glyph_cache, 0, sizeof (glyph_cache));
    status = CAIRO_STATUS_SUCCESS;

    _cairo_scaled_font_freeze_cache (info->font);
    for (i = 0; i < info->num_glyphs; i++) {
      int x, y;
      cairo_image_surface_t *glyph_surface;
      cairo_scaled_glyph_t *scaled_glyph;
      unsigned long glyph_index = info->glyphs[i].index;
      int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache);

      scaled_glyph = glyph_cache[cache_index];
      if (scaled_glyph == NULL ||
          _cairo_scaled_glyph_index (scaled_glyph) != glyph_index)
      {
          status = _cairo_scaled_glyph_lookup (info->font, glyph_index,
                                     CAIRO_SCALED_GLYPH_INFO_SURFACE,
                                     &scaled_glyph);

          if (unlikely (status))
            break;

          glyph_cache[cache_index] = scaled_glyph;
      }

      glyph_surface = scaled_glyph->surface;
      if (glyph_surface->width && glyph_surface->height) {
          int x1, y1, x2, y2;

          /* round glyph locations to the nearest pixel */
          /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */
          x = _cairo_lround (info->glyphs[i].x -
                         glyph_surface->base.device_transform.x0);
          y = _cairo_lround (info->glyphs[i].y -
                         glyph_surface->base.device_transform.y0);

          x1 = x;
          if (x1 < extents->x)
            x1 = extents->x;
          x2 = x + glyph_surface->width;
          if (x2 > extents->x + extents->width)
            x2 = extents->x + extents->width;

          y1 = y;
          if (y1 < extents->y)
            y1 = extents->y;
          y2 = y + glyph_surface->height;
          if (y2 > extents->y + extents->height)
            y2 = extents->y + extents->height;

          pixman_image_composite32 (pixman_op,
                                      src, glyph_surface->pixman_image, dst,
                                      x1 + src_x,  y1 + src_y,
                                      x1 - x, y1 - y,
                                      x1 - dst_x, y1 - dst_y,
                                      x2 - x1, y2 - y1);
      }
    }
    _cairo_scaled_font_thaw_cache (info->font);

    pixman_image_unref (src);

    return status;
}

static cairo_int_status_t
_cairo_image_surface_glyphs (void               *abstract_surface,
                       cairo_operator_t          op,
                       const cairo_pattern_t    *source,
                       cairo_glyph_t            *glyphs,
                       int                 num_glyphs,
                       cairo_scaled_font_t      *scaled_font,
                       cairo_clip_t       *clip,
                       int *num_remaining)
{
    cairo_image_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    composite_glyphs_info_t glyph_info;
    cairo_clip_t local_clip;
    cairo_bool_t have_clip = FALSE;
    cairo_bool_t overlap;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_glyphs (&extents,
                                            surface->width,
                                            surface->height,
                                            op, source,
                                            scaled_font,
                                            glyphs, num_glyphs,
                                            clip,
                                            &overlap);
    if (unlikely (status))
      return status;

    if (_cairo_clip_contains_rectangle (clip, &extents.mask))
      clip = NULL;

    if (clip != NULL && extents.is_bounded) {
      clip = _cairo_clip_init_copy (&local_clip, clip);
      status = _cairo_clip_rectangle (clip, &extents.bounded);
      if (unlikely (status))
          return status;

      have_clip = TRUE;
    }

    glyph_info.font = scaled_font;
    glyph_info.glyphs = glyphs;
    glyph_info.num_glyphs = num_glyphs;

    status = _clip_and_composite (surface, op, source,
                          overlap || extents.is_bounded == 0 ? _composite_glyphs_via_mask : _composite_glyphs,
                          &glyph_info,
                          &extents, clip);

    if (have_clip)
      _cairo_clip_fini (&local_clip);

    *num_remaining = 0;
    return status;
}

static cairo_bool_t
_cairo_image_surface_get_extents (void                  *abstract_surface,
                          cairo_rectangle_int_t   *rectangle)
{
    cairo_image_surface_t *surface = abstract_surface;

    rectangle->x = 0;
    rectangle->y = 0;
    rectangle->width  = surface->width;
    rectangle->height = surface->height;

    return TRUE;
}

static void
_cairo_image_surface_get_font_options (void                  *abstract_surface,
                               cairo_font_options_t  *options)
{
    _cairo_font_options_init_default (options);

    cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_ON);
}

/* legacy interface kept for compatibility until surface-fallback is removed */
static cairo_status_t
_cairo_image_surface_acquire_dest_image (void                    *abstract_surface,
                               cairo_rectangle_int_t   *interest_rect,
                               cairo_image_surface_t  **image_out,
                               cairo_rectangle_int_t   *image_rect_out,
                               void                   **image_extra)
{
    cairo_image_surface_t *surface = abstract_surface;

    image_rect_out->x = 0;
    image_rect_out->y = 0;
    image_rect_out->width = surface->width;
    image_rect_out->height = surface->height;

    *image_out = surface;
    *image_extra = NULL;

    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_image_surface_release_dest_image (void                    *abstract_surface,
                                        cairo_rectangle_int_t   *interest_rect,
                                        cairo_image_surface_t   *image,
                                        cairo_rectangle_int_t   *image_rect,
                                        void                    *image_extra)
{
}

static cairo_status_t
_cairo_image_surface_clone_similar (void               *abstract_surface,
                            cairo_surface_t     *src,
                            int                  src_x,
                            int                  src_y,
                            int                  width,
                            int                  height,
                            int                 *clone_offset_x,
                            int                 *clone_offset_y,
                            cairo_surface_t    **clone_out)
{
    cairo_image_surface_t *surface = abstract_surface;

    if (src->backend == surface->base.backend) {
      *clone_offset_x = *clone_offset_y = 0;
      *clone_out = cairo_surface_reference (src);

      return CAIRO_STATUS_SUCCESS;
    }

    return CAIRO_INT_STATUS_UNSUPPORTED;
}

static cairo_int_status_t
_cairo_image_surface_composite (cairo_operator_t       op,
                        const cairo_pattern_t   *src_pattern,
                        const cairo_pattern_t   *mask_pattern,
                        void              *abstract_dst,
                        int                src_x,
                        int                src_y,
                        int                mask_x,
                        int                mask_y,
                        int                dst_x,
                        int                dst_y,
                        unsigned int             width,
                        unsigned int             height,
                        cairo_region_t          *clip_region)
{
    cairo_image_surface_t *dst = abstract_dst;
    cairo_composite_rectangles_t extents;
    pixman_image_t *src;
    int src_offset_x, src_offset_y;
    cairo_status_t status;

    if (clip_region != NULL) {
      status = _cairo_image_surface_set_clip_region (dst, clip_region);
      if (unlikely (status))
          return status;
    }

    extents.source.x = src_x;
    extents.source.y = src_y;
    extents.source.width  = width;
    extents.source.height = height;

    extents.mask.x = mask_x;
    extents.mask.y = mask_y;
    extents.mask.width  = width;
    extents.mask.height = height;

    extents.bounded.x = dst_x;
    extents.bounded.y = dst_y;
    extents.bounded.width  = width;
    extents.bounded.height = height;

    extents.unbounded.x = 0;
    extents.unbounded.y = 0;
    extents.unbounded.width  = dst->width;
    extents.unbounded.height = dst->height;

    if (clip_region != NULL) {
      cairo_rectangle_int_t rect;

      cairo_region_get_extents (clip_region, &rect);
      if (! _cairo_rectangle_intersect (&extents.unbounded, &rect))
          return CAIRO_STATUS_SUCCESS;
    }

    extents.is_bounded = _cairo_operator_bounded_by_either (op);

    src = _pixman_image_for_pattern (src_pattern, FALSE, &extents.source, &src_offset_x, &src_offset_y);
    if (unlikely (src == NULL))
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    status = CAIRO_STATUS_SUCCESS;
    if (mask_pattern != NULL) {
      pixman_image_t *mask;
      int mask_offset_x, mask_offset_y;

      mask = _pixman_image_for_pattern (mask_pattern, TRUE, &extents.mask, &mask_offset_x, &mask_offset_y);
      if (unlikely (mask == NULL)) {
          pixman_image_unref (src);
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
      }

      pixman_image_composite32 (_pixman_operator (op),
                                  src, mask, dst->pixman_image,
                                  src_x + src_offset_x,
                                  src_y + src_offset_y,
                                  mask_x + mask_offset_x,
                                  mask_y + mask_offset_y,
                          dst_x, dst_y, width, height);

      pixman_image_unref (mask);
    } else {
      pixman_image_composite32 (_pixman_operator (op),
                                  src, NULL, dst->pixman_image,
                                  src_x + src_offset_x,
                                  src_y + src_offset_y,
                                  0, 0,
                                  dst_x, dst_y, width, height);
    }

    pixman_image_unref (src);

    if (! extents.is_bounded)
      status = _cairo_image_surface_fixup_unbounded (dst, &extents, NULL);

    if (clip_region != NULL)
      _cairo_image_surface_unset_clip_region (dst);

    return status;
}

static cairo_int_status_t
_cairo_image_surface_fill_rectangles (void                  *abstract_surface,
                              cairo_operator_t         op,
                              const cairo_color_t     *color,
                              cairo_rectangle_int_t   *rects,
                              int                num_rects)
{
    cairo_image_surface_t *surface = abstract_surface;

    pixman_color_t pixman_color;
    pixman_box32_t stack_boxes[CAIRO_STACK_ARRAY_LENGTH (pixman_rectangle16_t)];
    pixman_box32_t *pixman_boxes = stack_boxes;
    int i;

    cairo_int_status_t status;

    if (CAIRO_INJECT_FAULT ())
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    pixman_color.red   = color->red_short;
    pixman_color.green = color->green_short;
    pixman_color.blue  = color->blue_short;
    pixman_color.alpha = color->alpha_short;

    if (num_rects > ARRAY_LENGTH (stack_boxes)) {
      pixman_boxes = _cairo_malloc_ab (num_rects, sizeof (pixman_rectangle16_t));
      if (unlikely (pixman_boxes == NULL))
          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    for (i = 0; i < num_rects; i++) {
      pixman_boxes[i].x1 = rects[i].x;
      pixman_boxes[i].y1 = rects[i].y;
      pixman_boxes[i].x2 = rects[i].x + rects[i].width;
      pixman_boxes[i].y2 = rects[i].y + rects[i].height;
    }

    status = CAIRO_STATUS_SUCCESS;
    if (! pixman_image_fill_boxes (_pixman_operator (op),
                                   surface->pixman_image,
                                   &pixman_color,
                                   num_rects,
                                   pixman_boxes))
    {
      status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    if (pixman_boxes != stack_boxes)
      free (pixman_boxes);

    return status;
}

static cairo_int_status_t
_cairo_image_surface_composite_trapezoids (cairo_operator_t op,
                                 const cairo_pattern_t *pattern,
                                 void                 *abstract_dst,
                                 cairo_antialias_t    antialias,
                                 int                  src_x,
                                 int                  src_y,
                                 int                  dst_x,
                                 int                  dst_y,
                                 unsigned int         width,
                                 unsigned int         height,
                                 cairo_trapezoid_t    *traps,
                                 int                  num_traps,
                                 cairo_region_t *clip_region)
{
    cairo_image_surface_t     *dst = abstract_dst;
    cairo_composite_rectangles_t extents;
    cairo_pattern_union_t        source_pattern;
    composite_traps_info_t     info;
    cairo_status_t             status;

    if (height == 0 || width == 0)
      return CAIRO_STATUS_SUCCESS;

    if (CAIRO_INJECT_FAULT ())
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    extents.source.x = src_x;
    extents.source.y = src_y;
    extents.source.width  = width;
    extents.source.height = height;

    extents.mask.x = dst_x;
    extents.mask.y = dst_y;
    extents.mask.width  = width;
    extents.mask.height = height;

    extents.bounded.x = dst_x;
    extents.bounded.y = dst_y;
    extents.bounded.width  = width;
    extents.bounded.height = height;

    extents.unbounded.x = 0;
    extents.unbounded.y = 0;
    extents.unbounded.width  = dst->width;
    extents.unbounded.height = dst->height;

    if (clip_region != NULL) {
      cairo_rectangle_int_t rect;

      cairo_region_get_extents (clip_region, &rect);
      if (! _cairo_rectangle_intersect (&extents.unbounded, &rect))
          return CAIRO_STATUS_SUCCESS;
    }

    extents.is_bounded = _cairo_operator_bounded_by_either (op);

    if (clip_region != NULL) {
      status = _cairo_image_surface_set_clip_region (dst, clip_region);
      if (unlikely (status))
          return status;
    }

    _cairo_pattern_init_static_copy (&source_pattern.base, pattern);
    cairo_matrix_translate (&source_pattern.base.matrix,
                            src_x - extents.bounded.x,
                            src_y - extents.bounded.y);

    info.traps = traps;
    info.num_traps = num_traps;
    info.antialias = antialias;
    status = _composite_traps (&info,
                         dst->pixman_image,
                         dst->pixman_format,
                         op,
                         &source_pattern.base,
                         0, 0,
                         &extents.bounded,
                         clip_region);

    if (status == CAIRO_STATUS_SUCCESS && ! extents.is_bounded)
      status = _cairo_image_surface_fixup_unbounded (dst, &extents, NULL);

    if (clip_region != NULL)
      _cairo_image_surface_unset_clip_region (dst);

    return status;
}

04356 typedef struct _legacy_image_surface_span_renderer {
    cairo_span_renderer_t base;

    cairo_operator_t op;
    const cairo_pattern_t *pattern;
    cairo_antialias_t antialias;
    cairo_region_t *clip_region;

    pixman_image_t *mask;
    uint8_t *mask_data;
    uint32_t mask_stride;

    cairo_image_surface_t *dst;
    cairo_composite_rectangles_t composite_rectangles;
} legacy_image_surface_span_renderer_t;

void
_cairo_image_surface_span_render_row (
    int                                  y,
    const cairo_half_open_span_t        *spans,
    unsigned                             num_spans,
    uint8_t                   *data,
    uint32_t                         stride)
{
    uint8_t *row;
    unsigned i;

    if (num_spans == 0)
      return;

    row = data + y * stride;
    for (i = 0; i < num_spans - 1; i++) {
      if (! spans[i].coverage)
          continue;

      /* We implement setting the most common single pixel wide
       * span case to avoid the overhead of a memset call.
       * Open coding setting longer spans didn't show a
       * noticeable improvement over memset.
       */
      if (spans[i+1].x == spans[i].x + 1) {
          row[spans[i].x] = spans[i].coverage;
      } else {
          memset (row + spans[i].x,
                spans[i].coverage,
                spans[i+1].x - spans[i].x);
      }
    }
}

static cairo_status_t
_cairo_image_surface_span_renderer_render_rows (
    void                      *abstract_renderer,
    int                              y,
    int                              height,
    const cairo_half_open_span_t    *spans,
    unsigned                         num_spans)
{
    legacy_image_surface_span_renderer_t *renderer = abstract_renderer;
    while (height--)
      _cairo_image_surface_span_render_row (y++, spans, num_spans, renderer->mask_data, renderer->mask_stride);
    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_image_surface_span_renderer_destroy (void *abstract_renderer)
{
    legacy_image_surface_span_renderer_t *renderer = abstract_renderer;
    if (renderer == NULL)
      return;

    pixman_image_unref (renderer->mask);

    free (renderer);
}

static cairo_status_t
_cairo_image_surface_span_renderer_finish (void *abstract_renderer)
{
    legacy_image_surface_span_renderer_t *renderer = abstract_renderer;
    cairo_composite_rectangles_t *rects = &renderer->composite_rectangles;
    cairo_image_surface_t *dst = renderer->dst;
    pixman_image_t *src;
    int src_x, src_y;
    cairo_status_t status;

    if (renderer->clip_region != NULL) {
      status = _cairo_image_surface_set_clip_region (dst, renderer->clip_region);
      if (unlikely (status))
          return status;
    }

    src = _pixman_image_for_pattern (renderer->pattern, FALSE, &rects->bounded, &src_x, &src_y);
    if (src == NULL)
      return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    status = CAIRO_STATUS_SUCCESS;
    pixman_image_composite32 (_pixman_operator (renderer->op),
                              src,
                              renderer->mask,
                              dst->pixman_image,
                              rects->bounded.x + src_x,
                              rects->bounded.y + src_y,
                              0, 0,
                              rects->bounded.x, rects->bounded.y,
                              rects->bounded.width, rects->bounded.height);

    if (! rects->is_bounded)
      status = _cairo_image_surface_fixup_unbounded (dst, rects, NULL);

    if (renderer->clip_region != NULL)
       _cairo_image_surface_unset_clip_region (dst);

    return status;
}

static cairo_bool_t
_cairo_image_surface_check_span_renderer (cairo_operator_t    op,
                                const cairo_pattern_t  *pattern,
                                void                   *abstract_dst,
                                cairo_antialias_t       antialias)
{
    return TRUE;
    (void) op;
    (void) pattern;
    (void) abstract_dst;
    (void) antialias;
}

static cairo_span_renderer_t *
_cairo_image_surface_create_span_renderer (cairo_operator_t  op,
                                 const cairo_pattern_t  *pattern,
                                 void                 *abstract_dst,
                                 cairo_antialias_t     antialias,
                                 const cairo_composite_rectangles_t *rects,
                                 cairo_region_t *clip_region)
{
    cairo_image_surface_t *dst = abstract_dst;
    legacy_image_surface_span_renderer_t *renderer;

    renderer = calloc(1, sizeof(*renderer));
    if (unlikely (renderer == NULL))
      return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY);

    renderer->base.destroy = _cairo_image_surface_span_renderer_destroy;
    renderer->base.finish = _cairo_image_surface_span_renderer_finish;
    renderer->base.render_rows = _cairo_image_surface_span_renderer_render_rows;
    renderer->op = op;
    renderer->pattern = pattern;
    renderer->antialias = antialias;
    renderer->dst = dst;
    renderer->clip_region = clip_region;

    renderer->composite_rectangles = *rects;

    /* TODO: support rendering to A1 surfaces (or: go add span
     * compositing to pixman.) */
    renderer->mask = pixman_image_create_bits (PIXMAN_a8,
                                     rects->bounded.width,
                                     rects->bounded.height,
                                     NULL, 0);
    if (renderer->mask == NULL) {
      free (renderer);
      return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY);
    }

    renderer->mask_stride = pixman_image_get_stride (renderer->mask);
    renderer->mask_data = (uint8_t *) pixman_image_get_data (renderer->mask) - rects->bounded.x - rects->bounded.y * renderer->mask_stride;

    return &renderer->base;
}

/**
 * _cairo_surface_is_image:
 * @surface: a #cairo_surface_t
 *
 * Checks if a surface is an #cairo_image_surface_t
 *
 * Return value: %TRUE if the surface is an image surface
 **/
cairo_bool_t
_cairo_surface_is_image (const cairo_surface_t *surface)
{
    return surface->backend == &_cairo_image_surface_backend;
}

const cairo_surface_backend_t _cairo_image_surface_backend = {
    CAIRO_SURFACE_TYPE_IMAGE,
    _cairo_image_surface_create_similar,
    _cairo_image_surface_finish,
    _cairo_image_surface_acquire_source_image,
    _cairo_image_surface_release_source_image,
    _cairo_image_surface_acquire_dest_image,
    _cairo_image_surface_release_dest_image,
    _cairo_image_surface_clone_similar,
    _cairo_image_surface_composite,
    _cairo_image_surface_fill_rectangles,
    _cairo_image_surface_composite_trapezoids,
    _cairo_image_surface_create_span_renderer,
    _cairo_image_surface_check_span_renderer,

    NULL, /* copy_page */
    NULL, /* show_page */
    _cairo_image_surface_get_extents,
    NULL, /* old_show_glyphs */
    _cairo_image_surface_get_font_options,
    NULL, /* flush */
    NULL, /* mark dirty */
    NULL, /* font_fini */
    NULL, /* glyph_fini */

    _cairo_image_surface_paint,
    _cairo_image_surface_mask,
    _cairo_image_surface_stroke,
    _cairo_image_surface_fill,
    _cairo_image_surface_glyphs,
    NULL, /* show_text_glyphs */
    NULL, /* snapshot */
    NULL, /* is_similar */
};

/* A convenience function for when one needs to coerce an image
 * surface to an alternate format. */
cairo_image_surface_t *
_cairo_image_surface_coerce (cairo_image_surface_t *surface)
{
    return _cairo_image_surface_coerce_to_format (surface,
                                              _cairo_format_from_content (surface->base.content));
        
}

/* A convenience function for when one needs to coerce an image
 * surface to an alternate format. */
cairo_image_surface_t *
_cairo_image_surface_coerce_to_format (cairo_image_surface_t *surface,
                                 cairo_format_t       format)
{
    cairo_image_surface_t *clone;
    cairo_status_t status;

    status = surface->base.status;
    if (unlikely (status))
      return (cairo_image_surface_t *)_cairo_surface_create_in_error (status);

    if (surface->format == format)
      return (cairo_image_surface_t *)cairo_surface_reference(&surface->base);

    clone = (cairo_image_surface_t *)
      cairo_image_surface_create (format, surface->width, surface->height);
    if (unlikely (clone->base.status))
      return clone;

    pixman_image_composite32 (PIXMAN_OP_SRC,
                              surface->pixman_image, NULL, clone->pixman_image,
                              0, 0,
                              0, 0,
                              0, 0,
                              surface->width, surface->height);
    clone->base.is_clear = FALSE;

    clone->base.device_transform =
      surface->base.device_transform;
    clone->base.device_transform_inverse =
      surface->base.device_transform_inverse;

    return clone;
}

cairo_image_transparency_t
_cairo_image_analyze_transparency (cairo_image_surface_t      *image)
{
    int x, y;

    if (image->transparency != CAIRO_IMAGE_UNKNOWN)
      return image->transparency;

    if ((image->base.content & CAIRO_CONTENT_ALPHA) == 0)
      return image->transparency = CAIRO_IMAGE_IS_OPAQUE;

    if ((image->base.content & CAIRO_CONTENT_COLOR) == 0) {
      if (image->format == CAIRO_FORMAT_A1)
          return image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA;
      else
          return image->transparency = CAIRO_IMAGE_HAS_ALPHA;
    }

    if (image->format == CAIRO_FORMAT_RGB16_565) {
      image->transparency = CAIRO_IMAGE_IS_OPAQUE;
      return CAIRO_IMAGE_IS_OPAQUE;
    }

    if (image->format != CAIRO_FORMAT_ARGB32)
      return image->transparency = CAIRO_IMAGE_HAS_ALPHA;

    image->transparency = CAIRO_IMAGE_IS_OPAQUE;
    for (y = 0; y < image->height; y++) {
      uint32_t *pixel = (uint32_t *) (image->data + y * image->stride);

      for (x = 0; x < image->width; x++, pixel++) {
          int a = (*pixel & 0xff000000) >> 24;
          if (a > 0 && a < 255) {
            return image->transparency = CAIRO_IMAGE_HAS_ALPHA;
          } else if (a == 0) {
            image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA;
          }
      }
    }

    return image->transparency;
}

Generated by  Doxygen 1.6.0   Back to index