WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-recording-surface.c

  * 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 "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-clip-private.h"
+#include "cairo-default-context-private.h"
+#include "cairo-error-private.h"
-#include "cairo-error-private.h"
+#include "cairo-image-surface-private.h"
-#include "cairo-recording-surface-private.h"
+#include "cairo-recording-surface-inline.h"
+#include "cairo-surface-wrapper-private.h"
-#include "cairo-surface-wrapper-private.h"
+#include "cairo-traps-private.h"
 typedef enum {
     CAIRO_RECORDING_REPLAY,
  * 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 = 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:
+    bbtree_del (&surface->bbtree);
+    return status;
  */
 /**
  * cairo_recording_surface_create:
  * @content: the content of the recording surface
  **/
 cairo_surface_t *
 cairo_recording_surface_create (cairo_content_t		 content,
 				const cairo_rectangle_t	*extents)
+{
-    cairo_recording_surface_t *recording_surface;
+    cairo_recording_surface_t *surface;
-    cairo_status_t status;
-    recording_surface = malloc (sizeof (cairo_recording_surface_t));
+    surface = malloc (sizeof (cairo_recording_surface_t));
-    if (unlikely (recording_surface == NULL))
+    if (unlikely (surface == NULL))
 	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
-    _cairo_surface_init (&recording_surface->base,
+    _cairo_surface_init (&surface->base,
 			 &cairo_recording_surface_backend,
-			 NULL, /* device */
-			 content);
+			 NULL, /* device */
-    recording_surface->content = content;
+			 content);
-    recording_surface->unbounded = TRUE;
-    _cairo_clip_init (&recording_surface->clip);
+    surface->unbounded = TRUE;
     /* unbounded -> 'infinite' extents */
     if (extents != NULL) {
-	recording_surface->extents_pixels = *extents;
+	surface->extents_pixels = *extents;
-	/* XXX check for overflow */
-	recording_surface->extents.x = floor (extents->x);
-	recording_surface->extents.y = floor (extents->y);
-	recording_surface->extents.width = ceil (extents->x + extents->width) - recording_surface->extents.x;
-	recording_surface->extents.height = ceil (extents->y + extents->height) - recording_surface->extents.y;
+	/* XXX check for overflow */
+	surface->extents.x = floor (extents->x);
-	status = _cairo_clip_rectangle (&recording_surface->clip,
-					&recording_surface->extents);
+	surface->extents.y = floor (extents->y);
-	if (unlikely (status)) {
+	surface->extents.width = ceil (extents->x + extents->width) - surface->extents.x;
-	    free (recording_surface);
+	surface->extents.height = ceil (extents->y + extents->height) - surface->extents.y;
+	surface->unbounded = FALSE;
+    }
-	    return _cairo_surface_create_in_error (status);
+    _cairo_array_init (&surface->commands, sizeof (cairo_command_t *));
     surface->base.is_clear = TRUE;
 	recording_surface->unbounded = FALSE;
     surface->bbtree.left = surface->bbtree.right = NULL;
+}
 static cairo_status_t
 _cairo_recording_surface_finish (void *abstract_surface)
 {
-    cairo_recording_surface_t *recording_surface = abstract_surface;
+    cairo_recording_surface_t *surface = abstract_surface;
     cairo_command_t **elements;
     int i, num_elements;
-    num_elements = recording_surface->commands.num_elements;
+    num_elements = surface->commands.num_elements;
-    elements = _cairo_array_index (&recording_surface->commands, 0);
+    elements = _cairo_array_index (&surface->commands, 0);
     for (i = 0; i < num_elements; i++) {
 	cairo_command_t *command = elements[i];
 	default:
 	    ASSERT_NOT_REACHED;
 	}
-	_cairo_clip_fini (&command->header.clip);
+	_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);
+}
-    _cairo_array_fini (&recording_surface->commands);
+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 = 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);
+    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 *
-    _cairo_clip_fini (&recording_surface->clip);
+get_proxy (cairo_surface_t *proxy)
+{
-    return CAIRO_STATUS_SUCCESS;
+    return ((struct proxy *)proxy)->image;
+}
-static cairo_status_t
-_cairo_recording_surface_acquire_source_image (void			 *abstract_surface,
+static cairo_status_t
-					       cairo_image_surface_t	**image_out,
+_cairo_recording_surface_acquire_source_image (void			 *abstract_surface,
+					       cairo_image_surface_t	**image_out,
 					       void			**image_extra)
-{
-    cairo_status_t status;
+{
     cairo_recording_surface_t *surface = abstract_surface;
+    cairo_surface_t *image, *proxy;
-    cairo_surface_t *image;
+    cairo_status_t status;
-    image = _cairo_surface_has_snapshot (&surface->base,
+    proxy = _cairo_surface_has_snapshot (abstract_surface, &proxy_backend);
+    if (proxy != NULL) {
-					 &_cairo_image_surface_backend);
+	*image_out = (cairo_image_surface_t *)
-    if (image != NULL) {
+	    cairo_surface_reference (get_proxy (proxy));
-	*image_out = (cairo_image_surface_t *) cairo_surface_reference (image);
+	*image_extra = NULL;
-	*image_extra = NULL;
+	return CAIRO_STATUS_SUCCESS;
 	return CAIRO_STATUS_SUCCESS;
-    }
-    image = _cairo_image_surface_create_with_content (surface->content,
+    assert (! surface->unbounded);
-						      surface->extents.width,
-						      surface->extents.height);
+    image = _cairo_image_surface_create_with_content (surface->base.content,
+						      surface->extents.width,
+						      surface->extents.height);
     if (unlikely (image->status))
 	return image->status;
-    cairo_surface_set_device_offset (image,
+    /* Handle recursion by returning future reads from the current image */
-				     -surface->extents.x,
-				     -surface->extents.y);
     proxy = attach_proxy (abstract_surface, image);
     status = _cairo_recording_surface_replay (&surface->base, image);
-    if (unlikely (status)) {
+    detach_proxy (abstract_surface, proxy);
 	cairo_surface_destroy (image);
+{
     cairo_surface_destroy (&image->base);
+}
 static cairo_status_t
-_command_init (cairo_recording_surface_t *recording_surface,
+_command_init (cairo_recording_surface_t *surface,
 	       cairo_command_header_t *command,
 	       cairo_command_type_t type,
 	       cairo_operator_t op,
-	       cairo_clip_t *clip)
+	       cairo_composite_rectangles_t *composite)
+{
     cairo_status_t status = CAIRO_STATUS_SUCCESS;
     command->type = type;
+    command->op = op;
+    command->region = CAIRO_RECORDING_REGION_ALL;
-    command->op = op;
+    command->extents = composite->unbounded;
+    command->chain = NULL;
+    command->index = surface->commands.num_elements;
-    command->region = CAIRO_RECORDING_REGION_ALL;
-    _cairo_clip_init_copy (&command->clip, clip);
+    /* steal the clip */
+    command->clip = NULL;
+    if (! _cairo_composite_rectangles_can_reduce_clip (composite,
+						       composite->clip))
+    {
+	command->clip = composite->clip;
-    if (recording_surface->clip.path != NULL)
+	composite->clip = NULL;
 	status = _cairo_clip_apply_clip (&command->clip, &recording_surface->clip);
+    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_bool_t
+is_identity_recording_pattern (const cairo_pattern_t *pattern)
+{
+    cairo_surface_t *surface;
+    if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE)
+	return FALSE;
+    if (!_cairo_matrix_is_identity(&pattern->matrix))
+	return FALSE;
     surface = ((cairo_surface_pattern_t *)pattern)->surface;
-    return status;
+    return surface->backend->type == CAIRO_SURFACE_TYPE_RECORDING;
+}
 static cairo_int_status_t
 _cairo_recording_surface_paint (void			  *abstract_surface,
 				cairo_operator_t	   op,
 				const cairo_pattern_t	  *source,
-				cairo_clip_t		  *clip)
+				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);
+	if (is_identity_recording_pattern (source)) {
+	    cairo_surface_t *src = ((cairo_surface_pattern_t *)source)->surface;
+	    return _cairo_recording_surface_replay (src, &surface->base);
+	}
+    }
+    status = _cairo_composite_rectangles_init_for_paint (&composite,
+							 &surface->base,
 							 op, source,
-    cairo_status_t status;
+							 clip);
-    cairo_recording_surface_t *recording_surface = abstract_surface;
+    if (unlikely (status))
+	return status;
-    cairo_command_paint_t *command;
+    command = malloc (sizeof (cairo_command_paint_t));
+    if (unlikely (command == NULL)) {
+	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    command = malloc (sizeof (cairo_command_paint_t));
+	goto CLEANUP_COMPOSITE;
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
     status = _command_init (surface,
-    status = _command_init (recording_surface,
+			    &command->header, CAIRO_COMMAND_PAINT, op,
-			    &command->header, CAIRO_COMMAND_PAINT, op, clip);
+			    &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->source.base, source);
-    status = _cairo_array_append (&recording_surface->commands, &command);
+    if (unlikely (status))
-    if (unlikely (status))
+	goto CLEANUP_COMMAND;
 	goto CLEANUP_SOURCE;
     status = _cairo_recording_surface_commit (surface, &command->header);
-    /* An optimisation that takes care to not replay what was done
+    if (unlikely (status))
-     * before surface is cleared. We don't erase recorded commands
+	goto CLEANUP_SOURCE;
+    _cairo_recording_surface_destroy_bbtree (surface);
      * since we may have earlier snapshots of this surface. */
-    if (op == CAIRO_OPERATOR_CLEAR && clip == NULL)
+    _cairo_composite_rectangles_fini (&composite);
-	recording_surface->replay_start_idx = recording_surface->commands.num_elements;
+    return CAIRO_STATUS_SUCCESS;
-    return CAIRO_STATUS_SUCCESS;
+  CLEANUP_SOURCE:
     _cairo_pattern_fini (&command->source.base);
-  CLEANUP_SOURCE:
+  CLEANUP_COMMAND:
-    _cairo_pattern_fini (&command->source.base);
+    _cairo_clip_destroy (command->header.clip);
-  CLEANUP_COMMAND:
+    free (command);
-    _cairo_clip_fini (&command->header.clip);
+CLEANUP_COMPOSITE:
-    free (command);
+    _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;
-static cairo_int_status_t
+    cairo_composite_rectangles_t composite;
+    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));
-_cairo_recording_surface_mask (void			*abstract_surface,
-			       cairo_operator_t		 op,
+    status = _cairo_composite_rectangles_init_for_mask (&composite,
+							&surface->base,
-			       const cairo_pattern_t	*source,
+							op, source, mask,
-			       const cairo_pattern_t	*mask,
+							clip);
-			       cairo_clip_t		*clip)
+    if (unlikely (status))
 	return status;
     status = _cairo_pattern_init_snapshot (&command->mask.base, mask);
     if (unlikely (status))
 	goto CLEANUP_SOURCE;
-    status = _cairo_array_append (&recording_surface->commands, &command);
+    status = _cairo_recording_surface_commit (surface, &command->header);
+    if (unlikely (status))
+	goto CLEANUP_MASK;
-    if (unlikely (status))
+    _cairo_recording_surface_destroy_bbtree (surface);
 	goto CLEANUP_MASK;
     _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_pattern_fini (&command->source.base);
+    _cairo_clip_destroy (command->header.clip);
-  CLEANUP_COMMAND:
+    free (command);
-    _cairo_clip_fini (&command->header.clip);
+CLEANUP_COMPOSITE:
-    free (command);
+    _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,
-				 cairo_path_fixed_t	*path,
+				 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,
-				 cairo_clip_t		*clip)
+							  op, source,
-{
+							  path, style, ctm,
-    cairo_status_t status;
+							  clip);
+    if (unlikely (status))
+	return status;
-    cairo_recording_surface_t *recording_surface = abstract_surface;
-    cairo_command_stroke_t *command;
+    command = malloc (sizeof (cairo_command_stroke_t));
+    if (unlikely (command == NULL)) {
 	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    command = malloc (sizeof (cairo_command_stroke_t));
+	goto CLEANUP_COMPOSITE;
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
     command->ctm = *ctm;
     command->ctm_inverse = *ctm_inverse;
     command->tolerance = tolerance;
     command->antialias = antialias;
-    status = _cairo_array_append (&recording_surface->commands, &command);
+    status = _cairo_recording_surface_commit (surface, &command->header);
     if (unlikely (status))
+	goto CLEANUP_STYLE;
+    _cairo_recording_surface_destroy_bbtree (surface);
 	goto CLEANUP_STYLE;
     _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);
-  CLEANUP_COMMAND:
+    free (command);
-    _cairo_clip_fini (&command->header.clip);
+CLEANUP_COMPOSITE:
-    free (command);
+    _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,
-			       cairo_path_fixed_t	*path,
+			       const cairo_path_fixed_t	*path,
 			       cairo_fill_rule_t	 fill_rule,
 			       double			 tolerance,
 			       cairo_antialias_t	 antialias,
-			       cairo_clip_t		*clip)
+			       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,
-    cairo_status_t status;
+							clip);
-    cairo_recording_surface_t *recording_surface = abstract_surface;
+    if (unlikely (status))
+	return status;
-    cairo_command_fill_t *command;
+    command = malloc (sizeof (cairo_command_fill_t));
+    if (unlikely (command == NULL)) {
+	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    command = malloc (sizeof (cairo_command_fill_t));
+	goto CLEANUP_COMPOSITE;
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
     status =_command_init (surface,
     command->fill_rule = fill_rule;
     command->tolerance = tolerance;
     command->antialias = antialias;
-    status = _cairo_array_append (&recording_surface->commands, &command);
+    status = _cairo_recording_surface_commit (surface, &command->header);
+    if (unlikely (status))
+	goto CLEANUP_PATH;
-    if (unlikely (status))
+    _cairo_recording_surface_destroy_bbtree (surface);
 	goto CLEANUP_PATH;
     _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_pattern_fini (&command->source.base);
+    _cairo_clip_destroy (command->header.clip);
-  CLEANUP_COMMAND:
+    free (command);
-    _cairo_clip_fini (&command->header.clip);
+CLEANUP_COMPOSITE:
-    free (command);
+    _cairo_composite_rectangles_fini (&composite);
 					   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,
-					   cairo_clip_t			*clip)
+					   const cairo_clip_t		*clip)
+{
     cairo_status_t status;
-    cairo_recording_surface_t *recording_surface = abstract_surface;
+    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 = malloc (sizeof (cairo_command_show_text_glyphs_t));
-    if (unlikely (command == NULL))
+    if (unlikely (command == NULL)) {
+	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+	goto CLEANUP_COMPOSITE;
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    }
-    status = _command_init (recording_surface,
+    status = _command_init (surface,
 			    &command->header, CAIRO_COMMAND_SHOW_TEXT_GLYPHS,
-			    op, clip);
+			    op, &composite);
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
     command->cluster_flags = cluster_flags;
     command->scaled_font = cairo_scaled_font_reference (scaled_font);
+    status = _cairo_recording_surface_commit (surface, &command->header);
-    status = _cairo_array_append (&recording_surface->commands, &command);
+    if (unlikely (status))
-    if (unlikely (status))
+	goto CLEANUP_SCALED_FONT;
 	goto CLEANUP_SCALED_FONT;
     _cairo_composite_rectangles_fini (&composite);
     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 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->region = CAIRO_RECORDING_REGION_ALL;
+    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 = 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 = 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.source.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);
-    _cairo_clip_fini (&command->header.clip);
+err_command:
+    free(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 = 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 = 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 = 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 = 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 (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;
+	default:
+	    ASSERT_NOT_REACHED;
+	}
+	if (unlikely (status))
+	    return status;
+    }
+    return CAIRO_STATUS_SUCCESS;
+}
 /**
- * _cairo_recording_surface_snapshot
+ * _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
  **/
 static cairo_surface_t *
 _cairo_recording_surface_snapshot (void *abstract_other)
