/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ /* cairo - a vector graphics library with display and print output * * Copyright © 2005 Red Hat, Inc * Copyright © 2007 Adrian Johnson * * 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 Red Hat, Inc. * * Contributor(s): * Kristian Høgsberg * Carl Worth * Adrian Johnson */ /** * SECTION:cairo-recording * @Title: Recording Surfaces * @Short_Description: Records all drawing operations * @See_Also: #cairo_surface_t * * A recording surface is a surface that records all drawing operations at * the highest level of the surface backend interface, (that is, the * level of paint, mask, stroke, fill, and show_text_glyphs). The recording * surface can then be "replayed" against any target surface by using it * as a source surface. * * If you want to replay a surface so that the results in target will be * identical to the results that would have been obtained if the original * operations applied to the recording surface had instead been applied to the * target surface, you can use code like this: * * cairo_t *cr; * * cr = cairo_create (target); * cairo_set_source_surface (cr, recording_surface, 0.0, 0.0); * cairo_paint (cr); * cairo_destroy (cr); * * * A recording surface is logically unbounded, i.e. it has no implicit constraint * on the size of the drawing surface. However, in practice this is rarely * useful as you wish to replay against a particular target surface with * known bounds. For this case, it is more efficient to specify the target * extents to the recording surface upon creation. * * The recording phase of the recording surface is careful to snapshot all * necessary objects (paths, patterns, etc.), in order to achieve * accurate replay. The efficiency of the recording surface could be * improved by improving the implementation of snapshot for the * various objects. For example, it would be nice to have a * copy-on-write implementation for _cairo_surface_snapshot. **/ #include "cairoint.h" #include "cairo-array-private.h" #include "cairo-analysis-surface-private.h" #include "cairo-clip-private.h" #include "cairo-combsort-inline.h" #include "cairo-composite-rectangles-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" #include "cairo-list-inline.h" #include "cairo-recording-surface-inline.h" #include "cairo-surface-snapshot-inline.h" #include "cairo-surface-wrapper-private.h" #include "cairo-traps-private.h" typedef struct _cairo_recording_surface_replay_params { const cairo_rectangle_int_t *surface_extents; const cairo_matrix_t *surface_transform; cairo_surface_t *target; const cairo_clip_t *target_clip; cairo_bool_t surface_is_unbounded; cairo_recording_replay_type_t type; cairo_recording_region_type_t region; unsigned int regions_id; const cairo_color_t *foreground_color; cairo_bool_t foreground_used; cairo_bool_t replay_all; } cairo_recording_surface_replay_params_t; static const cairo_surface_backend_t cairo_recording_surface_backend; /** * CAIRO_HAS_RECORDING_SURFACE: * * Defined if the recording surface backend is available. * The recording surface backend is always built in. * This macro was added for completeness in cairo 1.10. * * Since: 1.10 **/ /* Currently all recording surfaces do have a size which should be passed * in as the maximum size of any target surface against which the * recording-surface will ever be replayed. * * XXX: The naming of "pixels" in the size here is a misnomer. It's * actually a size in whatever device-space units are desired (again, * according to the intended replay target). */ static int bbtree_left_or_right (struct bbtree *bbt, const cairo_box_t *box) { int left, right; if (bbt->left) { cairo_box_t *e = &bbt->left->extents; cairo_box_t b; b.p1.x = MIN (e->p1.x, box->p1.x); b.p1.y = MIN (e->p1.y, box->p1.y); b.p2.x = MAX (e->p2.x, box->p2.x); b.p2.y = MAX (e->p2.y, box->p2.y); left = _cairo_fixed_integer_part (b.p2.x - b.p1.x) * _cairo_fixed_integer_part (b.p2.y - b.p1.y); left -= _cairo_fixed_integer_part (e->p2.x - e->p1.x) * _cairo_fixed_integer_part (e->p2.y - e->p1.y); } else left = 0; if (bbt->right) { cairo_box_t *e = &bbt->right->extents; cairo_box_t b; b.p1.x = MIN (e->p1.x, box->p1.x); b.p1.y = MIN (e->p1.y, box->p1.y); b.p2.x = MAX (e->p2.x, box->p2.x); b.p2.y = MAX (e->p2.y, box->p2.y); right = _cairo_fixed_integer_part (b.p2.x - b.p1.x) * _cairo_fixed_integer_part (b.p2.y - b.p1.y); right -= _cairo_fixed_integer_part (e->p2.x - e->p1.x) * _cairo_fixed_integer_part (e->p2.y - e->p1.y); } else right = 0; return left <= right; } #define INVALID_CHAIN ((cairo_command_header_t *)-1) static struct bbtree * bbtree_new (const cairo_box_t *box, cairo_command_header_t *chain) { struct bbtree *bbt = _cairo_malloc (sizeof (*bbt)); if (bbt == NULL) return NULL; bbt->extents = *box; bbt->left = bbt->right = NULL; bbt->chain = chain; return bbt; } static void bbtree_init (struct bbtree *bbt, cairo_command_header_t *header) { _cairo_box_from_rectangle (&bbt->extents, &header->extents); bbt->chain = header; } static cairo_status_t bbtree_add (struct bbtree *bbt, cairo_command_header_t *header, const cairo_box_t *box) { if (box->p1.x < bbt->extents.p1.x || box->p1.y < bbt->extents.p1.y || box->p2.x > bbt->extents.p2.x || box->p2.y > bbt->extents.p2.y) { if (bbt->chain) { if (bbtree_left_or_right (bbt, &bbt->extents)) { if (bbt->left == NULL) { bbt->left = bbtree_new (&bbt->extents, bbt->chain); if (unlikely (bbt->left == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); } else bbtree_add (bbt->left, bbt->chain, &bbt->extents); } else { if (bbt->right == NULL) { bbt->right = bbtree_new (&bbt->extents, bbt->chain); if (unlikely (bbt->right == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); } else bbtree_add (bbt->right, bbt->chain, &bbt->extents); } bbt->chain = NULL; } bbt->extents.p1.x = MIN (bbt->extents.p1.x, box->p1.x); bbt->extents.p1.y = MIN (bbt->extents.p1.y, box->p1.y); bbt->extents.p2.x = MAX (bbt->extents.p2.x, box->p2.x); bbt->extents.p2.y = MAX (bbt->extents.p2.y, box->p2.y); } if (box->p1.x == bbt->extents.p1.x && box->p1.y == bbt->extents.p1.y && box->p2.x == bbt->extents.p2.x && box->p2.y == bbt->extents.p2.y) { cairo_command_header_t *last = header; while (last->chain) /* expected to be infrequent */ last = last->chain; last->chain = bbt->chain; bbt->chain = header; return CAIRO_STATUS_SUCCESS; } if (bbtree_left_or_right (bbt, box)) { if (bbt->left == NULL) { bbt->left = bbtree_new (box, header); if (unlikely (bbt->left == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); } else return bbtree_add (bbt->left, header, box); } else { if (bbt->right == NULL) { bbt->right = bbtree_new (box, header); if (unlikely (bbt->right == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); } else return bbtree_add (bbt->right, header, box); } return CAIRO_STATUS_SUCCESS; } static void bbtree_del (struct bbtree *bbt) { if (bbt->left) bbtree_del (bbt->left); if (bbt->right) bbtree_del (bbt->right); free (bbt); } static cairo_bool_t box_outside (const cairo_box_t *a, const cairo_box_t *b) { return a->p1.x >= b->p2.x || a->p1.y >= b->p2.y || a->p2.x <= b->p1.x || a->p2.y <= b->p1.y; } static void bbtree_foreach_mark_visible (struct bbtree *bbt, const cairo_box_t *box, unsigned int **indices) { cairo_command_header_t *chain; for (chain = bbt->chain; chain; chain = chain->chain) *(*indices)++ = chain->index; if (bbt->left && ! box_outside (box, &bbt->left->extents)) bbtree_foreach_mark_visible (bbt->left, box, indices); if (bbt->right && ! box_outside (box, &bbt->right->extents)) bbtree_foreach_mark_visible (bbt->right, box, indices); } static inline int intcmp (const unsigned int a, const unsigned int b) { return a - b; } CAIRO_COMBSORT_DECLARE (sort_indices, unsigned int, intcmp) static inline int sizecmp (unsigned int a, unsigned int b, cairo_command_header_t **elements) { const cairo_rectangle_int_t *r; r = &elements[a]->extents; a = r->width * r->height; r = &elements[b]->extents; b = r->width * r->height; return b - a; } CAIRO_COMBSORT_DECLARE_WITH_DATA (sort_commands, unsigned int, sizecmp) static void _cairo_recording_surface_destroy_bbtree (cairo_recording_surface_t *surface) { cairo_command_t **elements; int i, num_elements; if (surface->bbtree.chain == INVALID_CHAIN) return; if (surface->bbtree.left) { bbtree_del (surface->bbtree.left); surface->bbtree.left = NULL; } if (surface->bbtree.right) { bbtree_del (surface->bbtree.right); surface->bbtree.right = NULL; } elements = _cairo_array_index (&surface->commands, 0); num_elements = surface->commands.num_elements; for (i = 0; i < num_elements; i++) elements[i]->header.chain = NULL; surface->bbtree.chain = INVALID_CHAIN; } static cairo_status_t _cairo_recording_surface_create_bbtree (cairo_recording_surface_t *surface) { cairo_command_t **elements = _cairo_array_index (&surface->commands, 0); unsigned int *indices; cairo_status_t status; unsigned int i, count; count = surface->commands.num_elements; if (count > surface->num_indices) { free (surface->indices); surface->indices = _cairo_malloc_ab (count, sizeof (int)); if (unlikely (surface->indices == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); surface->num_indices = count; } indices = surface->indices; for (i = 0; i < count; i++) indices[i] = i; sort_commands (indices, count, elements); bbtree_init (&surface->bbtree, &elements[indices[0]]->header); for (i = 1; i < count; i++) { cairo_command_header_t *header = &elements[indices[i]]->header; cairo_box_t box; _cairo_box_from_rectangle (&box, &header->extents); status = bbtree_add (&surface->bbtree, header, &box); if (unlikely (status)) goto cleanup; } return CAIRO_STATUS_SUCCESS; cleanup: if (surface->bbtree.left) bbtree_del (surface->bbtree.left); if (surface->bbtree.right) bbtree_del (surface->bbtree.right); return status; } /** * cairo_recording_surface_create: * @content: the content of the recording surface * @extents: the extents to record in pixels, can be %NULL to record * unbounded operations. * * Creates a recording-surface which can be used to record all drawing operations * at the highest level (that is, the level of paint, mask, stroke, fill * and show_text_glyphs). The recording surface can then be "replayed" against * any target surface by using it as a source to drawing operations. * * The recording phase of the recording surface is careful to snapshot all * necessary objects (paths, patterns, etc.), in order to achieve * accurate replay. * * Return value: a pointer to the newly created surface. The caller * owns the surface and should call cairo_surface_destroy() when done * with it. * * Since: 1.10 **/ cairo_surface_t * cairo_recording_surface_create (cairo_content_t content, const cairo_rectangle_t *extents) { cairo_recording_surface_t *surface; surface = _cairo_malloc (sizeof (cairo_recording_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &cairo_recording_surface_backend, NULL, /* device */ content, TRUE); /* is_vector */ surface->unbounded = TRUE; /* unbounded -> 'infinite' extents */ if (extents != NULL) { surface->extents_pixels = *extents; /* XXX check for overflow */ surface->extents.x = floor (extents->x); surface->extents.y = floor (extents->y); surface->extents.width = ceil (extents->x + extents->width) - surface->extents.x; surface->extents.height = ceil (extents->y + extents->height) - surface->extents.y; surface->unbounded = FALSE; } _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); surface->base.is_clear = TRUE; surface->bbtree.left = surface->bbtree.right = NULL; surface->bbtree.chain = INVALID_CHAIN; surface->indices = NULL; surface->num_indices = 0; surface->optimize_clears = TRUE; surface->has_bilevel_alpha = FALSE; surface->has_only_op_over = FALSE; surface->has_tags = FALSE; CAIRO_MUTEX_INIT (surface->mutex); cairo_list_init (&surface->region_array_list); return &surface->base; } slim_hidden_def (cairo_recording_surface_create); static cairo_surface_t * _cairo_recording_surface_create_similar (void *abstract_surface, cairo_content_t content, int width, int height) { cairo_rectangle_t extents; extents.x = extents.y = 0; extents.width = width; extents.height = height; return cairo_recording_surface_create (content, &extents); } static void destroy_pattern_region_array (const cairo_pattern_t *pattern, unsigned int region_id) { if (region_id != 0) { if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) { cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern; if (_cairo_surface_is_recording (surface_pattern->surface)) _cairo_recording_surface_region_array_remove (surface_pattern->surface, region_id); } } } static void _cairo_recording_surface_region_array_destroy (cairo_recording_surface_t *surface, cairo_recording_regions_array_t *region_array) { cairo_command_t **elements; cairo_recording_region_element_t *region_elements; int i, num_elements; num_elements = surface->commands.num_elements; elements = _cairo_array_index (&surface->commands, 0); region_elements = _cairo_array_index (®ion_array->regions, 0); for (i = 0; i < num_elements; i++) { cairo_command_t *command = elements[i]; cairo_recording_region_element_t *region_element = ®ion_elements[i]; switch (command->header.type) { case CAIRO_COMMAND_PAINT: destroy_pattern_region_array (&command->paint.source.base, region_element->source_id); break; case CAIRO_COMMAND_MASK: destroy_pattern_region_array (&command->mask.source.base, region_element->source_id); destroy_pattern_region_array (&command->mask.mask.base, region_element->mask_id); break; case CAIRO_COMMAND_STROKE: destroy_pattern_region_array (&command->stroke.source.base, region_element->source_id); break; case CAIRO_COMMAND_FILL: destroy_pattern_region_array (&command->fill.source.base, region_element->source_id); break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: destroy_pattern_region_array (&command->show_text_glyphs.source.base, region_element->source_id); break; case CAIRO_COMMAND_TAG: break; default: ASSERT_NOT_REACHED; } } _cairo_array_fini (®ion_array->regions); free (region_array); } static cairo_status_t _cairo_recording_surface_finish (void *abstract_surface) { cairo_recording_surface_t *surface = abstract_surface; cairo_command_t **elements; int i, num_elements; cairo_recording_regions_array_t *region_array, *region_next; /* Normally backend surfaces hold a reference to the surface as * well as the region and free the region before the surface. So * the regions should already be freed at this point but just in * case we ensure the regions are freed before destroying the * surface. */ cairo_list_foreach_entry_safe (region_array, region_next, cairo_recording_regions_array_t, &surface->region_array_list, link) { cairo_list_del (®ion_array->link); _cairo_recording_surface_region_array_destroy (surface, region_array); } num_elements = surface->commands.num_elements; elements = _cairo_array_index (&surface->commands, 0); for (i = 0; i < num_elements; i++) { cairo_command_t *command = elements[i]; switch (command->header.type) { case CAIRO_COMMAND_PAINT: _cairo_pattern_fini (&command->paint.source.base); break; case CAIRO_COMMAND_MASK: _cairo_pattern_fini (&command->mask.source.base); _cairo_pattern_fini (&command->mask.mask.base); break; case CAIRO_COMMAND_STROKE: _cairo_pattern_fini (&command->stroke.source.base); _cairo_path_fixed_fini (&command->stroke.path); _cairo_stroke_style_fini (&command->stroke.style); break; case CAIRO_COMMAND_FILL: _cairo_pattern_fini (&command->fill.source.base); _cairo_path_fixed_fini (&command->fill.path); break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: _cairo_pattern_fini (&command->show_text_glyphs.source.base); free (command->show_text_glyphs.utf8); free (command->show_text_glyphs.glyphs); free (command->show_text_glyphs.clusters); cairo_scaled_font_destroy (command->show_text_glyphs.scaled_font); break; case CAIRO_COMMAND_TAG: free (command->tag.tag_name); if (command->tag.begin) { free (command->tag.attributes); } break; default: ASSERT_NOT_REACHED; } _cairo_clip_destroy (command->header.clip); free (command); } _cairo_array_fini (&surface->commands); if (surface->bbtree.left) bbtree_del (surface->bbtree.left); if (surface->bbtree.right) bbtree_del (surface->bbtree.right); free (surface->indices); return CAIRO_STATUS_SUCCESS; } struct proxy { cairo_surface_t base; cairo_surface_t *image; }; static cairo_status_t proxy_acquire_source_image (void *abstract_surface, cairo_image_surface_t **image_out, void **image_extra) { struct proxy *proxy = abstract_surface; return _cairo_surface_acquire_source_image (proxy->image, image_out, image_extra); } static void proxy_release_source_image (void *abstract_surface, cairo_image_surface_t *image, void *image_extra) { struct proxy *proxy = abstract_surface; _cairo_surface_release_source_image (proxy->image, image, image_extra); } static cairo_status_t proxy_finish (void *abstract_surface) { return CAIRO_STATUS_SUCCESS; } static const cairo_surface_backend_t proxy_backend = { CAIRO_INTERNAL_SURFACE_TYPE_NULL, proxy_finish, NULL, NULL, /* create similar */ NULL, /* create similar image */ NULL, /* map to image */ NULL, /* unmap image */ _cairo_surface_default_source, proxy_acquire_source_image, proxy_release_source_image, }; static cairo_surface_t * attach_proxy (cairo_surface_t *source, cairo_surface_t *image) { struct proxy *proxy; proxy = _cairo_malloc (sizeof (*proxy)); if (unlikely (proxy == NULL)) return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); _cairo_surface_init (&proxy->base, &proxy_backend, NULL, image->content, FALSE); proxy->image = image; _cairo_surface_attach_snapshot (source, &proxy->base, NULL); return &proxy->base; } static void detach_proxy (cairo_surface_t *source, cairo_surface_t *proxy) { cairo_surface_finish (proxy); cairo_surface_destroy (proxy); } static cairo_surface_t * get_proxy (cairo_surface_t *proxy) { return ((struct proxy *)proxy)->image; } static cairo_status_t _cairo_recording_surface_acquire_source_image (void *abstract_surface, cairo_image_surface_t **image_out, void **image_extra) { cairo_recording_surface_t *surface = abstract_surface; cairo_surface_t *image, *proxy; cairo_status_t status; proxy = _cairo_surface_has_snapshot (abstract_surface, &proxy_backend); if (proxy != NULL) { *image_out = (cairo_image_surface_t *) cairo_surface_reference (get_proxy (proxy)); *image_extra = NULL; return CAIRO_STATUS_SUCCESS; } if (surface->unbounded) return CAIRO_INT_STATUS_UNSUPPORTED; image = _cairo_image_surface_create_with_content (surface->base.content, surface->extents.width, surface->extents.height); cairo_surface_set_device_offset (image, -surface->extents.x, -surface->extents.y); if (unlikely (image->status)) return image->status; cairo_surface_set_device_offset(image, -surface->extents.x, -surface->extents.y); /* Handle recursion by returning future reads from the current image */ proxy = attach_proxy (abstract_surface, image); status = _cairo_recording_surface_replay (&surface->base, image); detach_proxy (abstract_surface, proxy); if (unlikely (status)) { cairo_surface_destroy (image); return status; } *image_out = (cairo_image_surface_t *) image; *image_extra = NULL; return CAIRO_STATUS_SUCCESS; } static void _cairo_recording_surface_release_source_image (void *abstract_surface, cairo_image_surface_t *image, void *image_extra) { cairo_surface_destroy (&image->base); } static cairo_status_t _command_init (cairo_recording_surface_t *surface, cairo_command_header_t *command, cairo_command_type_t type, cairo_operator_t op, cairo_composite_rectangles_t *composite) { cairo_status_t status = CAIRO_STATUS_SUCCESS; command->type = type; command->op = op; command->extents = composite ? composite->unbounded : _cairo_empty_rectangle; command->chain = NULL; command->index = surface->commands.num_elements; /* steal the clip */ command->clip = NULL; if (composite && ! _cairo_composite_rectangles_can_reduce_clip (composite, composite->clip)) { command->clip = composite->clip; composite->clip = NULL; } return status; } static void _cairo_recording_surface_break_self_copy_loop (cairo_recording_surface_t *surface) { cairo_surface_flush (&surface->base); } static cairo_status_t _cairo_recording_surface_commit (cairo_recording_surface_t *surface, cairo_command_header_t *command) { _cairo_recording_surface_break_self_copy_loop (surface); return _cairo_array_append (&surface->commands, &command); } static void _cairo_recording_surface_reset (cairo_recording_surface_t *surface) { /* Reset the commands and temporaries */ _cairo_recording_surface_finish (surface); surface->bbtree.left = surface->bbtree.right = NULL; surface->bbtree.chain = INVALID_CHAIN; surface->indices = NULL; surface->num_indices = 0; _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); } static cairo_int_status_t _cairo_recording_surface_paint (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { cairo_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_paint_t *command; cairo_composite_rectangles_t composite; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); if (op == CAIRO_OPERATOR_CLEAR && clip == NULL) { if (surface->optimize_clears) { _cairo_recording_surface_reset (surface); return CAIRO_STATUS_SUCCESS; } } if (clip == NULL && surface->optimize_clears && (op == CAIRO_OPERATOR_SOURCE || (op == CAIRO_OPERATOR_OVER && (surface->base.is_clear || _cairo_pattern_is_opaque_solid (source))))) { _cairo_recording_surface_reset (surface); } status = _cairo_composite_rectangles_init_for_paint (&composite, &surface->base, op, source, clip); if (unlikely (status)) return status; command = _cairo_malloc (sizeof (cairo_command_paint_t)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMPOSITE; } status = _command_init (surface, &command->header, CAIRO_COMMAND_PAINT, op, &composite); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->source.base, source); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_SOURCE; _cairo_recording_surface_destroy_bbtree (surface); _cairo_composite_rectangles_fini (&composite); return CAIRO_STATUS_SUCCESS; CLEANUP_SOURCE: _cairo_pattern_fini (&command->source.base); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); CLEANUP_COMPOSITE: _cairo_composite_rectangles_fini (&composite); return status; } static cairo_int_status_t _cairo_recording_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_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_mask_t *command; cairo_composite_rectangles_t composite; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); status = _cairo_composite_rectangles_init_for_mask (&composite, &surface->base, op, source, mask, clip); if (unlikely (status)) return status; command = _cairo_malloc (sizeof (cairo_command_mask_t)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMPOSITE; } status = _command_init (surface, &command->header, CAIRO_COMMAND_MASK, op, &composite); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->source.base, source); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->mask.base, mask); if (unlikely (status)) goto CLEANUP_SOURCE; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_MASK; _cairo_recording_surface_destroy_bbtree (surface); _cairo_composite_rectangles_fini (&composite); return CAIRO_STATUS_SUCCESS; CLEANUP_MASK: _cairo_pattern_fini (&command->mask.base); CLEANUP_SOURCE: _cairo_pattern_fini (&command->source.base); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); CLEANUP_COMPOSITE: _cairo_composite_rectangles_fini (&composite); return status; } static cairo_int_status_t _cairo_recording_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_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_stroke_t *command; cairo_composite_rectangles_t composite; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); status = _cairo_composite_rectangles_init_for_stroke (&composite, &surface->base, op, source, path, style, ctm, clip); if (unlikely (status)) return status; command = _cairo_malloc (sizeof (cairo_command_stroke_t)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMPOSITE; } status = _command_init (surface, &command->header, CAIRO_COMMAND_STROKE, op, &composite); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->source.base, source); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_path_fixed_init_copy (&command->path, path); if (unlikely (status)) goto CLEANUP_SOURCE; status = _cairo_stroke_style_init_copy (&command->style, style); if (unlikely (status)) goto CLEANUP_PATH; command->ctm = *ctm; command->ctm_inverse = *ctm_inverse; command->tolerance = tolerance; command->antialias = antialias; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_STYLE; _cairo_recording_surface_destroy_bbtree (surface); _cairo_composite_rectangles_fini (&composite); return CAIRO_STATUS_SUCCESS; CLEANUP_STYLE: _cairo_stroke_style_fini (&command->style); CLEANUP_PATH: _cairo_path_fixed_fini (&command->path); CLEANUP_SOURCE: _cairo_pattern_fini (&command->source.base); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); CLEANUP_COMPOSITE: _cairo_composite_rectangles_fini (&composite); return status; } static cairo_int_status_t _cairo_recording_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_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_fill_t *command; cairo_composite_rectangles_t composite; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); status = _cairo_composite_rectangles_init_for_fill (&composite, &surface->base, op, source, path, clip); if (unlikely (status)) return status; command = _cairo_malloc (sizeof (cairo_command_fill_t)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMPOSITE; } status =_command_init (surface, &command->header, CAIRO_COMMAND_FILL, op, &composite); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->source.base, source); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_path_fixed_init_copy (&command->path, path); if (unlikely (status)) goto CLEANUP_SOURCE; command->fill_rule = fill_rule; command->tolerance = tolerance; command->antialias = antialias; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_PATH; _cairo_recording_surface_destroy_bbtree (surface); _cairo_composite_rectangles_fini (&composite); return CAIRO_STATUS_SUCCESS; CLEANUP_PATH: _cairo_path_fixed_fini (&command->path); CLEANUP_SOURCE: _cairo_pattern_fini (&command->source.base); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); CLEANUP_COMPOSITE: _cairo_composite_rectangles_fini (&composite); return status; } static cairo_bool_t _cairo_recording_surface_has_show_text_glyphs (void *abstract_surface) { return TRUE; } static cairo_int_status_t _cairo_recording_surface_show_text_glyphs (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const char *utf8, int utf8_len, cairo_glyph_t *glyphs, int num_glyphs, const cairo_text_cluster_t *clusters, int num_clusters, cairo_text_cluster_flags_t cluster_flags, cairo_scaled_font_t *scaled_font, const cairo_clip_t *clip) { cairo_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_show_text_glyphs_t *command; cairo_composite_rectangles_t composite; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); status = _cairo_composite_rectangles_init_for_glyphs (&composite, &surface->base, op, source, scaled_font, glyphs, num_glyphs, clip, NULL); if (unlikely (status)) return status; command = _cairo_malloc (sizeof (cairo_command_show_text_glyphs_t)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMPOSITE; } status = _command_init (surface, &command->header, CAIRO_COMMAND_SHOW_TEXT_GLYPHS, op, &composite); if (unlikely (status)) goto CLEANUP_COMMAND; status = _cairo_pattern_init_snapshot (&command->source.base, source); if (unlikely (status)) goto CLEANUP_COMMAND; command->utf8 = NULL; command->utf8_len = utf8_len; command->glyphs = NULL; command->num_glyphs = num_glyphs; command->clusters = NULL; command->num_clusters = num_clusters; if (utf8_len) { command->utf8 = _cairo_malloc (utf8_len); if (unlikely (command->utf8 == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_ARRAYS; } memcpy (command->utf8, utf8, utf8_len); } if (num_glyphs) { command->glyphs = _cairo_malloc_ab (num_glyphs, sizeof (glyphs[0])); if (unlikely (command->glyphs == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_ARRAYS; } memcpy (command->glyphs, glyphs, sizeof (glyphs[0]) * num_glyphs); } if (num_clusters) { command->clusters = _cairo_malloc_ab (num_clusters, sizeof (clusters[0])); if (unlikely (command->clusters == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_ARRAYS; } memcpy (command->clusters, clusters, sizeof (clusters[0]) * num_clusters); } command->cluster_flags = cluster_flags; command->scaled_font = cairo_scaled_font_reference (scaled_font); status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_SCALED_FONT; _cairo_composite_rectangles_fini (&composite); return CAIRO_STATUS_SUCCESS; CLEANUP_SCALED_FONT: cairo_scaled_font_destroy (command->scaled_font); CLEANUP_ARRAYS: free (command->utf8); free (command->glyphs); free (command->clusters); _cairo_pattern_fini (&command->source.base); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); CLEANUP_COMPOSITE: _cairo_composite_rectangles_fini (&composite); return status; } static cairo_int_status_t _cairo_recording_surface_tag (void *abstract_surface, cairo_bool_t begin, const char *tag_name, const char *attributes) { cairo_status_t status; cairo_recording_surface_t *surface = abstract_surface; cairo_command_tag_t *command; TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id)); surface->has_tags = TRUE; command = calloc (1, sizeof (cairo_command_tag_t)); if (unlikely (command == NULL)) { return _cairo_error (CAIRO_STATUS_NO_MEMORY); } status = _command_init (surface, &command->header, CAIRO_COMMAND_TAG, CAIRO_OPERATOR_SOURCE, NULL); if (unlikely (status)) goto CLEANUP_COMMAND; command->begin = begin; command->tag_name = strdup (tag_name); if (unlikely (command->tag_name == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_COMMAND; } if (begin) { if (attributes) { command->attributes = strdup (attributes); if (unlikely (command->attributes == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto CLEANUP_STRINGS; } } } status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto CLEANUP_STRINGS; _cairo_recording_surface_destroy_bbtree (surface); return CAIRO_STATUS_SUCCESS; CLEANUP_STRINGS: free (command->tag_name); free (command->attributes); CLEANUP_COMMAND: _cairo_clip_destroy (command->header.clip); free (command); return status; } static cairo_bool_t _cairo_recording_surface_supports_color_glyph (void *abstract_surface, cairo_scaled_font_t *scaled_font, unsigned long glyph_index) { return TRUE; } static void _command_init_copy (cairo_recording_surface_t *surface, cairo_command_header_t *dst, const cairo_command_header_t *src) { dst->type = src->type; dst->op = src->op; dst->extents = src->extents; dst->chain = NULL; dst->index = surface->commands.num_elements; dst->clip = _cairo_clip_copy (src->clip); } static cairo_status_t _cairo_recording_surface_copy__paint (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_paint_t *command; cairo_status_t status; command = _cairo_malloc (sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); status = _cairo_pattern_init_copy (&command->source.base, &src->paint.source.base); if (unlikely (status)) goto err_command; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_source; return CAIRO_STATUS_SUCCESS; err_source: _cairo_pattern_fini (&command->source.base); err_command: free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy__mask (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_mask_t *command; cairo_status_t status; command = _cairo_malloc (sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); status = _cairo_pattern_init_copy (&command->source.base, &src->mask.source.base); if (unlikely (status)) goto err_command; status = _cairo_pattern_init_copy (&command->mask.base, &src->mask.mask.base); if (unlikely (status)) goto err_source; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_mask; return CAIRO_STATUS_SUCCESS; err_mask: _cairo_pattern_fini (&command->mask.base); err_source: _cairo_pattern_fini (&command->source.base); err_command: free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy__stroke (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_stroke_t *command; cairo_status_t status; command = _cairo_malloc (sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); status = _cairo_pattern_init_copy (&command->source.base, &src->stroke.source.base); if (unlikely (status)) goto err_command; status = _cairo_path_fixed_init_copy (&command->path, &src->stroke.path); if (unlikely (status)) goto err_source; status = _cairo_stroke_style_init_copy (&command->style, &src->stroke.style); if (unlikely (status)) goto err_path; command->ctm = src->stroke.ctm; command->ctm_inverse = src->stroke.ctm_inverse; command->tolerance = src->stroke.tolerance; command->antialias = src->stroke.antialias; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_style; return CAIRO_STATUS_SUCCESS; err_style: _cairo_stroke_style_fini (&command->style); err_path: _cairo_path_fixed_fini (&command->path); err_source: _cairo_pattern_fini (&command->source.base); err_command: free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy__fill (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_fill_t *command; cairo_status_t status; command = _cairo_malloc (sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); status = _cairo_pattern_init_copy (&command->source.base, &src->fill.source.base); if (unlikely (status)) goto err_command; status = _cairo_path_fixed_init_copy (&command->path, &src->fill.path); if (unlikely (status)) goto err_source; command->fill_rule = src->fill.fill_rule; command->tolerance = src->fill.tolerance; command->antialias = src->fill.antialias; status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_path; return CAIRO_STATUS_SUCCESS; err_path: _cairo_path_fixed_fini (&command->path); err_source: _cairo_pattern_fini (&command->source.base); err_command: free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy__glyphs (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_show_text_glyphs_t *command; cairo_status_t status; command = _cairo_malloc (sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); status = _cairo_pattern_init_copy (&command->source.base, &src->show_text_glyphs.source.base); if (unlikely (status)) goto err_command; command->utf8 = NULL; command->utf8_len = src->show_text_glyphs.utf8_len; command->glyphs = NULL; command->num_glyphs = src->show_text_glyphs.num_glyphs; command->clusters = NULL; command->num_clusters = src->show_text_glyphs.num_clusters; if (command->utf8_len) { command->utf8 = _cairo_malloc (command->utf8_len); if (unlikely (command->utf8 == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err_arrays; } memcpy (command->utf8, src->show_text_glyphs.utf8, command->utf8_len); } if (command->num_glyphs) { command->glyphs = _cairo_malloc_ab (command->num_glyphs, sizeof (command->glyphs[0])); if (unlikely (command->glyphs == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err_arrays; } memcpy (command->glyphs, src->show_text_glyphs.glyphs, sizeof (command->glyphs[0]) * command->num_glyphs); } if (command->num_clusters) { command->clusters = _cairo_malloc_ab (command->num_clusters, sizeof (command->clusters[0])); if (unlikely (command->clusters == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err_arrays; } memcpy (command->clusters, src->show_text_glyphs.clusters, sizeof (command->clusters[0]) * command->num_clusters); } command->cluster_flags = src->show_text_glyphs.cluster_flags; command->scaled_font = cairo_scaled_font_reference (src->show_text_glyphs.scaled_font); status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_arrays; return CAIRO_STATUS_SUCCESS; err_arrays: free (command->utf8); free (command->glyphs); free (command->clusters); _cairo_pattern_fini (&command->source.base); err_command: free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy__tag (cairo_recording_surface_t *surface, const cairo_command_t *src) { cairo_command_tag_t *command; cairo_status_t status; command = calloc (1, sizeof (*command)); if (unlikely (command == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err; } _command_init_copy (surface, &command->header, &src->header); command->begin = src->tag.begin; command->tag_name = strdup (src->tag.tag_name); if (unlikely (command->tag_name == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err_command; } if (src->tag.begin) { if (src->tag.attributes) { command->attributes = strdup (src->tag.attributes); if (unlikely (command->attributes == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto err_command; } } } status = _cairo_recording_surface_commit (surface, &command->header); if (unlikely (status)) goto err_command; return CAIRO_STATUS_SUCCESS; err_command: free(command->tag_name); free(command->attributes); free(command); err: return status; } static cairo_status_t _cairo_recording_surface_copy (cairo_recording_surface_t *dst, cairo_recording_surface_t *src) { cairo_command_t **elements; int i, num_elements; cairo_status_t status; elements = _cairo_array_index (&src->commands, 0); num_elements = src->commands.num_elements; for (i = 0; i < num_elements; i++) { const cairo_command_t *command = elements[i]; switch (command->header.type) { case CAIRO_COMMAND_PAINT: status = _cairo_recording_surface_copy__paint (dst, command); break; case CAIRO_COMMAND_MASK: status = _cairo_recording_surface_copy__mask (dst, command); break; case CAIRO_COMMAND_STROKE: status = _cairo_recording_surface_copy__stroke (dst, command); break; case CAIRO_COMMAND_FILL: status = _cairo_recording_surface_copy__fill (dst, command); break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: status = _cairo_recording_surface_copy__glyphs (dst, command); break; case CAIRO_COMMAND_TAG: status = _cairo_recording_surface_copy__tag (dst, command); break; default: ASSERT_NOT_REACHED; } if (unlikely (status)) return status; } return CAIRO_STATUS_SUCCESS; } /** * _cairo_recording_surface_snapshot: * @surface: a #cairo_surface_t which must be a recording surface * * Make an immutable copy of @surface. It is an error to call a * surface-modifying function on the result of this function. * * The caller owns the return value and should call * cairo_surface_destroy() when finished with it. This function will not * return %NULL, but will return a nil surface instead. * * Return value: The snapshot surface. **/ static cairo_surface_t * _cairo_recording_surface_snapshot (void *abstract_other) { cairo_recording_surface_t *other = abstract_other; cairo_recording_surface_t *surface; cairo_status_t status; surface = _cairo_malloc (sizeof (cairo_recording_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); _cairo_surface_init (&surface->base, &cairo_recording_surface_backend, NULL, /* device */ other->base.content, other->base.is_vector); surface->extents_pixels = other->extents_pixels; surface->extents = other->extents; surface->unbounded = other->unbounded; surface->has_bilevel_alpha = other->has_bilevel_alpha; surface->has_only_op_over = other->has_only_op_over; surface->has_tags = other->has_tags; surface->base.is_clear = other->base.is_clear; surface->bbtree.left = surface->bbtree.right = NULL; surface->bbtree.chain = INVALID_CHAIN; surface->indices = NULL; surface->num_indices = 0; surface->optimize_clears = TRUE; CAIRO_MUTEX_INIT (surface->mutex); cairo_list_init (&surface->region_array_list); _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); status = _cairo_recording_surface_copy (surface, other); if (unlikely (status)) { cairo_surface_destroy (&surface->base); return _cairo_surface_create_in_error (status); } return &surface->base; } static cairo_bool_t _cairo_recording_surface_get_extents (void *abstract_surface, cairo_rectangle_int_t *rectangle) { cairo_recording_surface_t *surface = abstract_surface; if (surface->unbounded) return FALSE; *rectangle = surface->extents; return TRUE; } static const cairo_surface_backend_t cairo_recording_surface_backend = { CAIRO_SURFACE_TYPE_RECORDING, _cairo_recording_surface_finish, _cairo_default_context_create, _cairo_recording_surface_create_similar, NULL, /* create similar image */ NULL, /* map to image */ NULL, /* unmap image */ _cairo_surface_default_source, _cairo_recording_surface_acquire_source_image, _cairo_recording_surface_release_source_image, _cairo_recording_surface_snapshot, NULL, /* copy_page */ NULL, /* show_page */ _cairo_recording_surface_get_extents, NULL, /* get_font_options */ NULL, /* flush */ NULL, /* mark_dirty_rectangle */ /* Here are the 5 basic drawing operations, (which are in some * sense the only things that cairo_recording_surface should need to * implement). However, we implement the more generic show_text_glyphs * instead of show_glyphs. One or the other is eough. */ _cairo_recording_surface_paint, _cairo_recording_surface_mask, _cairo_recording_surface_stroke, _cairo_recording_surface_fill, NULL, /* fill-stroke */ NULL, _cairo_recording_surface_has_show_text_glyphs, _cairo_recording_surface_show_text_glyphs, NULL, /* get_supported_mime_types */ _cairo_recording_surface_tag, _cairo_recording_surface_supports_color_glyph, NULL, /* analyze_recording_surface */ NULL, /* command_id */ }; static unsigned int _cairo_recording_surface_regions_allocate_unique_id (void) { static cairo_atomic_int_t unique_id; #if CAIRO_NO_MUTEX if (++unique_id == 0) unique_id = 1; return unique_id; #else cairo_atomic_int_t old, id; do { old = _cairo_atomic_uint_get (&unique_id); id = old + 1; if (id == 0) id = 1; } while (! _cairo_atomic_uint_cmpxchg (&unique_id, old, id)); return id; #endif } static cairo_recording_regions_array_t * _cairo_recording_surface_region_array_find (cairo_recording_surface_t *surface, unsigned int id) { cairo_recording_regions_array_t *regions; cairo_list_foreach_entry (regions, cairo_recording_regions_array_t, &surface->region_array_list, link) { if (regions->id == id) return regions; } return NULL; } /* Create and initialize a new #cairo_recording_regions_array_t. Attach * it to the recording surface and return its id */ cairo_status_t _cairo_recording_surface_region_array_attach (cairo_surface_t *abstract_surface, unsigned int *id) { cairo_recording_regions_array_t *region_array; cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface; assert (_cairo_surface_is_recording (abstract_surface)); region_array = _cairo_malloc (sizeof (cairo_recording_regions_array_t)); if (region_array == NULL) { *id = 0; return _cairo_error (CAIRO_STATUS_NO_MEMORY); } region_array->id = _cairo_recording_surface_regions_allocate_unique_id (); CAIRO_REFERENCE_COUNT_INIT (®ion_array->ref_count, 1); _cairo_array_init (®ion_array->regions, sizeof (cairo_recording_region_element_t)); CAIRO_MUTEX_LOCK (surface->mutex); cairo_list_add (®ion_array->link, &surface->region_array_list); CAIRO_MUTEX_UNLOCK (surface->mutex); *id = region_array->id; return CAIRO_STATUS_SUCCESS; } void _cairo_recording_surface_region_array_remove (cairo_surface_t *abstract_surface, unsigned int id) { cairo_recording_regions_array_t *region_array; cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface; if (id == 0) return; assert (_cairo_surface_is_recording (abstract_surface)); CAIRO_MUTEX_LOCK (surface->mutex); region_array = _cairo_recording_surface_region_array_find (surface, id); if (region_array) { if (_cairo_reference_count_dec_and_test (®ion_array->ref_count)) cairo_list_del (®ion_array->link); else region_array = NULL; } CAIRO_MUTEX_UNLOCK (surface->mutex); if (region_array) _cairo_recording_surface_region_array_destroy (surface, region_array); } void _cairo_recording_surface_region_array_reference (cairo_surface_t *abstract_surface, unsigned int id) { cairo_recording_regions_array_t *region_array; cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface; assert (_cairo_surface_is_recording (abstract_surface)); CAIRO_MUTEX_LOCK (surface->mutex); region_array = _cairo_recording_surface_region_array_find (surface, id); if (region_array) { _cairo_reference_count_inc (®ion_array->ref_count); } CAIRO_MUTEX_UNLOCK (surface->mutex); } cairo_int_status_t _cairo_recording_surface_get_path (cairo_surface_t *abstract_surface, cairo_path_fixed_t *path) { cairo_recording_surface_t *surface; cairo_command_t **elements; int i, num_elements; cairo_int_status_t status; if (unlikely (abstract_surface->status)) return abstract_surface->status; surface = (cairo_recording_surface_t *) abstract_surface; status = CAIRO_STATUS_SUCCESS; num_elements = surface->commands.num_elements; elements = _cairo_array_index (&surface->commands, 0); for (i = 0; i < num_elements; i++) { cairo_command_t *command = elements[i]; switch (command->header.type) { case CAIRO_COMMAND_PAINT: case CAIRO_COMMAND_MASK: status = CAIRO_INT_STATUS_UNSUPPORTED; break; case CAIRO_COMMAND_STROKE: { cairo_traps_t traps; _cairo_traps_init (&traps); /* XXX call cairo_stroke_to_path() when that is implemented */ status = _cairo_path_fixed_stroke_polygon_to_traps (&command->stroke.path, &command->stroke.style, &command->stroke.ctm, &command->stroke.ctm_inverse, command->stroke.tolerance, &traps); if (status == CAIRO_INT_STATUS_SUCCESS) status = _cairo_traps_path (&traps, path); _cairo_traps_fini (&traps); break; } case CAIRO_COMMAND_FILL: { status = _cairo_path_fixed_append (path, &command->fill.path, 0, 0); break; } case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: { status = _cairo_scaled_font_glyph_path (command->show_text_glyphs.scaled_font, command->show_text_glyphs.glyphs, command->show_text_glyphs.num_glyphs, path); break; } case CAIRO_COMMAND_TAG: break; default: ASSERT_NOT_REACHED; } if (unlikely (status)) break; } return status; } static int _cairo_recording_surface_get_visible_commands (cairo_recording_surface_t *surface, const cairo_rectangle_int_t *extents) { unsigned int num_visible, *indices; cairo_box_t box; if (surface->commands.num_elements == 0) return 0; _cairo_box_from_rectangle (&box, extents); if (surface->bbtree.chain == INVALID_CHAIN) _cairo_recording_surface_create_bbtree (surface); indices = surface->indices; bbtree_foreach_mark_visible (&surface->bbtree, &box, &indices); num_visible = indices - surface->indices; if (num_visible > 1) sort_indices (surface->indices, num_visible); return num_visible; } static void _cairo_recording_surface_merge_source_attributes (cairo_recording_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source) { if (op != CAIRO_OPERATOR_OVER) surface->has_only_op_over = FALSE; if (source->type == CAIRO_PATTERN_TYPE_SURFACE) { cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) source; cairo_surface_t *surf = surf_pat->surface; cairo_surface_t *free_me = NULL; if (_cairo_surface_is_snapshot (surf)) free_me = surf = _cairo_surface_snapshot_get_target (surf); if (unlikely (surf->status)) // There was some kind of error and the surface could be a nil error // surface with various "problems" (e.g. ->backend == NULL). return; if (surf->type == CAIRO_SURFACE_TYPE_RECORDING) { cairo_recording_surface_t *rec_surf = (cairo_recording_surface_t *) surf; if (! _cairo_recording_surface_has_only_bilevel_alpha (rec_surf)) surface->has_bilevel_alpha = FALSE; if (! _cairo_recording_surface_has_only_op_over (rec_surf)) surface->has_only_op_over = FALSE; } else if (surf->type == CAIRO_SURFACE_TYPE_IMAGE) { cairo_image_surface_t *img_surf = (cairo_image_surface_t *) surf; if (_cairo_image_analyze_transparency (img_surf) == CAIRO_IMAGE_HAS_ALPHA) surface->has_bilevel_alpha = FALSE; } else { if (!_cairo_pattern_is_clear (source) && !_cairo_pattern_is_opaque (source, NULL)) surface->has_bilevel_alpha = FALSE; } cairo_surface_destroy (free_me); return; } else if (source->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) { cairo_surface_t *image; cairo_surface_t *raster; image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1); raster = _cairo_raster_source_pattern_acquire (source, image, NULL); cairo_surface_destroy (image); if (raster) { if (raster->type == CAIRO_SURFACE_TYPE_IMAGE) { if (_cairo_image_analyze_transparency ((cairo_image_surface_t *)raster) == CAIRO_IMAGE_HAS_ALPHA) surface->has_bilevel_alpha = FALSE; } _cairo_raster_source_pattern_release (source, raster); if (raster->type == CAIRO_SURFACE_TYPE_IMAGE) return; } } if (!_cairo_pattern_is_clear (source) && !_cairo_pattern_is_opaque (source, NULL)) surface->has_bilevel_alpha = FALSE; } static cairo_status_t _cairo_recording_surface_replay_internal (cairo_recording_surface_t *surface, cairo_recording_surface_replay_params_t *params) { cairo_surface_wrapper_t wrapper; cairo_command_t **elements; cairo_recording_regions_array_t *regions_array = NULL; cairo_recording_region_element_t *region_elements = NULL; cairo_int_status_t status = CAIRO_STATUS_SUCCESS; cairo_rectangle_int_t extents; cairo_bool_t use_indices = FALSE; const cairo_rectangle_int_t *r; unsigned int i, num_elements; if (unlikely (surface->base.status)) return surface->base.status; if (unlikely (params->target->status)) return params->target->status; if (unlikely (surface->base.finished)) return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); if (surface->base.is_clear) return CAIRO_STATUS_SUCCESS; assert (_cairo_surface_is_recording (&surface->base)); if (params->regions_id != 0) { regions_array = _cairo_recording_surface_region_array_find (surface, params->regions_id); assert (regions_array != NULL); } _cairo_surface_wrapper_init (&wrapper, params->target); if (params->surface_extents) _cairo_surface_wrapper_intersect_extents (&wrapper, params->surface_extents); r = &_cairo_unbounded_rectangle; if (! surface->unbounded && !params->surface_is_unbounded) { _cairo_surface_wrapper_intersect_extents (&wrapper, &surface->extents); r = &surface->extents; } _cairo_surface_wrapper_set_inverse_transform (&wrapper, params->surface_transform); _cairo_surface_wrapper_set_clip (&wrapper, params->target_clip); if (params->foreground_color) { params->target->foreground_source = _cairo_pattern_create_solid (params->foreground_color); params->target->foreground_used = FALSE; } /* Compute the extents of the target clip in recorded device space */ if (! _cairo_surface_wrapper_get_target_extents (&wrapper, params->surface_is_unbounded, &extents)) goto done; surface->has_bilevel_alpha = TRUE; surface->has_only_op_over = TRUE; num_elements = surface->commands.num_elements; if (regions_array) { if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { /* Re-running create regions with the same region id is not supported. */ assert (_cairo_array_num_elements (®ions_array->regions) == 0); void *array_elems; status = _cairo_array_allocate (®ions_array->regions, num_elements, &array_elems); if (unlikely (status)) return status; /* Set regions to CAIRO_RECORDING_REGION_ALL and ids to 0 */ memset (array_elems, 0, num_elements * sizeof (cairo_recording_region_element_t)); } else { assert (_cairo_array_num_elements (®ions_array->regions) == num_elements); } } elements = _cairo_array_index (&surface->commands, 0); if (regions_array) region_elements = _cairo_array_index (®ions_array->regions, 0); if (!params->replay_all && (extents.width < r->width || extents.height < r->height)) { num_elements = _cairo_recording_surface_get_visible_commands (surface, &extents); use_indices = num_elements != surface->commands.num_elements; } cairo_bool_t target_is_analysis = _cairo_surface_is_analysis (params->target); for (i = 0; i < num_elements; i++) { cairo_command_t *command = elements[use_indices ? surface->indices[i] : i]; cairo_recording_region_element_t *region_element = NULL; unsigned int source_region_id = 0; unsigned int mask_region_id = 0; if (region_elements) region_element = ®ion_elements[use_indices ? surface->indices[i] : i]; if (region_element && params->type == CAIRO_RECORDING_REPLAY_REGION && region_element->region != params->region) { continue; } if (! _cairo_rectangle_intersects (&extents, &command->header.extents)) { if (command->header.type != CAIRO_COMMAND_TAG) continue; } if (params->target->backend->command_id) { status = params->target->backend->command_id (params->target, params->regions_id, i); if (unlikely (status)) return status; } switch (command->header.type) { case CAIRO_COMMAND_PAINT: if (region_element) source_region_id = region_element->source_id; status = _cairo_surface_wrapper_paint (&wrapper, command->header.op, &command->paint.source.base, source_region_id, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->paint.source.base); if (region_element && target_is_analysis) region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target); } break; case CAIRO_COMMAND_MASK: if (region_element) { source_region_id = region_element->source_id; mask_region_id = region_element->mask_id; } status = _cairo_surface_wrapper_mask (&wrapper, command->header.op, &command->mask.source.base, source_region_id, &command->mask.mask.base, mask_region_id, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->mask.source.base); _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->mask.mask.base); if (region_element && target_is_analysis) { region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target); region_element->mask_id = _cairo_analysis_surface_get_mask_region_id (params->target); } } break; case CAIRO_COMMAND_STROKE: if (region_element) source_region_id = region_element->source_id; status = _cairo_surface_wrapper_stroke (&wrapper, command->header.op, &command->stroke.source.base, source_region_id, &command->stroke.path, &command->stroke.style, &command->stroke.ctm, &command->stroke.ctm_inverse, command->stroke.tolerance, command->stroke.antialias, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->stroke.source.base); if (region_element && target_is_analysis) region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target); } break; case CAIRO_COMMAND_FILL: status = CAIRO_INT_STATUS_UNSUPPORTED; if (region_element) source_region_id = region_element->source_id; if (_cairo_surface_wrapper_has_fill_stroke (&wrapper)) { cairo_command_t *stroke_command = NULL; cairo_recording_region_element_t *stroke_region_element = NULL; unsigned stroke_region_id = 0; /* The analysis surface does not implement * fill_stroke. When creating regions the fill and * stroke commands are tested separately. */ if (params->type != CAIRO_RECORDING_CREATE_REGIONS && i < num_elements - 1) { stroke_command = elements[i + 1]; if (region_elements) stroke_region_element = ®ion_elements[i + 1]; } if (stroke_region_element) stroke_region_id = stroke_region_element->source_id; if (stroke_command && stroke_region_element && params->type == CAIRO_RECORDING_REPLAY_REGION && params->region != CAIRO_RECORDING_REGION_ALL) { if (stroke_region_element->region != params->region) stroke_command = NULL; } if (stroke_command != NULL && stroke_command->header.type == CAIRO_COMMAND_STROKE && _cairo_path_fixed_equal (&command->fill.path, &stroke_command->stroke.path) && _cairo_clip_equal (command->header.clip, stroke_command->header.clip)) { status = _cairo_surface_wrapper_fill_stroke (&wrapper, command->header.op, &command->fill.source.base, source_region_id, command->fill.fill_rule, command->fill.tolerance, command->fill.antialias, &command->fill.path, stroke_command->header.op, &stroke_command->stroke.source.base, stroke_region_id, &stroke_command->stroke.style, &stroke_command->stroke.ctm, &stroke_command->stroke.ctm_inverse, stroke_command->stroke.tolerance, stroke_command->stroke.antialias, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->fill.source.base); _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->stroke.source.base); } i++; } } if (status == CAIRO_INT_STATUS_UNSUPPORTED) { status = _cairo_surface_wrapper_fill (&wrapper, command->header.op, &command->fill.source.base, source_region_id, &command->fill.path, command->fill.fill_rule, command->fill.tolerance, command->fill.antialias, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->fill.source.base); if (region_element && target_is_analysis) region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target); } } break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: if (region_element) source_region_id = region_element->source_id; status = _cairo_surface_wrapper_show_text_glyphs (&wrapper, command->header.op, &command->show_text_glyphs.source.base, source_region_id, command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len, command->show_text_glyphs.glyphs, command->show_text_glyphs.num_glyphs, command->show_text_glyphs.clusters, command->show_text_glyphs.num_clusters, command->show_text_glyphs.cluster_flags, command->show_text_glyphs.scaled_font, command->header.clip); if (params->type == CAIRO_RECORDING_CREATE_REGIONS) { _cairo_recording_surface_merge_source_attributes (surface, command->header.op, &command->show_text_glyphs.source.base); if (region_element && target_is_analysis) region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target); } break; case CAIRO_COMMAND_TAG: status = _cairo_surface_wrapper_tag (&wrapper, command->tag.begin, command->tag.tag_name, command->tag.attributes); break; default: ASSERT_NOT_REACHED; } /* It's possible that a degenerate clip caused the command to end up doing nothing when replayed. */ if (unlikely (status == CAIRO_INT_STATUS_NOTHING_TO_DO)) status = CAIRO_INT_STATUS_SUCCESS; if (params->type == CAIRO_RECORDING_CREATE_REGIONS && region_element) { if (status == CAIRO_INT_STATUS_SUCCESS) { region_element->region = CAIRO_RECORDING_REGION_NATIVE; } else if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) { region_element->region = CAIRO_RECORDING_REGION_IMAGE_FALLBACK; status = CAIRO_INT_STATUS_SUCCESS; } else { assert (_cairo_int_status_is_error (status)); } } if (unlikely (status)) break; } done: if (params->foreground_color) { cairo_pattern_destroy (params->target->foreground_source); params->target->foreground_source = NULL; params->foreground_used = params->target->foreground_used; } _cairo_surface_wrapper_fini (&wrapper); return _cairo_surface_set_error (&surface->base, status); } cairo_status_t _cairo_recording_surface_replay_one (cairo_recording_surface_t *surface, long unsigned index, cairo_surface_t *target) { cairo_surface_wrapper_t wrapper; cairo_command_t **elements, *command; cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS; if (unlikely (surface->base.status)) return surface->base.status; if (unlikely (target->status)) return target->status; if (unlikely (surface->base.finished)) return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); assert (_cairo_surface_is_recording (&surface->base)); /* XXX * Use a surface wrapper because we may want to do transformed * replay in the future. */ _cairo_surface_wrapper_init (&wrapper, target); if (index > surface->commands.num_elements) return _cairo_error (CAIRO_STATUS_READ_ERROR); elements = _cairo_array_index (&surface->commands, 0); command = elements[index]; switch (command->header.type) { case CAIRO_COMMAND_PAINT: status = _cairo_surface_wrapper_paint (&wrapper, command->header.op, &command->paint.source.base, 0, command->header.clip); break; case CAIRO_COMMAND_MASK: status = _cairo_surface_wrapper_mask (&wrapper, command->header.op, &command->mask.source.base, 0, &command->mask.mask.base, 0, command->header.clip); break; case CAIRO_COMMAND_STROKE: status = _cairo_surface_wrapper_stroke (&wrapper, command->header.op, &command->stroke.source.base, 0, &command->stroke.path, &command->stroke.style, &command->stroke.ctm, &command->stroke.ctm_inverse, command->stroke.tolerance, command->stroke.antialias, command->header.clip); break; case CAIRO_COMMAND_FILL: status = _cairo_surface_wrapper_fill (&wrapper, command->header.op, &command->fill.source.base, 0, &command->fill.path, command->fill.fill_rule, command->fill.tolerance, command->fill.antialias, command->header.clip); break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: status = _cairo_surface_wrapper_show_text_glyphs (&wrapper, command->header.op, &command->show_text_glyphs.source.base, 0, command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len, command->show_text_glyphs.glyphs, command->show_text_glyphs.num_glyphs, command->show_text_glyphs.clusters, command->show_text_glyphs.num_clusters, command->show_text_glyphs.cluster_flags, command->show_text_glyphs.scaled_font, command->header.clip); break; case CAIRO_COMMAND_TAG: status = _cairo_surface_wrapper_tag (&wrapper, command->tag.begin, command->tag.tag_name, command->tag.attributes); break; default: ASSERT_NOT_REACHED; } _cairo_surface_wrapper_fini (&wrapper); return _cairo_surface_set_error (&surface->base, status); } /** * _cairo_recording_surface_replay: * @surface: the #cairo_recording_surface_t * @target: a target #cairo_surface_t onto which to replay the operations * @width_pixels: width of the surface, in pixels * @height_pixels: height of the surface, in pixels * * A recording surface can be "replayed" against any target surface, * after which the results in target will be identical to the results * that would have been obtained if the original operations applied to * the recording surface had instead been applied to the target surface. **/ cairo_status_t _cairo_recording_surface_replay (cairo_surface_t *surface, cairo_surface_t *target) { cairo_recording_surface_replay_params_t params; params.surface_extents = NULL; params.surface_transform = NULL; params.target = target; params.target_clip = NULL; params.surface_is_unbounded = FALSE; params.type = CAIRO_RECORDING_REPLAY; params.region = CAIRO_RECORDING_REGION_ALL; params.regions_id = 0; params.foreground_color = NULL; params.replay_all = FALSE; return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); } cairo_status_t _cairo_recording_surface_replay_with_foreground_color (cairo_surface_t *surface, cairo_surface_t *target, const cairo_color_t *foreground_color, cairo_bool_t *foreground_used) { cairo_recording_surface_replay_params_t params; cairo_status_t status; params.surface_extents = NULL; params.surface_transform = NULL; params.target = target; params.target_clip = NULL; params.surface_is_unbounded = FALSE; params.type = CAIRO_RECORDING_REPLAY; params.region = CAIRO_RECORDING_REGION_ALL; params.regions_id = 0; params.foreground_color = foreground_color; params.foreground_used = FALSE; params.replay_all = FALSE; status = _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); *foreground_used = params.foreground_used; return status; } cairo_status_t _cairo_recording_surface_replay_with_transform (cairo_surface_t *surface, const cairo_matrix_t *surface_transform, cairo_surface_t *target, cairo_bool_t surface_is_unbounded, cairo_bool_t replay_all) { cairo_recording_surface_replay_params_t params; params.surface_extents = NULL; params.surface_transform = surface_transform; params.target = target; params.target_clip = NULL; params.surface_is_unbounded = surface_is_unbounded; params.type = CAIRO_RECORDING_REPLAY; params.region = CAIRO_RECORDING_REGION_ALL; params.regions_id = 0; params.foreground_color = NULL; params.replay_all = replay_all; return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); } cairo_status_t _cairo_recording_surface_replay_with_clip (cairo_surface_t *surface, const cairo_matrix_t *surface_transform, cairo_surface_t *target, const cairo_clip_t *target_clip) { cairo_recording_surface_replay_params_t params; params.surface_extents = NULL; params.surface_transform = surface_transform; params.target = target; params.target_clip = target_clip; params.surface_is_unbounded = FALSE; params.type = CAIRO_RECORDING_REPLAY; params.region = CAIRO_RECORDING_REGION_ALL; params.regions_id = 0; params.foreground_color = NULL; params.replay_all = FALSE; return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); } /* Replay recording to surface. When the return status of each operation is * one of %CAIRO_STATUS_SUCCESS, %CAIRO_INT_STATUS_UNSUPPORTED, or * %CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY the status of each operation * will be stored in the recording surface. Any other status will abort the * replay and return the status. */ cairo_status_t _cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface, unsigned int regions_id, const cairo_matrix_t *surface_transform, cairo_surface_t *target, cairo_bool_t surface_is_unbounded, cairo_bool_t replay_all) { cairo_recording_surface_replay_params_t params; params.surface_extents = NULL; params.surface_transform = surface_transform; params.target = target; params.target_clip = NULL; params.surface_is_unbounded = surface_is_unbounded; params.type = CAIRO_RECORDING_CREATE_REGIONS; params.region = CAIRO_RECORDING_REGION_ALL; params.regions_id = regions_id; params.foreground_color = NULL; params.replay_all = replay_all; return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); } cairo_status_t _cairo_recording_surface_replay_region (cairo_surface_t *surface, unsigned int regions_id, const cairo_rectangle_int_t *surface_extents, cairo_surface_t *target, cairo_recording_region_type_t region) { cairo_recording_surface_replay_params_t params; params.surface_extents = surface_extents; params.surface_transform = NULL; params.target = target; params.target_clip = NULL; params.surface_is_unbounded = FALSE; params.type = CAIRO_RECORDING_REPLAY_REGION; params.region = region; params.regions_id = regions_id; params.foreground_color = NULL; params.replay_all = FALSE; return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, ¶ms); } static cairo_status_t _recording_surface_get_ink_bbox (cairo_recording_surface_t *surface, cairo_box_t *bbox, const cairo_matrix_t *transform) { cairo_surface_t *null_surface; cairo_surface_t *analysis_surface; cairo_status_t status; null_surface = _cairo_null_surface_create (surface->base.content); analysis_surface = _cairo_analysis_surface_create (null_surface, FALSE); cairo_surface_destroy (null_surface); status = analysis_surface->status; if (unlikely (status)) return status; if (transform != NULL) _cairo_analysis_surface_set_ctm (analysis_surface, transform); status = _cairo_recording_surface_replay (&surface->base, analysis_surface); _cairo_analysis_surface_get_bounding_box (analysis_surface, bbox); cairo_surface_destroy (analysis_surface); return status; } /** * cairo_recording_surface_ink_extents: * @surface: a #cairo_recording_surface_t * @x0: the x-coordinate of the top-left of the ink bounding box * @y0: the y-coordinate of the top-left of the ink bounding box * @width: the width of the ink bounding box * @height: the height of the ink bounding box * * Measures the extents of the operations stored within the recording-surface. * This is useful to compute the required size of an image surface (or * equivalent) into which to replay the full sequence of drawing operations. * * Since: 1.10 **/ void cairo_recording_surface_ink_extents (cairo_surface_t *surface, double *x0, double *y0, double *width, double *height) { cairo_status_t status; cairo_box_t bbox; memset (&bbox, 0, sizeof (bbox)); if (surface->status || ! _cairo_surface_is_recording (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); goto DONE; } status = _recording_surface_get_ink_bbox ((cairo_recording_surface_t *) surface, &bbox, NULL); if (unlikely (status)) status = _cairo_surface_set_error (surface, status); DONE: if (x0) *x0 = _cairo_fixed_to_double (bbox.p1.x); if (y0) *y0 = _cairo_fixed_to_double (bbox.p1.y); if (width) *width = _cairo_fixed_to_double (bbox.p2.x - bbox.p1.x); if (height) *height = _cairo_fixed_to_double (bbox.p2.y - bbox.p1.y); } slim_hidden_def (cairo_recording_surface_ink_extents); cairo_status_t _cairo_recording_surface_get_bbox (cairo_recording_surface_t *surface, cairo_box_t *bbox, const cairo_matrix_t *transform) { if (! surface->unbounded) { _cairo_box_from_rectangle (bbox, &surface->extents); if (transform != NULL) _cairo_matrix_transform_bounding_box_fixed (transform, bbox, NULL); return CAIRO_STATUS_SUCCESS; } return _recording_surface_get_ink_bbox (surface, bbox, transform); } cairo_status_t _cairo_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface, cairo_box_t *bbox, const cairo_matrix_t *transform) { return _recording_surface_get_ink_bbox (surface, bbox, transform); } /** * cairo_recording_surface_get_extents: * @surface: a #cairo_recording_surface_t * @extents: the #cairo_rectangle_t to be assigned the extents * * Get the extents of the recording-surface. * * Return value: %TRUE if the surface is bounded, of recording type, and * not in an error state, otherwise %FALSE * * Since: 1.12 **/ cairo_bool_t cairo_recording_surface_get_extents (cairo_surface_t *surface, cairo_rectangle_t *extents) { cairo_recording_surface_t *record; if (surface->status || ! _cairo_surface_is_recording (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return FALSE; } record = (cairo_recording_surface_t *)surface; if (record->unbounded) return FALSE; *extents = record->extents_pixels; return TRUE; } cairo_bool_t _cairo_recording_surface_has_only_bilevel_alpha (cairo_recording_surface_t *surface) { return surface->has_bilevel_alpha; } cairo_bool_t _cairo_recording_surface_has_only_op_over (cairo_recording_surface_t *surface) { return surface->has_only_op_over; } cairo_bool_t _cairo_recording_surface_has_tags (cairo_surface_t *surface) { cairo_recording_surface_t *record; if (surface->status || ! _cairo_surface_is_recording (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return FALSE; } record = (cairo_recording_surface_t *)surface; return record->has_tags; } static void print_indent (FILE *file, int indent) { fprintf (file, "%*s", indent * 2, ""); } static void print_pattern (FILE *file, const cairo_pattern_t *pattern, unsigned int region_id, int indent, cairo_bool_t recurse) { switch (pattern->type) { case CAIRO_PATTERN_TYPE_SOLID: { cairo_solid_pattern_t *p = (cairo_solid_pattern_t *) pattern; if (pattern->is_foreground_marker) { fprintf (file, "solid foreground\n"); } else { fprintf (file, "solid rgba: %f %f %f %f\n", p->color.red, p->color.green, p->color.blue, p->color.alpha); } } break; case CAIRO_PATTERN_TYPE_SURFACE: { cairo_surface_pattern_t *p = (cairo_surface_pattern_t *) pattern; fprintf (file, "surface "); if (p->surface->type == CAIRO_SURFACE_TYPE_RECORDING) { fprintf (file, "recording id: %d\n", p->surface->unique_id); if (recurse) { _cairo_debug_print_recording_surface (file, p->surface, region_id, indent + 1, recurse); } } else if (p->surface->type == CAIRO_SURFACE_TYPE_IMAGE) { cairo_image_surface_t *image = (cairo_image_surface_t *)p->surface; fprintf (file, "image format: "); switch (image->format) { case CAIRO_FORMAT_INVALID: fputs ("INVALID", file); break; case CAIRO_FORMAT_ARGB32: fputs ("ARGB32", file); break; case CAIRO_FORMAT_RGB24: fputs ("RGB24", file); break; case CAIRO_FORMAT_A8: fputs ("A8", file); break; case CAIRO_FORMAT_A1: fputs ("A1", file); break; case CAIRO_FORMAT_RGB16_565: fputs ("RGB16_565", file); break; case CAIRO_FORMAT_RGB30: fputs ("RGB30", file); break; case CAIRO_FORMAT_RGB96F: fputs ("RGB96F", file); break; case CAIRO_FORMAT_RGBA128F: fputs ("RGBA128F", file); break; } fprintf (file, " width: %d height: %d\n", image->width, image->height); } else { fprintf (file, "type %d\n", p->surface->type); } } break; case CAIRO_PATTERN_TYPE_LINEAR: fprintf (file, "linear\n"); break; case CAIRO_PATTERN_TYPE_RADIAL: fprintf (file, "radial\n"); break; case CAIRO_PATTERN_TYPE_MESH: fprintf (file, "mesh\n"); break; case CAIRO_PATTERN_TYPE_RASTER_SOURCE: fprintf (file, "raster\n"); break; } } void _cairo_debug_print_recording_surface (FILE *file, cairo_surface_t *surface, unsigned int regions_id, int indent, cairo_bool_t recurse) { cairo_command_t **elements; cairo_recording_region_element_t *region_elements = NULL; unsigned int i, num_elements; cairo_recording_surface_t *recording_surface; cairo_surface_t *free_me = NULL; char common[100]; if (_cairo_surface_is_snapshot (surface)) free_me = surface = _cairo_surface_snapshot_get_target (surface); assert (_cairo_surface_is_recording (surface)); recording_surface = (cairo_recording_surface_t *)surface; print_indent (file, indent); indent++; fprintf(file, "recording surface id: %d regions id: %d\n", recording_surface->base.unique_id, regions_id); num_elements = recording_surface->commands.num_elements; elements = _cairo_array_index (&recording_surface->commands, 0); if (regions_id != 0) { cairo_recording_regions_array_t *regions_array; regions_array = _cairo_recording_surface_region_array_find (recording_surface, regions_id); assert (regions_array != NULL); assert (_cairo_array_num_elements (®ions_array->regions) == num_elements); region_elements = _cairo_array_index (®ions_array->regions, 0); } for (i = 0; i < num_elements; i++) { cairo_command_t *command = elements[i]; unsigned int source_region_id = 0; unsigned int mask_region_id = 0; common[0] = 0; if (region_elements) { cairo_recording_region_element_t *region_element = ®ion_elements[i]; strcpy (common, "region: "); switch (region_element->region) { case CAIRO_RECORDING_REGION_ALL: strcat (common, "all"); break; case CAIRO_RECORDING_REGION_NATIVE: strcat (common, "native"); break; case CAIRO_RECORDING_REGION_IMAGE_FALLBACK: strcat (common, "fallback"); break; } source_region_id = region_element->source_id; mask_region_id = region_element->mask_id; } sprintf (common + strlen(common), " op: %s", _cairo_debug_operator_to_string (command->header.op)); switch (command->header.type) { case CAIRO_COMMAND_PAINT: print_indent (file, indent); fprintf(file, "%d PAINT %s source: ", i, common); print_pattern (file, &command->paint.source.base, source_region_id, indent + 1, recurse); break; case CAIRO_COMMAND_MASK: print_indent (file, indent); fprintf(file, "%d MASK %s\n", i, common); print_indent (file, indent + 1); fprintf(file, "source: "); print_pattern (file, &command->mask.source.base, source_region_id, indent + 1, recurse); print_indent (file, indent + 1); fprintf(file, "mask: "); print_pattern (file, &command->mask.mask.base, mask_region_id, indent + 1, recurse); break; case CAIRO_COMMAND_STROKE: print_indent (file, indent); fprintf(file, "%d STROKE %s source:", i, common); print_pattern (file, &command->stroke.source.base, source_region_id, indent + 1, recurse); break; case CAIRO_COMMAND_FILL: print_indent (file, indent); fprintf(file, "%d FILL %s source: ", i, common); print_pattern (file, &command->fill.source.base, source_region_id, indent + 1, recurse); break; case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: print_indent (file, indent); fprintf(file, "%d SHOW_TEXT_GLYPHS %s font_type: ", i, common); switch (command->show_text_glyphs.scaled_font->backend->type) { case CAIRO_FONT_TYPE_TOY: fputs ("toy", file); break; case CAIRO_FONT_TYPE_FT: fputs ("ft", file); break; case CAIRO_FONT_TYPE_WIN32: fputs ("win32", file); break; case CAIRO_FONT_TYPE_QUARTZ: fputs ("quartz", file); break; case CAIRO_FONT_TYPE_USER: fputs ("user", file); break; case CAIRO_FONT_TYPE_DWRITE: fputs ("dwrite", file); break; } fprintf (file, " glyphs:"); for (unsigned j = 0; j < command->show_text_glyphs.num_glyphs; j++) fprintf (file, " %ld", command->show_text_glyphs.glyphs[j].index); fprintf (file, " source:"); print_pattern (file, &command->show_text_glyphs.source.base, source_region_id, indent + 1, recurse); break; case CAIRO_COMMAND_TAG: print_indent (file, indent); fprintf(file, "%d %s %s '%s'\n", i, command->tag.begin ? "BEGIN TAG" : "END TAG", command->tag.tag_name, command->tag.attributes); break; default: ASSERT_NOT_REACHED; } } cairo_surface_destroy (free_me); }