/* -*- 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,2011 Intel Corporation * * This library is free software; you can redistribute it and/or * modify it either under the terms of the GNU Lesser General Public * License version 2.1 as published by the Free Software Foundation * (the "LGPL") or, at your option, under the terms of the Mozilla * Public License Version 1.1 (the "MPL"). If you do not alter this * notice, a recipient may use your version of this file under either * the MPL or the LGPL. * * You should have received a copy of the LGPL along with this library * in the file COPYING-LGPL-2.1; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA * You should have received a copy of the MPL along with this library * in the file COPYING-MPL-1.1 * * The contents of this file are subject to the Mozilla Public License * Version 1.1 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY * OF ANY KIND, either express or implied. See the LGPL or the MPL for * the specific language governing rights and limitations. * * The Original Code is the cairo graphics library. * * The Initial Developer of the Original Code is University of Southern * California. * * Contributor(s): * Carl D. Worth * Chris Wilson */ #include "cairoint.h" #include "cairo-boxes-private.h" #include "cairo-clip-private.h" #include "cairo-composite-rectangles-private.h" #include "cairo-compositor-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-inline.h" #include "cairo-paginated-private.h" #include "cairo-pattern-private.h" #include "cairo-pixman-private.h" #include "cairo-recording-surface-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" #include "cairo-surface-shadow-private.h" #include "cairo-list-inline.h" #include "cairo-ttrace.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 MAX_IMAGE_SHADOW_SIZE 256 #define MIN_IMAGE_SHADOW_SIZE 32 /** * 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_list_t shadow_caches; static unsigned long shadow_caches_size = 0; static cairo_recursive_mutex_t shadow_caches_mutex; static unsigned shadow_caches_mutex_depth = 0; static cairo_atomic_int_t shadow_caches_ref_count = 0; static void _cairo_image_shadow_caches_init (void) { CAIRO_RECURSIVE_MUTEX_INIT (shadow_caches_mutex); CAIRO_MUTEX_LOCK (shadow_caches_mutex); _cairo_atomic_int_inc (&shadow_caches_ref_count); if (shadow_caches_ref_count == 1) cairo_list_init (&shadow_caches); CAIRO_MUTEX_UNLOCK (shadow_caches_mutex); } static void _cairo_image_shadow_caches_destroy (void) { assert (shadow_caches_ref_count != 0); if (! _cairo_atomic_int_dec_and_test (&shadow_caches_ref_count)) return; if (shadow_caches_mutex_depth == 0) { CAIRO_MUTEX_FINI (shadow_caches_mutex); while (! cairo_list_is_empty (&shadow_caches)) { cairo_shadow_cache_t *shadow; shadow = cairo_list_first_entry (&shadow_caches, cairo_shadow_cache_t, link); cairo_list_del (&shadow->link); cairo_surface_destroy (shadow->surface); free (shadow); } shadow_caches_size = 0; } } static cairo_status_t _cairo_image_surface_shadow_cache_acquire (void *abstract_surface) { cairo_image_surface_t *surface = abstract_surface; if (! surface || surface->base.type != CAIRO_SURFACE_TYPE_IMAGE) return CAIRO_STATUS_SURFACE_TYPE_MISMATCH; if (unlikely (surface->base.status)) return surface->base.status; if (!surface->shadow_cache_init) { _cairo_image_shadow_caches_init(); surface->shadow_cache_init = 1; } CAIRO_MUTEX_LOCK (shadow_caches_mutex); shadow_caches_mutex_depth++; return CAIRO_STATUS_SUCCESS; } static void _cairo_image_surface_shadow_cache_release (void *abstract_surface) { cairo_image_surface_t *surface = abstract_surface; if (! surface || surface->base.type != CAIRO_SURFACE_TYPE_IMAGE) return; if (unlikely (surface->base.status)) return; assert (shadow_caches_mutex_depth > 0); shadow_caches_mutex_depth--; CAIRO_MUTEX_UNLOCK (shadow_caches_mutex); } static cairo_list_t * _cairo_image_surface_get_shadow_cache (void *abstract_surface) { cairo_image_surface_t *surface = abstract_surface; if (! surface || surface->base.type != CAIRO_SURFACE_TYPE_IMAGE) return NULL; if (unlikely (surface->base.status)) return NULL; if (!surface->shadow_cache_init) { _cairo_image_shadow_caches_init(); surface->shadow_cache_init = 1; } return &shadow_caches; } static unsigned long * _cairo_image_surface_get_shadow_cache_size (void *abstract_surface) { cairo_image_surface_t *surface = abstract_surface; if (! surface || surface->base.type != CAIRO_SURFACE_TYPE_IMAGE) return NULL; if (unlikely (surface->base.status)) return NULL; return &shadow_caches_size; } static cairo_bool_t _cairo_image_surface_has_shadow_cache (void *abstract_surface) { cairo_image_surface_t *surface = abstract_surface; if (! surface || surface->base.type != CAIRO_SURFACE_TYPE_IMAGE) return FALSE; return TRUE; } 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_x2r10g10b10: return CAIRO_FORMAT_RGB30; 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; #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,22,0) case PIXMAN_r8g8b8a8: case PIXMAN_r8g8b8x8: #endif #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,27,2) case PIXMAN_a8r8g8b8_sRGB: #endif 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_a2b10g10r10: case PIXMAN_x2b10g10r10: case PIXMAN_a2r10g10b10: #if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0,22,0) case PIXMAN_x14r6g6b6: #endif 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; } void _cairo_image_surface_init (cairo_image_surface_t *surface, pixman_image_t *pixman_image, pixman_format_code_t pixman_format) { CAIRO_TRACE_BEGIN (__func__); surface->parent = NULL; 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->color = CAIRO_IMAGE_UNKNOWN_COLOR; surface->width = pixman_image_get_width (pixman_image); surface->height = pixman_image_get_height (pixman_image); surface->stride = pixman_image_get_stride (pixman_image); surface->depth = pixman_image_get_depth (pixman_image); surface->base.is_clear = surface->width == 0 || surface->height == 0; surface->compositor = _cairo_image_spans_compositor_get (); surface->shadow_cache_init = 0; CAIRO_TRACE_END (__func__); } cairo_surface_t * _cairo_image_surface_create_for_pixman_image (pixman_image_t *pixman_image, pixman_format_code_t pixman_format) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *surface; surface = malloc (sizeof (cairo_image_surface_t)); if (unlikely (surface == NULL)) { CAIRO_TRACE_END (__func__); 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)); _cairo_image_surface_init (surface, pixman_image, pixman_format); CAIRO_TRACE_END (__func__); 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_RGB30: ret = PIXMAN_x2r10g10b10; 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_TRACE_BEGIN (__func__); cairo_surface_t *surface; pixman_image_t *pixman_image; if (! _cairo_image_surface_is_size_valid (width, height)) { CAIRO_TRACE_END (__func__); 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)) { CAIRO_TRACE_END (__func__); 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); CAIRO_TRACE_END (__func__); return surface; } /* we can not make any assumptions about the initial state of user data */ surface->is_clear = data == NULL; CAIRO_TRACE_END (__func__); 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. * * Since: 1.0 **/ cairo_surface_t * cairo_image_surface_create (cairo_format_t format, int width, int height) { CAIRO_TRACE_BEGIN (__func__); pixman_format_code_t pixman_format; cairo_surface_t *image_surface = NULL; if (! CAIRO_FORMAT_VALID (format)) { CAIRO_TRACE_END (__func__); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT)); } pixman_format = _cairo_format_to_pixman_format_code (format); image_surface = _cairo_image_surface_create_with_pixman_format (NULL, pixman_format, width, height, -1); CAIRO_TRACE_END (__func__); return image_surface; } 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: * * * 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); * * * 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. * * Since: 1.0 **/ 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. * * A call to cairo_surface_flush() is required before accessing the * pixel data to ensure that all pending drawing operations are * finished. A call to cairo_surface_mark_dirty() is required after * the data is modified. * * 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. * * Since: 1.0 **/ 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. * * Since: 1.0 **/ 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_RGB30: return CAIRO_CONTENT_COLOR; 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: case CAIRO_FORMAT_RGB30: 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; } } 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; TRACE ((stderr, "%s (other=%u)\n", __FUNCTION__, other->base.unique_id)); 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); } cairo_surface_t * _cairo_image_surface_snapshot (void *abstract_surface) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *image = abstract_surface; cairo_image_surface_t *clone; /* If we own the image, we can simply steal the memory for the snapshot */ if (image->owns_data && image->base._finishing) { clone = (cairo_image_surface_t *) _cairo_image_surface_create_for_pixman_image (image->pixman_image, image->pixman_format); if (unlikely (clone->base.status)) { CAIRO_TRACE_END (__func__); return &clone->base; } image->pixman_image = NULL; image->owns_data = FALSE; clone->transparency = image->transparency; clone->color = image->color; clone->owns_data = TRUE; CAIRO_TRACE_END (__func__); return &clone->base; } clone = (cairo_image_surface_t *) _cairo_image_surface_create_with_pixman_format (NULL, image->pixman_format, image->width, image->height, 0); if (unlikely (clone->base.status)) { CAIRO_TRACE_END (__func__); return &clone->base; } if (clone->stride == image->stride) { memcpy (clone->data, image->data, clone->stride * clone->height); } else { pixman_image_composite32 (PIXMAN_OP_SRC, image->pixman_image, NULL, clone->pixman_image, 0, 0, 0, 0, 0, 0, image->width, image->height); } clone->base.is_clear = FALSE; CAIRO_TRACE_END (__func__); return &clone->base; } cairo_image_surface_t * _cairo_image_surface_map_to_image (void *abstract_other, const cairo_rectangle_int_t *extents) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *other = abstract_other; cairo_surface_t *surface; uint8_t *data; data = other->data; data += extents->y * other->stride; data += extents->x * PIXMAN_FORMAT_BPP (other->pixman_format)/ 8; surface = _cairo_image_surface_create_with_pixman_format (data, other->pixman_format, extents->width, extents->height, other->stride); cairo_surface_set_device_offset (surface, -extents->x, -extents->y); CAIRO_TRACE_END (__func__); return (cairo_image_surface_t *) surface; } cairo_int_status_t _cairo_image_surface_unmap_image (void *abstract_surface, cairo_image_surface_t *image) { cairo_surface_finish (&image->base); cairo_surface_destroy (&image->base); return CAIRO_INT_STATUS_SUCCESS; } cairo_status_t _cairo_image_surface_finish (void *abstract_surface) { CAIRO_TRACE_BEGIN (__func__); 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; } if (surface->parent) { cairo_surface_t *parent = surface->parent; surface->parent = NULL; cairo_surface_destroy (parent); } if (surface->shadow_cache_init) { _cairo_image_shadow_caches_destroy (); surface->shadow_cache_init = 0; } CAIRO_TRACE_END (__func__); return CAIRO_STATUS_SUCCESS; } void _cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface) { surface->owns_data = TRUE; } cairo_surface_t * _cairo_image_surface_source (void *abstract_surface, cairo_rectangle_int_t *extents) { cairo_image_surface_t *surface = abstract_surface; if (extents) { extents->x = extents->y = 0; extents->width = surface->width; extents->height = surface->height; } return &surface->base; } 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; } void _cairo_image_surface_release_source_image (void *abstract_surface, cairo_image_surface_t *image, void *image_extra) { } /* high level image interface */ 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; } cairo_int_status_t _cairo_image_surface_paint (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *surface = abstract_surface; cairo_int_status_t status; TRACE ((stderr, "%s (surface=%d)\n", __FUNCTION__, surface->base.unique_id)); status = cairo_device_acquire (surface->base.device); if (unlikely (status)) { CAIRO_TRACE_END (__func__); return status; } status = _cairo_surface_shadow_paint (abstract_surface, op, source, clip, &source->shadow); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (source->shadow.draw_shadow_only) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } status = _cairo_compositor_paint (surface->compositor, &surface->base, op, source, clip); cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } 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, const cairo_clip_t *clip) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *surface = abstract_surface; cairo_int_status_t status; TRACE ((stderr, "%s (surface=%d)\n", __FUNCTION__, surface->base.unique_id)); status = cairo_device_acquire (surface->base.device); if (unlikely (status)) { CAIRO_TRACE_END (__func__); return status; } status = _cairo_surface_shadow_mask (abstract_surface, op, source, mask, clip, &source->shadow); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (source->shadow.draw_shadow_only) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } status = _cairo_compositor_mask (surface->compositor, &surface->base, op, source, mask, clip); cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } cairo_int_status_t _cairo_image_surface_stroke (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, const cairo_stroke_style_t *style, const cairo_matrix_t *ctm, const cairo_matrix_t *ctm_inverse, double tolerance, cairo_antialias_t antialias, const cairo_clip_t *clip) { CAIRO_TRACE_BEGIN (__func__); cairo_int_status_t status; cairo_image_surface_t *surface = abstract_surface; cairo_shadow_type_t shadow_type = source->shadow.type; TRACE ((stderr, "%s (surface=%d)\n", __FUNCTION__, surface->base.unique_id)); status = cairo_device_acquire (surface->base.device); if (unlikely (status)) { CAIRO_TRACE_END (__func__); return status; } if (shadow_type != CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_stroke (abstract_surface, op, source, path, style, ctm, ctm_inverse, tolerance, antialias, clip, &source->shadow); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_DROP && source->shadow.draw_shadow_only) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (! source->shadow.draw_shadow_only) status = _cairo_compositor_stroke (surface->compositor, &surface->base, op, source, path, style, ctm, ctm_inverse, tolerance, antialias, clip); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_stroke (abstract_surface, op, source, path, style, ctm, ctm_inverse, tolerance, antialias, clip, &source->shadow); cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } cairo_int_status_t _cairo_image_surface_fill (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias, const cairo_clip_t *clip) { CAIRO_TRACE_BEGIN (__func__); cairo_int_status_t status; cairo_image_surface_t *surface = abstract_surface; cairo_shadow_type_t shadow_type = source->shadow.type; TRACE ((stderr, "%s (surface=%d)\n", __FUNCTION__, surface->base.unique_id)); status = cairo_device_acquire (surface->base.device); if (unlikely (status)) { CAIRO_TRACE_END (__func__); return status; } if (shadow_type != CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_fill (abstract_surface, op, source, path, fill_rule, tolerance, antialias, clip, &source->shadow); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_DROP && source->shadow.draw_shadow_only) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (! source->shadow.draw_shadow_only) { if (! source->shadow.path_is_fill_with_spread || source->shadow.type != CAIRO_SHADOW_INSET) status = _cairo_compositor_fill (surface->compositor, &surface->base, op, source, path, fill_rule, tolerance, antialias, clip); else status = _cairo_compositor_paint (surface->compositor, &surface->base, op, source, clip); } if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_fill (abstract_surface, op, source, path, fill_rule, tolerance, antialias, clip, &source->shadow); cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } 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, const cairo_clip_t *clip) { CAIRO_TRACE_BEGIN (__func__); cairo_int_status_t status; cairo_image_surface_t *surface = abstract_surface; cairo_shadow_type_t shadow_type = source->shadow.type; TRACE ((stderr, "%s (surface=%d)\n", __FUNCTION__, surface->base.unique_id)); status = cairo_device_acquire (surface->base.device); if (unlikely (status)) { CAIRO_TRACE_END (__func__); return status; } if (shadow_type != CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_glyphs (abstract_surface, op, source, scaled_font, glyphs, num_glyphs, clip, &source->shadow); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_DROP && source->shadow.draw_shadow_only) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (! source->shadow.draw_shadow_only) status = _cairo_compositor_glyphs (surface->compositor, &surface->base, op, source, glyphs, num_glyphs, scaled_font, clip); if (unlikely (status)) { cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } if (shadow_type == CAIRO_SHADOW_INSET) status = _cairo_surface_shadow_glyphs (abstract_surface, op, source, scaled_font, glyphs, num_glyphs, clip, &source->shadow); cairo_device_release (surface->base.device); CAIRO_TRACE_END (__func__); return status; } 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); _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_ON); } static cairo_surface_t * _cairo_image_surface_shadow_surface (void *surface, cairo_bool_t has_blur, int width, int height, int *width_out, int *height_out) { CAIRO_TRACE_BEGIN (__func__); int shadow_width, shadow_height; cairo_image_surface_t *shadow_surface = NULL; if (width < MIN_IMAGE_SHADOW_SIZE) shadow_width = width; else if (has_blur) { if (width < MIN_IMAGE_SHADOW_SIZE * 2) shadow_width = MIN_IMAGE_SHADOW_SIZE; else if (width > MAX_IMAGE_SHADOW_SIZE * 2) shadow_width = MAX_IMAGE_SHADOW_SIZE; else shadow_width = width * 0.5; } else { if (width > MAX_IMAGE_SHADOW_SIZE) shadow_width = MAX_IMAGE_SHADOW_SIZE; else shadow_width = width; } if (height < MIN_IMAGE_SHADOW_SIZE) shadow_height = height; else if (has_blur) { if (height < MIN_IMAGE_SHADOW_SIZE * 2) shadow_height = MIN_IMAGE_SHADOW_SIZE; else if (height > MAX_IMAGE_SHADOW_SIZE * 2) shadow_height = MAX_IMAGE_SHADOW_SIZE; else shadow_height = height * 0.5; } else { if (height > MAX_IMAGE_SHADOW_SIZE) shadow_height = MAX_IMAGE_SHADOW_SIZE; else shadow_height = height; } shadow_surface = (cairo_image_surface_t *) cairo_image_surface_create (CAIRO_FORMAT_ARGB32, shadow_width, shadow_height); if (unlikely (shadow_surface->base.status)) { cairo_surface_destroy (&shadow_surface->base); CAIRO_TRACE_END (__func__); return NULL; } *width_out = shadow_width; *height_out = shadow_height; CAIRO_TRACE_END (__func__); return &shadow_surface->base; } const cairo_surface_backend_t _cairo_image_surface_backend = { CAIRO_SURFACE_TYPE_IMAGE, _cairo_image_surface_finish, _cairo_default_context_create, _cairo_image_surface_create_similar, NULL, /* create similar image */ _cairo_image_surface_map_to_image, _cairo_image_surface_unmap_image, _cairo_image_surface_source, _cairo_image_surface_acquire_source_image, _cairo_image_surface_release_source_image, _cairo_image_surface_snapshot, NULL, /* copy_page */ NULL, /* show_page */ _cairo_image_surface_get_extents, _cairo_image_surface_get_font_options, NULL, /* flush */ NULL, _cairo_image_surface_paint, _cairo_image_surface_mask, _cairo_image_surface_stroke, _cairo_image_surface_fill, NULL, /* fill-stroke */ _cairo_image_surface_glyphs, NULL, /* has_text_glyphs */ NULL, /* show_text_glyphs */ NULL, /* get_supported_mime_types */ _cairo_image_surface_shadow_surface, NULL, /* get_glyph_shadow_surface */ NULL, /* get_shadow_mask_surface */ NULL, /* get_glyph_shadow_mask_surface */ _cairo_image_surface_shadow_cache_acquire, _cairo_image_surface_shadow_cache_release, _cairo_image_surface_get_shadow_cache, _cairo_image_surface_get_shadow_cache_size, _cairo_image_surface_has_shadow_cache, }; /* 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_surface_t * _cairo_image_surface_create_from_image (cairo_image_surface_t *other, pixman_format_code_t format, int x, int y, int width, int height, int stride) { CAIRO_TRACE_BEGIN (__func__); cairo_image_surface_t *surface = NULL; cairo_status_t status; pixman_image_t *image; void *mem = NULL; status = other->base.status; if (unlikely (status)) goto cleanup; if (stride) { mem = _cairo_malloc_ab (height, stride); if (unlikely (mem == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto cleanup; } } image = pixman_image_create_bits (format, width, height, mem, stride); if (unlikely (image == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto cleanup_mem; } surface = (cairo_image_surface_t *) _cairo_image_surface_create_for_pixman_image (image, format); if (unlikely (surface->base.status)) { status = surface->base.status; goto cleanup_image; } pixman_image_composite32 (PIXMAN_OP_SRC, other->pixman_image, NULL, image, x, y, 0, 0, 0, 0, width, height); surface->base.is_clear = FALSE; surface->owns_data = mem != NULL; CAIRO_TRACE_END (__func__); return surface; cleanup_image: pixman_image_unref (image); cleanup_mem: free (mem); cleanup: cairo_surface_destroy (&surface->base); CAIRO_TRACE_END (__func__); return (cairo_image_surface_t *) _cairo_surface_create_in_error (status); } 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.is_clear) return image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA; if ((image->base.content & CAIRO_CONTENT_COLOR) == 0) { if (image->format == CAIRO_FORMAT_A1) { return image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA; } else if (image->format == CAIRO_FORMAT_A8) { for (y = 0; y < image->height; y++) { uint8_t *alpha = (uint8_t *) (image->data + y * image->stride); for (x = 0; x < image->width; x++, alpha++) { if (*alpha > 0 && *alpha < 255) return image->transparency = CAIRO_IMAGE_HAS_ALPHA; } } 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; } cairo_image_color_t _cairo_image_analyze_color (cairo_image_surface_t *image) { int x, y; if (image->color != CAIRO_IMAGE_UNKNOWN_COLOR) return image->color; if (image->format == CAIRO_FORMAT_A1) return image->color = CAIRO_IMAGE_IS_MONOCHROME; if (image->format == CAIRO_FORMAT_A8) return image->color = CAIRO_IMAGE_IS_GRAYSCALE; if (image->format == CAIRO_FORMAT_ARGB32) { image->color = CAIRO_IMAGE_IS_MONOCHROME; 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; int r = (*pixel & 0x00ff0000) >> 16; int g = (*pixel & 0x0000ff00) >> 8; int b = (*pixel & 0x000000ff); if (a == 0) { r = g = b = 0; } else { r = (r * 255 + a / 2) / a; g = (g * 255 + a / 2) / a; b = (b * 255 + a / 2) / a; } if (!(r == g && g == b)) return image->color = CAIRO_IMAGE_IS_COLOR; else if (r > 0 && r < 255) image->color = CAIRO_IMAGE_IS_GRAYSCALE; } } return image->color; } if (image->format == CAIRO_FORMAT_RGB24) { image->color = CAIRO_IMAGE_IS_MONOCHROME; 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 r = (*pixel & 0x00ff0000) >> 16; int g = (*pixel & 0x0000ff00) >> 8; int b = (*pixel & 0x000000ff); if (!(r == g && g == b)) return image->color = CAIRO_IMAGE_IS_COLOR; else if (r > 0 && r < 255) image->color = CAIRO_IMAGE_IS_GRAYSCALE; } } return image->color; } return image->color = CAIRO_IMAGE_IS_COLOR; } cairo_image_surface_t * _cairo_image_surface_clone_subimage (cairo_surface_t *surface, const cairo_rectangle_int_t *extents) { CAIRO_TRACE_BEGIN (__func__); cairo_surface_t *image; cairo_surface_pattern_t pattern; cairo_status_t status; image = cairo_surface_create_similar_image (surface, _cairo_format_from_content (surface->content), extents->width, extents->height); if (image->status) { CAIRO_TRACE_END (__func__); return to_image_surface (image); } /* TODO: check me with non-identity device_transform. Should we * clone the scaling, too? */ cairo_surface_set_device_offset (image, -extents->x, -extents->y); _cairo_pattern_init_for_surface (&pattern, surface); pattern.base.filter = CAIRO_FILTER_NEAREST; status = _cairo_surface_paint (image, CAIRO_OPERATOR_SOURCE, &pattern.base, NULL); _cairo_pattern_fini (&pattern.base); if (unlikely (status)) goto error; /* We use the parent as a flag during map-to-image/umap-image that the * resultant image came from a fallback rather than as direct call * to the backend's map_to_image(). Whilst we use it as a simple flag, * we need to make sure the parent surface obeys the reference counting * semantics and is consistent for all callers. */ _cairo_image_surface_set_parent (to_image_surface (image), cairo_surface_reference (surface)); CAIRO_TRACE_END (__func__); return to_image_surface (image); error: cairo_surface_destroy (image); CAIRO_TRACE_END (__func__); return to_image_surface (_cairo_surface_create_in_error (status)); }