+{
     cairo_recording_surface_t *other = abstract_other;
-    cairo_recording_surface_t *recording_surface;
+    cairo_recording_surface_t *surface;
     cairo_status_t status;
-    recording_surface = malloc (sizeof (cairo_recording_surface_t));
+    surface = malloc (sizeof (cairo_recording_surface_t));
-    if (unlikely (recording_surface == NULL))
+    if (unlikely (surface == NULL))
 	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
-    _cairo_surface_init (&recording_surface->base,
+    _cairo_surface_init (&surface->base,
 			 &cairo_recording_surface_backend,
 			 NULL, /* device */
 			 other->base.content);
-    recording_surface->extents_pixels = other->extents_pixels;
-    recording_surface->extents = other->extents;
+    surface->extents_pixels = other->extents_pixels;
-    recording_surface->unbounded = other->unbounded;
+    surface->extents = other->extents;
-    recording_surface->content = other->content;
+    surface->unbounded = other->unbounded;
+    surface->base.is_clear = other->base.is_clear;
-    _cairo_clip_init_copy (&recording_surface->clip, &other->clip);
+    surface->bbtree.left = surface->bbtree.right = NULL;
-    /* XXX We should in theory be able to reuse the original array, but we
+    surface->bbtree.chain = INVALID_CHAIN;
-     * need to handle reference cycles during subsurface and self-copy.
-     */
+    surface->indices = NULL;
-    recording_surface->replay_start_idx = 0;
+    surface->num_indices = 0;
-    recording_surface->base.is_clear = TRUE;
+    surface->optimize_clears = TRUE;
-    _cairo_array_init (&recording_surface->commands, sizeof (cairo_command_t *));
+    _cairo_array_init (&surface->commands, sizeof (cairo_command_t *));
-    status = _cairo_recording_surface_replay (&other->base, &recording_surface->base);
+    status = _cairo_recording_surface_copy (surface, other);
     if (unlikely (status)) {
-	cairo_surface_destroy (&recording_surface->base);
+	cairo_surface_destroy (&surface->base);
 	return _cairo_surface_create_in_error (status);
     *rectangle = surface->extents;
     return TRUE;
-}
-/**
- * _cairo_surface_is_recording:
- * @surface: a #cairo_surface_t
- *
- * Checks if a surface is a #cairo_recording_surface_t
- *
- * Return value: %TRUE if the surface is a recording surface
- **/
-cairo_bool_t
-_cairo_surface_is_recording (const cairo_surface_t *surface)
-{
-    return surface->backend == &cairo_recording_surface_backend;
+}
-static const cairo_surface_backend_t cairo_recording_surface_backend = {
-    CAIRO_SURFACE_TYPE_RECORDING,
+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_recording_surface_create_similar,
-    _cairo_recording_surface_finish,
+    _cairo_surface_default_source,
-    _cairo_recording_surface_acquire_source_image,
-    _cairo_recording_surface_release_source_image,
-    NULL, /* acquire_dest_image */
-    NULL, /* release_dest_image */
-    NULL, /* clone_similar */
-    NULL, /* composite */
+    _cairo_recording_surface_acquire_source_image,
-    NULL, /* fill_rectangles */
-    NULL, /* composite_trapezoids */
+    _cairo_recording_surface_release_source_image,
-    NULL, /* create_span_renderer */
+    _cairo_recording_surface_snapshot,
     NULL, /* check_span_renderer */
+    NULL, /* copy_page */
-    NULL, /* copy_page */
+    NULL, /* show_page */
-    NULL, /* show_page */
     _cairo_recording_surface_get_extents,
+    _cairo_recording_surface_get_extents,
-    NULL, /* old_show_glyphs */
+    NULL, /* get_font_options */
     NULL, /* get_font_options */
-    NULL, /* flush */
-    NULL, /* mark_dirty_rectangle */
-    NULL, /* scaled_font_fini */
+    NULL, /* flush */
-    NULL, /* scaled_glyph_fini */
+    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_paint,
+    _cairo_recording_surface_mask,
-    _cairo_recording_surface_mask,
-    _cairo_recording_surface_stroke,
-    _cairo_recording_surface_fill,
-    NULL,
-    _cairo_recording_surface_snapshot,
-    NULL, /* is_similar */
-    NULL, /* fill_stroke */
+    _cairo_recording_surface_stroke,
-    NULL, /* create_solid_pattern_surface */
+    _cairo_recording_surface_fill,
-    NULL, /* can_repaint_solid_pattern_surface */
+    NULL, /* fill-stroke */
     NULL,
     _cairo_recording_surface_has_show_text_glyphs,
-    _cairo_recording_surface_show_text_glyphs
+    _cairo_recording_surface_show_text_glyphs,
 };
 cairo_int_status_t
-_cairo_recording_surface_get_path (cairo_surface_t    *surface,
+_cairo_recording_surface_get_path (cairo_surface_t    *abstract_surface,
 				   cairo_path_fixed_t *path)
 {
-    cairo_recording_surface_t *recording_surface;
+    cairo_recording_surface_t *surface;
     cairo_command_t **elements;
     int i, num_elements;
     cairo_int_status_t status;
-    if (surface->status)
+    if (unlikely (abstract_surface->status))
-	return surface->status;
+	return abstract_surface->status;
-    recording_surface = (cairo_recording_surface_t *) surface;
+    surface = (cairo_recording_surface_t *) abstract_surface;
     status = CAIRO_STATUS_SUCCESS;
 	    cairo_traps_t traps;
 	    _cairo_traps_init (&traps);
 	    /* XXX call cairo_stroke_to_path() when that is implemented */
-	    status = _cairo_path_fixed_stroke_to_traps (&command->stroke.path,
+	    status = _cairo_path_fixed_stroke_polygon_to_traps (&command->stroke.path,
-							&command->stroke.style,
+								&command->stroke.style,
-							&command->stroke.ctm,
+								&command->stroke.ctm,
-							&command->stroke.ctm_inverse,
+								&command->stroke.ctm_inverse,
-							command->stroke.tolerance,
+								command->stroke.tolerance,
-							&traps);
+								&traps);
-	    if (status == CAIRO_STATUS_SUCCESS)
+	    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, CAIRO_DIRECTION_FORWARD,
+					       &command->fill.path,
 , 0);
 	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 _cairo_surface_set_error (surface, status);
     return num_visible;
+}
 #define _clip(c) ((c)->header.clip.path ? &(c)->header.clip : NULL)
+static cairo_status_t
-static cairo_status_t
+_cairo_recording_surface_replay_internal (cairo_recording_surface_t	*surface,
+					  const cairo_rectangle_int_t *surface_extents,
-_cairo_recording_surface_replay_internal (cairo_surface_t	     *surface,
+					  const cairo_matrix_t *surface_transform,
-					  const cairo_rectangle_int_t *surface_extents,
+					  cairo_surface_t	     *target,
-					  cairo_surface_t	     *target,
+					  const cairo_clip_t *target_clip,
-					  cairo_recording_replay_type_t type,
-					  cairo_recording_region_type_t region)
-{
-    cairo_recording_surface_t *recording_surface;
-    cairo_command_t **elements;
+					  cairo_recording_replay_type_t type,
+					  cairo_recording_region_type_t region)
+{
+    cairo_surface_wrapper_t wrapper;
+    cairo_command_t **elements;
+    cairo_bool_t replay_all =
+	type == CAIRO_RECORDING_REPLAY &&
+	region == CAIRO_RECORDING_REGION_ALL;
+    cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
+    cairo_rectangle_int_t extents;
-    int i, num_elements;
+    cairo_bool_t use_indices = FALSE;
-    cairo_int_status_t status;
+    const cairo_rectangle_int_t *r;
-    cairo_surface_wrapper_t wrapper;
+    unsigned int i, num_elements;
-    if (unlikely (surface->status))
+    if (unlikely (surface->base.status))
-	return surface->status;
+	return surface->base.status;
     if (unlikely (target->status))
 	return target->status;
+    if (unlikely (surface->base.finished))
-    if (unlikely (surface->finished))
+	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+    if (surface->base.is_clear)
+	return CAIRO_STATUS_SUCCESS;
+    assert (_cairo_surface_is_recording (&surface->base));
+    _cairo_surface_wrapper_init (&wrapper, target);
+    if (surface_extents)
+	_cairo_surface_wrapper_intersect_extents (&wrapper, surface_extents);
+    r = &_cairo_unbounded_rectangle;
+    if (! surface->unbounded) {
+	_cairo_surface_wrapper_intersect_extents (&wrapper, &surface->extents);
+	r = &surface->extents;
+    }
+    _cairo_surface_wrapper_set_inverse_transform (&wrapper, surface_transform);
-	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+    _cairo_surface_wrapper_set_clip (&wrapper, target_clip);
+    /* Compute the extents of the target clip in recorded device space */
-    if (surface->is_clear)
+    if (! _cairo_surface_wrapper_get_target_extents (&wrapper, &extents))
-	return CAIRO_STATUS_SUCCESS;
+	goto done;
-    assert (_cairo_surface_is_recording (surface));
+    num_elements = surface->commands.num_elements;
+    elements = _cairo_array_index (&surface->commands, 0);
-    _cairo_surface_wrapper_init (&wrapper, target);
-    _cairo_surface_wrapper_set_extents (&wrapper, surface_extents);
+    if (extents.width < r->width || extents.height < r->height) {
-    recording_surface = (cairo_recording_surface_t *) surface;
+	num_elements =
-    status = CAIRO_STATUS_SUCCESS;
+	    _cairo_recording_surface_get_visible_commands (surface, &extents);
 	use_indices = num_elements != surface->commands.num_elements;
     num_elements = recording_surface->commands.num_elements;
     elements = _cairo_array_index (&recording_surface->commands, 0);
+    for (i = 0; i < num_elements; i++) {
-    for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
+	cairo_command_t *command = elements[use_indices ? surface->indices[i] : i];
 	cairo_command_t *command = elements[i];
 	if (! replay_all && command->header.region != region)
-	if (type == CAIRO_RECORDING_REPLAY && region != CAIRO_RECORDING_REGION_ALL) {
+	    continue;
 	    if (command->header.region != region)
-		continue;
+	if (! _cairo_rectangle_intersects (&extents, &command->header.extents))
-        }
+	    continue;
 	switch (command->header.type) {
-	case CAIRO_COMMAND_PAINT:
-	    status = _cairo_surface_wrapper_paint (&wrapper,
+	case CAIRO_COMMAND_PAINT:
-						   command->header.op,
+	    status = _cairo_surface_wrapper_paint (&wrapper,
-						   &command->paint.source.base,
+						   command->header.op,
-						   _clip (command));
+						   &command->paint.source.base,
-	    break;
+						   command->header.clip);
 	    break;
 	case CAIRO_COMMAND_MASK:
-	    status = _cairo_surface_wrapper_mask (&wrapper,
+	case CAIRO_COMMAND_MASK:
-						  command->header.op,
+	    status = _cairo_surface_wrapper_mask (&wrapper,
-						  &command->mask.source.base,
+						  command->header.op,
-						  &command->mask.mask.base,
+						  &command->mask.source.base,
-						  _clip (command));
+						  &command->mask.mask.base,
-	    break;
+						  command->header.clip);
+	    break;
 	case CAIRO_COMMAND_STROKE:
 	    status = _cairo_surface_wrapper_stroke (&wrapper,
-	    status = _cairo_surface_wrapper_stroke (&wrapper,
+						    command->header.op,
-						    command->header.op,
+						    &command->stroke.source.base,
-		    stroke_command = NULL;
+			stroke_command = NULL;
+		}
-	    if (stroke_command != NULL &&
+		if (stroke_command != NULL &&
-		stroke_command->header.type == CAIRO_COMMAND_STROKE &&
+		    stroke_command->header.type == CAIRO_COMMAND_STROKE &&
-		_cairo_path_fixed_is_equal (&command->fill.path,
+		    _cairo_path_fixed_equal (&command->fill.path,
+					     &stroke_command->stroke.path) &&
+		    _cairo_clip_equal (command->header.clip,
-					    &stroke_command->stroke.path))
+				       stroke_command->header.clip))
+		{
-		status = _cairo_surface_wrapper_fill_stroke (&wrapper,
+		    status = _cairo_surface_wrapper_fill_stroke (&wrapper,
-							     command->header.op,
+								 command->header.op,
-							     &command->fill.source.base,
+								 &command->fill.source.base,
-							     &stroke_command->stroke.style,
+								 &stroke_command->stroke.style,
-							     &stroke_command->stroke.ctm,
+								 &stroke_command->stroke.ctm,
-							     &stroke_command->stroke.ctm_inverse,
+								 &stroke_command->stroke.ctm_inverse,
-							     stroke_command->stroke.tolerance,
+								 stroke_command->stroke.tolerance,
-							     stroke_command->stroke.antialias,
+								 stroke_command->stroke.antialias,
-							     _clip (command));
+								 command->header.clip);
-		i++;
+		    i++;
+		}
-	    else
-	    {
+	    }
+	    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
 		status = _cairo_surface_wrapper_fill (&wrapper,
 						      command->header.op,
 						      &command->fill.source.base,
 						      &command->fill.path,
 						      command->fill.fill_rule,
 						      command->fill.tolerance,
 						      command->fill.antialias,
-						      _clip (command));
+						      command->header.clip);
+	    }
 	    break;
-	}
-	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:
-	{
-	    cairo_glyph_t *glyphs = command->show_text_glyphs.glyphs;
-	    cairo_glyph_t *glyphs_copy;
-	    int num_glyphs = command->show_text_glyphs.num_glyphs;
-            /* show_text_glyphs is special because _cairo_surface_show_text_glyphs is allowed
-	     * to modify the glyph array that's passed in.  We must always
-	     * copy the array before handing it to the backend.
-	     */
-	    glyphs_copy = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t));
-	    if (unlikely (glyphs_copy == NULL)) {
-		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-		break;
-	    }
-	    memcpy (glyphs_copy, glyphs, sizeof (cairo_glyph_t) * num_glyphs);
 	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:
 	    status = _cairo_surface_wrapper_show_text_glyphs (&wrapper,
 							      command->header.op,
 							      &command->show_text_glyphs.source.base,
 							      command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len,
-							      glyphs_copy, num_glyphs,
+							      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,
-							      _clip (command));
-	    free (glyphs_copy);
+							      command->header.clip);
 	    break;
 	default:
 	    ASSERT_NOT_REACHED;
+	}
 	if (type == CAIRO_RECORDING_CREATE_REGIONS) {
-	    if (status == CAIRO_STATUS_SUCCESS) {
+	    if (status == CAIRO_INT_STATUS_SUCCESS) {
 		command->header.region = CAIRO_RECORDING_REGION_NATIVE;
 	    } else if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) {
 		command->header.region = CAIRO_RECORDING_REGION_IMAGE_FALLBACK;
-		status = CAIRO_STATUS_SUCCESS;
+		status = CAIRO_INT_STATUS_SUCCESS;
 	    } else {
-		assert (_cairo_status_is_error (status));
+		assert (_cairo_int_status_is_error (status));
+	    }
+	}
 	if (unlikely (status))
-	    break;
-    }
+	    break;
-    /* free up any caches */
+    }
     for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
