Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 3958 → Rev 3959

/programs/develop/libraries/cairo/src/cairo-recording-surface.c
74,14 → 74,21
* 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-recording-surface-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-recording-surface-inline.h"
#include "cairo-surface-wrapper-private.h"
#include "cairo-traps-private.h"
 
typedef enum {
CAIRO_RECORDING_REPLAY,
98,7 → 105,7
* 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
109,6 → 116,248
* 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
134,49 → 383,45
cairo_recording_surface_create (cairo_content_t content,
const cairo_rectangle_t *extents)
{
cairo_recording_surface_t *recording_surface;
cairo_status_t status;
cairo_recording_surface_t *surface;
 
recording_surface = malloc (sizeof (cairo_recording_surface_t));
if (unlikely (recording_surface == NULL))
surface = 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 (&recording_surface->base,
_cairo_surface_init (&surface->base,
&cairo_recording_surface_backend,
NULL, /* device */
content);
 
recording_surface->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;
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;
 
status = _cairo_clip_rectangle (&recording_surface->clip,
&recording_surface->extents);
if (unlikely (status)) {
free (recording_surface);
return _cairo_surface_create_in_error (status);
surface->unbounded = FALSE;
}
 
recording_surface->unbounded = FALSE;
}
_cairo_array_init (&surface->commands, sizeof (cairo_command_t *));
 
_cairo_array_init (&recording_surface->commands, sizeof (cairo_command_t *));
surface->base.is_clear = TRUE;
 
recording_surface->replay_start_idx = 0;
recording_surface->base.is_clear = TRUE;
surface->bbtree.left = surface->bbtree.right = NULL;
surface->bbtree.chain = INVALID_CHAIN;
 
return &recording_surface->base;
surface->indices = NULL;
surface->num_indices = 0;
surface->optimize_clears = TRUE;
 
return &surface->base;
}
slim_hidden_def (cairo_recording_surface_create);
 
196,12 → 441,12
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;
elements = _cairo_array_index (&recording_surface->commands, 0);
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];
 
238,51 → 483,132
ASSERT_NOT_REACHED;
}
 
_cairo_clip_fini (&command->header.clip);
_cairo_clip_destroy (command->header.clip);
free (command);
}
 
_cairo_array_fini (&recording_surface->commands);
_cairo_clip_fini (&recording_surface->clip);
_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 = 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 *
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;
cairo_recording_surface_t *surface = abstract_surface;
cairo_surface_t *image;
 
image = _cairo_surface_has_snapshot (&surface->base,
&_cairo_image_surface_backend);
if (image != NULL) {
*image_out = (cairo_image_surface_t *) cairo_surface_reference (image);
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;
}
 
image = _cairo_image_surface_create_with_content (surface->content,
assert (! surface->unbounded);
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,
-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);
 
status = _cairo_recording_surface_replay (&surface->base, image);
if (unlikely (status)) {
cairo_surface_destroy (image);
return status;
}
 
_cairo_surface_attach_snapshot (&surface->base, image, NULL);
 
*image_out = (cairo_image_surface_t *) image;
*image_extra = NULL;
return CAIRO_STATUS_SUCCESS;
297,11 → 623,11
}
 
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;
 
308,29 → 634,115
command->type = type;
command->op = op;
command->region = CAIRO_RECORDING_REGION_ALL;
_cairo_clip_init_copy (&command->clip, clip);
if (recording_surface->clip.path != NULL)
status = _cairo_clip_apply_clip (&command->clip, &recording_surface->clip);
 
command->extents = composite->unbounded;
command->chain = NULL;
command->index = surface->commands.num_elements;
 
/* steal the clip */
command->clip = NULL;
if (! _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_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 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 *recording_surface = abstract_surface;
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,
clip);
if (unlikely (status))
return status;
 