+done:
+    _cairo_surface_wrapper_fini (&wrapper);
+    return _cairo_surface_set_error (&surface->base, status);
+}
-	cairo_command_t *command = elements[i];
+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;
+    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,
+					       command->header.clip);
+	break;
+    case CAIRO_COMMAND_MASK:
+	status = _cairo_surface_wrapper_mask (&wrapper,
+					      command->header.op,
+					      &command->mask.source.base,
+					      &command->mask.mask.base,
+					      command->header.clip);
+	break;
+    case CAIRO_COMMAND_STROKE:
+	status = _cairo_surface_wrapper_stroke (&wrapper,
+						command->header.op,
+						&command->stroke.source.base,
+						&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,
+					      &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,
+							  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,
-	_cairo_clip_drop_cache (&command->header.clip);
+							  command->show_text_glyphs.scaled_font,
+							  command->header.clip);
+	break;
     default:
 	ASSERT_NOT_REACHED;
     _cairo_surface_wrapper_fini (&wrapper);
-    return _cairo_surface_set_error (surface, status);
+    _cairo_surface_wrapper_fini (&wrapper);
  **/
 cairo_status_t
 _cairo_recording_surface_replay (cairo_surface_t *surface,
 				 cairo_surface_t *target)
+{
-    return _cairo_recording_surface_replay_internal (surface, NULL,
+    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, NULL, NULL,
-						     target,
+						     target, NULL,
+						     CAIRO_RECORDING_REPLAY,
+						     CAIRO_RECORDING_REGION_ALL);
+}
+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)
+{
+    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, NULL, surface_transform,
+						     target, target_clip,
 						     CAIRO_RECORDING_REPLAY,
 						     CAIRO_RECORDING_REGION_ALL);
+}
  */
 cairo_status_t
 _cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface,
 						    cairo_surface_t *target)
+{
-    return _cairo_recording_surface_replay_internal (surface, NULL,
+    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, NULL, NULL,
-						     target,
+						     target, NULL,
 						     CAIRO_RECORDING_CREATE_REGIONS,
 						     CAIRO_RECORDING_REGION_ALL);
+}
 cairo_status_t
 _cairo_recording_surface_replay_region (cairo_surface_t          *surface,
 					const cairo_rectangle_int_t *surface_extents,
 					cairo_surface_t          *target,
 					cairo_recording_region_type_t  region)
 {
+    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface,
-    return _cairo_recording_surface_replay_internal (surface, surface_extents,
+						     surface_extents, NULL,
-						     target,
+						     target, NULL,
 						     CAIRO_RECORDING_REPLAY,
 						     region);
+}
+{
     cairo_surface_t *null_surface;
     cairo_surface_t *analysis_surface;
     cairo_status_t status;
-    null_surface = _cairo_null_surface_create (surface->content);
+    null_surface = _cairo_null_surface_create (surface->base.content);
     analysis_surface = _cairo_analysis_surface_create (null_surface);
     cairo_surface_destroy (null_surface);
     cairo_status_t status;
     cairo_box_t bbox;
     memset (&bbox, 0, sizeof (bbox));
-    if (! _cairo_surface_is_recording (surface)) {
+    if (surface->status || ! _cairo_surface_is_recording (surface)) {
 	_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
 	goto DONE;
 	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;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-recording-surface.c – Rev 1892 → 3959