command = malloc (sizeof (cairo_command_paint_t));
if (unlikely (command == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (unlikely (command == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP_COMPOSITE;
}
 
status = _command_init (recording_surface,
&command->header, CAIRO_COMMAND_PAINT, op, clip);
status = _command_init (surface,
&command->header, CAIRO_COMMAND_PAINT, op,
&composite);
if (unlikely (status))
goto CLEANUP_COMMAND;
 
338,23 → 750,22
if (unlikely (status))
goto CLEANUP_COMMAND;
 
status = _cairo_array_append (&recording_surface->commands, &command);
status = _cairo_recording_surface_commit (surface, &command->header);
if (unlikely (status))
goto CLEANUP_SOURCE;
 
/* An optimisation that takes care to not replay what was done
* before surface is cleared. We don't erase recorded commands
* since we may have earlier snapshots of this surface. */
if (op == CAIRO_OPERATOR_CLEAR && clip == NULL)
recording_surface->replay_start_idx = recording_surface->commands.num_elements;
_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_fini (&command->header.clip);
_cairo_clip_destroy (command->header.clip);
free (command);
CLEANUP_COMPOSITE:
_cairo_composite_rectangles_fini (&composite);
return status;
}
 
363,18 → 774,31
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_pattern_t *mask,
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_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 = malloc (sizeof (cairo_command_mask_t));
if (unlikely (command == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (unlikely (command == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP_COMPOSITE;
}
 
status = _command_init (recording_surface,
&command->header, CAIRO_COMMAND_MASK, op, clip);
status = _command_init (surface,
&command->header, CAIRO_COMMAND_MASK, op,
&composite);
if (unlikely (status))
goto CLEANUP_COMMAND;
 
386,10 → 810,13
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;
 
_cairo_recording_surface_destroy_bbtree (surface);
 
_cairo_composite_rectangles_fini (&composite);
return CAIRO_STATUS_SUCCESS;
 
CLEANUP_MASK:
397,8 → 824,10
CLEANUP_SOURCE:
_cairo_pattern_fini (&command->source.base);
CLEANUP_COMMAND:
_cairo_clip_fini (&command->header.clip);
_cairo_clip_destroy (command->header.clip);
free (command);
CLEANUP_COMPOSITE:
_cairo_composite_rectangles_fini (&composite);
return status;
}
 
406,24 → 835,38
_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,
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_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 = malloc (sizeof (cairo_command_stroke_t));
if (unlikely (command == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (unlikely (command == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP_COMPOSITE;
}
 
status = _command_init (recording_surface,
&command->header, CAIRO_COMMAND_STROKE, op, clip);
status = _command_init (surface,
&command->header, CAIRO_COMMAND_STROKE, op,
&composite);
if (unlikely (status))
goto CLEANUP_COMMAND;
 
444,10 → 887,13
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);
 
_cairo_composite_rectangles_fini (&composite);
return CAIRO_STATUS_SUCCESS;
 
CLEANUP_STYLE:
457,8 → 903,10
CLEANUP_SOURCE:
_cairo_pattern_fini (&command->source.base);
CLEANUP_COMMAND:
_cairo_clip_fini (&command->header.clip);
_cairo_clip_destroy (command->header.clip);
free (command);
CLEANUP_COMPOSITE:
_cairo_composite_rectangles_fini (&composite);
return status;
}
 
466,22 → 914,35
_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 *recording_surface = abstract_surface;
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 = malloc (sizeof (cairo_command_fill_t));
if (unlikely (command == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (unlikely (command == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP_COMPOSITE;
}
 
status =_command_init (recording_surface,
&command->header, CAIRO_COMMAND_FILL, op, clip);
status =_command_init (surface,
&command->header, CAIRO_COMMAND_FILL, op,
&composite);
if (unlikely (status))
goto CLEANUP_COMMAND;
 
497,10 → 958,13
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;
 
_cairo_recording_surface_destroy_bbtree (surface);
 
_cairo_composite_rectangles_fini (&composite);
return CAIRO_STATUS_SUCCESS;
 
CLEANUP_PATH:
508,8 → 972,10
CLEANUP_SOURCE:
_cairo_pattern_fini (&command->source.base);
CLEANUP_COMMAND:
_cairo_clip_fini (&command->header.clip);
_cairo_clip_destroy (command->header.clip);
free (command);
CLEANUP_COMPOSITE:
_cairo_composite_rectangles_fini (&composite);
return status;
}
 
531,19 → 997,34
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))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
if (unlikely (command == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP_COMPOSITE;
}
 
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;
 
587,10 → 1068,11
 
command->scaled_font = cairo_scaled_font_reference (scaled_font);
 
status = _cairo_array_append (&recording_surface->commands, &command);
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:
602,13 → 1084,325
 
_cairo_pattern_fini (&command->source.base);
CLEANUP_COMMAND:
_cairo_clip_fini (&command->header.clip);
_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);
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 = 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
624,39 → 1418,39
_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));
if (unlikely (recording_surface == NULL))
surface = 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 (&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;
recording_surface->unbounded = other->unbounded;
recording_surface->content = other->content;
surface->extents_pixels = other->extents_pixels;
surface->extents = other->extents;
surface->unbounded = other->unbounded;
 
_cairo_clip_init_copy (&recording_surface->clip, &other->clip);
surface->base.is_clear = other->base.is_clear;
 
/* XXX We should in theory be able to reuse the original array, but we
* need to handle reference cycles during subsurface and self-copy.
*/
recording_surface->replay_start_idx = 0;
recording_surface->base.is_clear = TRUE;
surface->bbtree.left = surface->bbtree.right = NULL;
surface->bbtree.chain = INVALID_CHAIN;
 
_cairo_array_init (&recording_surface->commands, sizeof (cairo_command_t *));
status = _cairo_recording_surface_replay (&other->base, &recording_surface->base);
surface->indices = NULL;
surface->num_indices = 0;
surface->optimize_clears = TRUE;
 
_cairo_array_init (&surface->commands, sizeof (cairo_command_t *));
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);
}
 
return &recording_surface->base;
return &surface->base;
}
 
static cairo_bool_t
672,43 → 1466,30
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,
_cairo_recording_surface_finish,
 
_cairo_default_context_create,
 
_cairo_recording_surface_create_similar,
_cairo_recording_surface_finish,
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,
NULL, /* acquire_dest_image */
NULL, /* release_dest_image */
NULL, /* clone_similar */
NULL, /* composite */
NULL, /* fill_rectangles */
NULL, /* composite_trapezoids */
NULL, /* create_span_renderer */
NULL, /* check_span_renderer */
_cairo_recording_surface_snapshot,
 
NULL, /* copy_page */
NULL, /* show_page */
 
_cairo_recording_surface_get_extents,
NULL, /* old_show_glyphs */
NULL, /* get_font_options */
 
NULL, /* flush */
NULL, /* mark_dirty_rectangle */
NULL, /* scaled_font_fini */
NULL, /* scaled_glyph_fini */
 
/* Here are the 5 basic drawing operations, (which are in some
* sense the only things that cairo_recording_surface should need to
719,37 → 1500,30
_cairo_recording_surface_mask,
_cairo_recording_surface_stroke,
_cairo_recording_surface_fill,
NULL, /* fill-stroke */
NULL,
 
_cairo_recording_surface_snapshot,
 
NULL, /* is_similar */
NULL, /* fill_stroke */
NULL, /* create_solid_pattern_surface */
NULL, /* can_repaint_solid_pattern_surface */
 
_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)
return surface->status;
if (unlikely (abstract_surface->status))
return abstract_surface->status;
 
recording_surface = (cairo_recording_surface_t *) surface;
surface = (cairo_recording_surface_t *) abstract_surface;
status = CAIRO_STATUS_SUCCESS;
 
num_elements = recording_surface->commands.num_elements;
elements = _cairo_array_index (&recording_surface->commands, 0);
for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
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) {
765,7 → 1539,7
_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.ctm,
&command->stroke.ctm_inverse,
772,7 → 1546,7
command->stroke.tolerance,
&traps);
 
if (status == CAIRO_STATUS_SUCCESS)
if (status == CAIRO_INT_STATUS_SUCCESS)
status = _cairo_traps_path (&traps, path);
 
_cairo_traps_fini (&traps);
781,7 → 1555,7
case CAIRO_COMMAND_FILL:
{
status = _cairo_path_fixed_append (path,
&command->fill.path, CAIRO_DIRECTION_FORWARD,
&command->fill.path,
0, 0);
break;
}
802,60 → 1576,105
break;
}
 
return _cairo_surface_set_error (surface, status);
return status;
}
 
#define _clip(c) ((c)->header.clip.path ? &(c)->header.clip : NULL)
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 cairo_status_t
_cairo_recording_surface_replay_internal (cairo_surface_t *surface,
_cairo_recording_surface_replay_internal (cairo_recording_surface_t *surface,
const cairo_rectangle_int_t *surface_extents,
const cairo_matrix_t *surface_transform,
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_surface_wrapper_t wrapper;
cairo_command_t **elements;
int i, num_elements;
cairo_int_status_t status;
cairo_surface_wrapper_t wrapper;
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;
cairo_bool_t use_indices = FALSE;
const cairo_rectangle_int_t *r;
unsigned int i, num_elements;
 
if (unlikely (surface->status))
return surface->status;
if (unlikely (surface->base.status))
return surface->base.status;
 
if (unlikely (target->status))
return target->status;
 
if (unlikely (surface->finished))
if (unlikely (surface->base.finished))
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
 
if (surface->is_clear)
if (surface->base.is_clear)
return CAIRO_STATUS_SUCCESS;
 
assert (_cairo_surface_is_recording (surface));
assert (_cairo_surface_is_recording (&surface->base));
 
_cairo_surface_wrapper_init (&wrapper, target);
_cairo_surface_wrapper_set_extents (&wrapper, surface_extents);
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);
_cairo_surface_wrapper_set_clip (&wrapper, target_clip);
 
recording_surface = (cairo_recording_surface_t *) surface;
status = CAIRO_STATUS_SUCCESS;
/* Compute the extents of the target clip in recorded device space */
if (! _cairo_surface_wrapper_get_target_extents (&wrapper, &extents))
goto done;
 
num_elements = recording_surface->commands.num_elements;
elements = _cairo_array_index (&recording_surface->commands, 0);
num_elements = surface->commands.num_elements;
elements = _cairo_array_index (&surface->commands, 0);
if (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;
}
 
for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
cairo_command_t *command = elements[i];
for (i = 0; i < num_elements; i++) {
cairo_command_t *command = elements[use_indices ? surface->indices[i] : i];
 
if (type == CAIRO_RECORDING_REPLAY && region != CAIRO_RECORDING_REGION_ALL) {
if (command->header.region != region)
if (! replay_all && 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,
command->header.op,
&command->paint.source.base,
_clip (command));
command->header.clip);
break;
 
case CAIRO_COMMAND_MASK:
863,11 → 1682,10
command->header.op,
&command->mask.source.base,
&command->mask.mask.base,
_clip (command));
command->header.clip);
break;
 
case CAIRO_COMMAND_STROKE:
{
status = _cairo_surface_wrapper_stroke (&wrapper,
command->header.op,
&command->stroke.source.base,
877,11 → 1695,12
&command->stroke.ctm_inverse,
command->stroke.tolerance,
command->stroke.antialias,
_clip (command));
command->header.clip);
break;
}
 
case CAIRO_COMMAND_FILL:
{
status = CAIRO_INT_STATUS_UNSUPPORTED;
if (_cairo_surface_wrapper_has_fill_stroke (&wrapper)) {
cairo_command_t *stroke_command;
 
stroke_command = NULL;
898,8 → 1717,10
 
if (stroke_command != NULL &&
stroke_command->header.type == CAIRO_COMMAND_STROKE &&
_cairo_path_fixed_is_equal (&command->fill.path,
&stroke_command->stroke.path))
_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,
915,11 → 1736,11
&stroke_command->stroke.ctm_inverse,
stroke_command->stroke.tolerance,
stroke_command->stroke.antialias,
_clip (command));
command->header.clip);
i++;
}
else
{
}
if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
status = _cairo_surface_wrapper_fill (&wrapper,
command->header.op,
&command->fill.source.base,
927,52 → 1748,34
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);
 
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));
}
}
 
980,18 → 1783,101
break;
}
 
/* free up any caches */
for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
cairo_command_t *command = elements[i];
done:
_cairo_surface_wrapper_fini (&wrapper);
return _cairo_surface_set_error (&surface->base, status);
}
 
_cairo_clip_drop_cache (&command->header.clip);
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,
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);
return _cairo_surface_set_error (&surface->base, status);
}
 
/**
* _cairo_recording_surface_replay:
* @surface: the #cairo_recording_surface_t
1008,12 → 1894,24
_cairo_recording_surface_replay (cairo_surface_t *surface,
cairo_surface_t *target)
{
return _cairo_recording_surface_replay_internal (surface, NULL,
target,
return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, NULL, NULL,
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);
}
 
/* 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
1024,8 → 1922,8
_cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface,
cairo_surface_t *target)
{
return _cairo_recording_surface_replay_internal (surface, NULL,
target,
return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, NULL, NULL,
target, NULL,
CAIRO_RECORDING_CREATE_REGIONS,
CAIRO_RECORDING_REGION_ALL);
}
1036,8 → 1934,9
cairo_surface_t *target,
cairo_recording_region_type_t region)
{
return _cairo_recording_surface_replay_internal (surface, surface_extents,
target,
return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface,
surface_extents, NULL,
target, NULL,
CAIRO_RECORDING_REPLAY,
region);
}
1051,7 → 1950,7
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);
 
1095,7 → 1994,7
 
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;
}
1132,3 → 2031,42
 
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;
}