Pass rect and matrix by value in geometry functions.

Several things irk me about passing values as const pointers:

* They can be NULL, which is not a valid value.
* They require explicit temporary variables for storage.
* They don't compose easily in a legible manner, requiring
  weird pointer passing semantics where the variable being assigned
  is hidden as an argument in the innermost function call.
* We can't change the value through the pointer, requiring yet more
  local variables to hold copies of the input value.

In the device interface where we pass a matrix to a function, we often
find ourselves making a local copy of the matrix so we can concatenate
other transforms to it. This copying is a lot of unnecessary busywork
that I hope to eventually avoid by laying the groundwork with this
commit.

This is a rather large API change, so I apologize for the inconvenience,
but I hope the end result and gain in legibility will be worth the pain.

9 files changed, 193 insertions, 213 deletions

diff --git a/source/xps/xps-common.c b/source/xps/xps-common.c
index f2f9b93c..75baa2bf 100644
--- a/source/xps/xps-common.c
+++ b/source/xps/xps-common.c
@@ -33,7 +33,7 @@ xps_lookup_alternate_content(fz_context *ctx, xps_document *doc, fz_xml *node)
 }
 
 void
-xps_parse_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node)
+xps_parse_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node)
 {
 	if (doc->cookie && doc->cookie->abort)
 		return;
@@ -51,7 +51,7 @@ xps_parse_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const
 }
 
 void
-xps_parse_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node)
+xps_parse_element(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node)
 {
 	if (doc->cookie && doc->cookie->abort)
 		return;
@@ -71,7 +71,7 @@ xps_parse_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, cons
 }
 
 void
-xps_begin_opacity(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_begin_opacity(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict,
 	char *opacity_att, fz_xml *opacity_mask_tag)
 {
@@ -109,7 +109,7 @@ xps_begin_opacity(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, cons
 
 	if (opacity_mask_tag)
 	{
-		fz_begin_mask(ctx, dev, area, 0, NULL, NULL, NULL);
+		fz_begin_mask(ctx, dev, &area, 0, NULL, NULL, NULL);
 		xps_parse_brush(ctx, doc, ctm, area, base_uri, dict, opacity_mask_tag);
 		fz_end_mask(ctx, dev);
 	}
@@ -134,9 +134,10 @@ xps_end_opacity(fz_context *ctx, xps_document *doc, char *base_uri, xps_resource
 	}
 }
 
-static void
-xps_parse_render_transform(fz_context *ctx, xps_document *doc, char *transform, fz_matrix *matrix)
+static fz_matrix
+xps_parse_render_transform(fz_context *ctx, xps_document *doc, char *transform)
 {
+	fz_matrix matrix;
 	float args[6];
 	char *s = transform;
 	int i;
@@ -154,40 +155,38 @@ xps_parse_render_transform(fz_context *ctx, xps_document *doc, char *transform,
 			s++;
 	}
 
-	matrix->a = args[0]; matrix->b = args[1];
-	matrix->c = args[2]; matrix->d = args[3];
-	matrix->e = args[4]; matrix->f = args[5];
+	matrix.a = args[0]; matrix.b = args[1];
+	matrix.c = args[2]; matrix.d = args[3];
+	matrix.e = args[4]; matrix.f = args[5];
+	return matrix;
 }
 
-static void
-xps_parse_matrix_transform(fz_context *ctx, xps_document *doc, fz_xml *root, fz_matrix *matrix)
+static fz_matrix
+xps_parse_matrix_transform(fz_context *ctx, xps_document *doc, fz_xml *root)
 {
-	char *transform;
-
-	*matrix = fz_identity;
-
 	if (fz_xml_is_tag(root, "MatrixTransform"))
 	{
-		transform = fz_xml_att(root, "Matrix");
+		char *transform = fz_xml_att(root, "Matrix");
 		if (transform)
-			xps_parse_render_transform(ctx, doc, transform, matrix);
+			return xps_parse_render_transform(ctx, doc, transform);
 	}
+	return fz_identity;
 }
 
-void
-xps_parse_transform(fz_context *ctx, xps_document *doc, char *att, fz_xml *tag, fz_matrix *transform, const fz_matrix *ctm)
+fz_matrix
+xps_parse_transform(fz_context *ctx, xps_document *doc, char *att, fz_xml *tag, fz_matrix ctm)
 {
-	*transform = fz_identity;
 	if (att)
-		xps_parse_render_transform(ctx, doc, att, transform);
+		return fz_concat(xps_parse_render_transform(ctx, doc, att), ctm);
 	if (tag)
-		xps_parse_matrix_transform(ctx, doc, tag, transform);
-	fz_concat(transform, transform, ctm);
+		return fz_concat(xps_parse_matrix_transform(ctx, doc, tag), ctm);
+	return ctm;
 }
 
-void
-xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text, fz_rect *rect)
+fz_rect
+xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text)
 {
+	fz_rect rect;
 	float args[4];
 	char *s = text;
 	int i;
@@ -204,10 +203,11 @@ xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text, fz_rect *rec
 			s++;
 	}
 
-	rect->x0 = args[0];
-	rect->y0 = args[1];
-	rect->x1 = args[0] + args[2];
-	rect->y1 = args[1] + args[3];
+	rect.x0 = args[0];
+	rect.y0 = args[1];
+	rect.x1 = args[0] + args[2];
+	rect.y1 = args[1] + args[3];
+	return rect;
 }
 
 static int count_commas(char *s)
diff --git a/source/xps/xps-doc.c b/source/xps/xps-doc.c
index a58aab72..de68c96f 100644
--- a/source/xps/xps-doc.c
+++ b/source/xps/xps-doc.c
@@ -377,13 +377,14 @@ xps_load_fixed_page(fz_context *ctx, xps_document *doc, xps_fixpage *page)
 	return xml;
 }
 
-static fz_rect *
-xps_bound_page(fz_context *ctx, fz_page *page_, fz_rect *bounds)
+static fz_rect
+xps_bound_page(fz_context *ctx, fz_page *page_)
 {
 	xps_page *page = (xps_page*)page_;
-	bounds->x0 = bounds->y0 = 0;
-	bounds->x1 = page->fix->width * 72.0f / 96.0f;
-	bounds->y1 = page->fix->height * 72.0f / 96.0f;
+	fz_rect bounds;
+	bounds.x0 = bounds.y0 = 0;
+	bounds.x1 = page->fix->width * 72.0f / 96.0f;
+	bounds.y1 = page->fix->height * 72.0f / 96.0f;
 	return bounds;
 }
 
diff --git a/source/xps/xps-glyphs.c b/source/xps/xps-glyphs.c
index 31da84fd..1effccc2 100644
--- a/source/xps/xps-glyphs.c
+++ b/source/xps/xps-glyphs.c
@@ -344,7 +344,7 @@ xps_parse_glyph_metrics(char *s, float *advance, float *uofs, float *vofs, int b
  * Calculate metrics for positioning.
  */
 fz_text *
-xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 	fz_font *font, float size, float originx, float originy,
 	int is_sideways, int bidi_level,
 	char *indices, char *unicode)
@@ -369,11 +369,9 @@ xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 	}
 
 	if (is_sideways)
-	{
-		fz_pre_scale(fz_rotate(&tm, 90), -size, size);
-	}
+		tm = fz_pre_scale(fz_rotate(90), -size, size);
 	else
-		fz_scale(&tm, size, -size);
+		tm = fz_scale(size, -size);
 
 	text = fz_new_text(ctx);
 
@@ -454,7 +452,7 @@ xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 			}
 
 			dir = bidi_level & 1 ? FZ_BIDI_RTL : FZ_BIDI_LTR;
-			fz_show_glyph(ctx, text, font, &tm, glyph_index, char_code, is_sideways, bidi_level, dir, FZ_LANG_UNSET);
+			fz_show_glyph(ctx, text, font, tm, glyph_index, char_code, is_sideways, bidi_level, dir, FZ_LANG_UNSET);
 
 			x += advance * 0.01f * size;
 		}
@@ -464,7 +462,7 @@ xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 }
 
 void
-xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_parse_glyphs(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 		char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_device *dev = doc->dev;
@@ -505,8 +503,6 @@ xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 	fz_text *text;
 	fz_rect area;
 
-	fz_matrix local_ctm;
-
 	/*
 	 * Extract attributes and extended attributes.
 	 */
@@ -576,20 +572,20 @@ xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 	 * Set up graphics state.
 	 */
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+	ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 	if (clip_att || clip_tag)
-		xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag);
+		xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);
 
 	font_size = fz_atof(font_size_att);
 
-	text = xps_parse_glyphs_imp(ctx, doc, &local_ctm, font, font_size,
+	text = xps_parse_glyphs_imp(ctx, doc, ctm, font, font_size,
 			fz_atof(origin_x_att), fz_atof(origin_y_att),
 			is_sideways, bidi_level, indices_att, unicode_att);
 
-	fz_bound_text(ctx, text, NULL, &local_ctm, &area);
+	area = fz_bound_text(ctx, text, NULL, ctm);
 
-	xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+	xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
 	/* If it's a solid color brush fill/stroke do a simple fill */
 
@@ -610,7 +606,7 @@ xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 			samples[0] *= fz_atof(fill_opacity_att);
 		xps_set_color(ctx, doc, colorspace, samples);
 
-		fz_fill_text(ctx, dev, text, &local_ctm,
+		fz_fill_text(ctx, dev, text, &ctm,
 			doc->colorspace, doc->color, doc->alpha, NULL);
 	}
 
@@ -618,8 +614,8 @@ xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 
 	if (fill_tag)
 	{
-		fz_clip_text(ctx, dev, text, &local_ctm, &area);
-		xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag);
+		fz_clip_text(ctx, dev, text, &ctm, &area);
+		xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
 		fz_pop_clip(ctx, dev);
 	}
 
diff --git a/source/xps/xps-gradient.c b/source/xps/xps-gradient.c
index 7916d088..73022790 100644
--- a/source/xps/xps-gradient.c
+++ b/source/xps/xps-gradient.c
@@ -210,7 +210,7 @@ xps_sample_gradient_stops(fz_context *ctx, xps_document *doc, fz_shade *shade, s
  */
 
 static void
-xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 	struct stop *stops, int count,
 	int extend,
 	float x0, float y0, float r0,
@@ -240,7 +240,7 @@ xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix
 	shade->u.l_or_r.coords[1][1] = y1;
 	shade->u.l_or_r.coords[1][2] = r1;
 
-	fz_fill_shade(ctx, dev, shade, ctm, 1, fz_default_color_params(ctx));
+	fz_fill_shade(ctx, dev, shade, &ctm, 1, fz_default_color_params(ctx));
 
 	fz_drop_shade(ctx, shade);
 }
@@ -250,7 +250,7 @@ xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix
  */
 
 static void
-xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 	struct stop *stops, int count,
 	int extend,
 	float x0, float y0, float x1, float y1)
@@ -279,7 +279,7 @@ xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix
 	shade->u.l_or_r.coords[1][1] = y1;
 	shade->u.l_or_r.coords[1][2] = 0;
 
-	fz_fill_shade(ctx, dev, shade, ctm, doc->opacity[doc->opacity_top], fz_default_color_params(ctx));
+	fz_fill_shade(ctx, dev, shade, &ctm, doc->opacity[doc->opacity_top], fz_default_color_params(ctx));
 
 	fz_drop_shade(ctx, shade);
 }
@@ -293,7 +293,7 @@ xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix
  */
 
 static void
-xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	struct stop *stops, int count,
 	fz_xml *root, int spread)
 {
@@ -303,9 +303,7 @@ xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 	float yrad = 1;
 	float invscale;
 	int i, ma = 1;
-	fz_matrix local_ctm = *ctm;
 	fz_matrix inv;
-	fz_rect local_area = *area;
 
 	char *center_att = fz_xml_att(root, "Center");
 	char *origin_att = fz_xml_att(root, "GradientOrigin");
@@ -332,7 +330,7 @@ xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 	/* scale the ctm to make ellipses */
 	if (fz_abs(xrad) > FLT_EPSILON)
 	{
-		fz_pre_scale(&local_ctm, 1, yrad/xrad);
+		ctm = fz_pre_scale(ctm, 1, yrad/xrad);
 	}
 
 	if (yrad != 0.0f)
@@ -345,16 +343,17 @@ xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 	r0 = 0;
 	r1 = xrad;
 
-	fz_transform_rect(&local_area, fz_invert_matrix(&inv, &local_ctm));
-	ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y0 - y0) / xrad));
-	ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y0 - y0) / xrad));
-	ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y1 - y0) / xrad));
-	ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y1 - y0) / xrad));
+	inv = fz_invert_matrix(ctm);
+	area = fz_transform_rect(area, inv);
+	ma = fz_maxi(ma, ceilf(hypotf(area.x0 - x0, area.y0 - y0) / xrad));
+	ma = fz_maxi(ma, ceilf(hypotf(area.x1 - x0, area.y0 - y0) / xrad));
+	ma = fz_maxi(ma, ceilf(hypotf(area.x0 - x0, area.y1 - y0) / xrad));
+	ma = fz_maxi(ma, ceilf(hypotf(area.x1 - x0, area.y1 - y0) / xrad));
 
 	if (spread == SPREAD_REPEAT)
 	{
 		for (i = ma - 1; i >= 0; i--)
-			xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(ctx, doc, ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
 	}
 	else if (spread == SPREAD_REFLECT)
 	{
@@ -362,13 +361,13 @@ xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 			ma++;
 		for (i = ma - 2; i >= 0; i -= 2)
 		{
-			xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
-			xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(ctx, doc, ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
+			xps_draw_one_radial_gradient(ctx, doc, ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad);
 		}
 	}
 	else
 	{
-		xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1);
+		xps_draw_one_radial_gradient(ctx, doc, ctm, stops, count, 1, x0, y0, r0, x1, y1, r1);
 	}
 }
 
@@ -378,7 +377,7 @@ xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
  */
 
 static void
-xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	struct stop *stops, int count,
 	fz_xml *root, int spread)
 {
@@ -387,7 +386,6 @@ xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 	float dx, dy, x, y, k;
 	fz_point p1, p2;
 	fz_matrix inv;
-	fz_rect local_area = *area;
 
 	char *start_point_att = fz_xml_att(root, "StartPoint");
 	char *end_point_att = fz_xml_att(root, "EndPoint");
@@ -401,15 +399,16 @@ xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 		xps_parse_point(ctx, doc, end_point_att, &x1, &y1);
 
 	p1.x = x0; p1.y = y0; p2.x = x1; p2.y = y1;
-	fz_transform_rect(&local_area, fz_invert_matrix(&inv, ctm));
+	inv = fz_invert_matrix(ctm);
+	area = fz_transform_rect(area, inv);
 	x = p2.x - p1.x; y = p2.y - p1.y;
-	k = ((local_area.x0 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y);
+	k = ((area.x0 - p1.x) * x + (area.y0 - p1.y) * y) / (x * x + y * y);
 	mi = floorf(k); ma = ceilf(k);
-	k = ((local_area.x1 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y);
+	k = ((area.x1 - p1.x) * x + (area.y0 - p1.y) * y) / (x * x + y * y);
 	mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k));
-	k = ((local_area.x0 - p1.x) * x + (local_area.y1 - p1.y) * y) / (x * x + y * y);
+	k = ((area.x0 - p1.x) * x + (area.y1 - p1.y) * y) / (x * x + y * y);
 	mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k));
-	k = ((local_area.x1 - p1.x) * x + (local_area.y1 - p1.y) * y) / (x * x + y * y);
+	k = ((area.x1 - p1.x) * x + (area.y1 - p1.y) * y) / (x * x + y * y);
 	mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k));
 	dx = x1 - x0; dy = y1 - y0;
 
@@ -440,9 +439,9 @@ xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ct
  */
 
 static void
-xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root,
-	void (*draw)(fz_context *ctx, xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int))
+	void (*draw)(fz_context *ctx, xps_document *, fz_matrix, fz_rect, struct stop *, int, fz_xml *, int))
 {
 	fz_xml *node;
 
@@ -455,7 +454,6 @@ xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 
 	struct stop stop_list[MAX_STOPS];
 	int stop_count;
-	fz_matrix local_ctm;
 	int spread_method;
 
 	opacity_att = fz_xml_att(root, "Opacity");
@@ -487,7 +485,7 @@ xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 			spread_method = SPREAD_REPEAT;
 	}
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+	ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 	if (!stop_tag) {
 		fz_warn(ctx, "missing gradient stops tag");
@@ -501,22 +499,22 @@ xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 		return;
 	}
 
-	xps_begin_opacity(ctx, doc, &local_ctm, area, base_uri, dict, opacity_att, NULL);
+	xps_begin_opacity(ctx, doc, ctm, area, base_uri, dict, opacity_att, NULL);
 
-	draw(ctx, doc, &local_ctm, area, stop_list, stop_count, root, spread_method);
+	draw(ctx, doc, ctm, area, stop_list, stop_count, root, spread_method);
 
 	xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL);
 }
 
 void
-xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient);
 }
 
 void
-xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient);
diff --git a/source/xps/xps-image.c b/source/xps/xps-image.c
index 82eee8e5..b5affe35 100644
--- a/source/xps/xps-image.c
+++ b/source/xps/xps-image.c
@@ -11,19 +11,18 @@ xps_load_image(fz_context *ctx, xps_document *doc, xps_part *part)
 
 /* FIXME: area unused! */
 static void
-xps_paint_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict,
+xps_paint_image_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict,
 	fz_xml *root, void *vimage)
 {
 	fz_image *image = vimage;
 	float xs, ys;
-	fz_matrix local_ctm = *ctm;
 
 	if (image->xres == 0 || image->yres == 0)
 		return;
 	xs = image->w * 96 / image->xres;
 	ys = image->h * 96 / image->yres;
-	fz_pre_scale(&local_ctm, xs, ys);
-	fz_fill_image(ctx, doc->dev, image, &local_ctm, doc->opacity[doc->opacity_top], fz_default_color_params(ctx));
+	ctm = fz_pre_scale(ctm, xs, ys);
+	fz_fill_image(ctx, doc->dev, image, &ctm, doc->opacity[doc->opacity_top], fz_default_color_params(ctx));
 }
 
 static void
@@ -90,7 +89,7 @@ xps_find_image_brush_source_part(fz_context *ctx, xps_document *doc, char *base_
 }
 
 void
-xps_parse_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_image_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	xps_part *part = NULL;
diff --git a/source/xps/xps-imp.h b/source/xps/xps-imp.h
index 1d2baaf0..fc820033 100644
--- a/source/xps/xps-imp.h
+++ b/source/xps/xps-imp.h
@@ -142,35 +142,35 @@ void xps_print_resource_dictionary(fz_context *ctx, xps_document *doc, xps_resou
  * Fixed page/graphics parsing.
  */
 
-void xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_page *page);
-void xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_solid_color_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-
-void xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void(*func)(fz_context *ctx, xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*), void *user);
+void xps_parse_fixed_page(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_page *page);
+void xps_parse_canvas(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_glyphs(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_solid_color_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_image_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_visual_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+
+void xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *root, void(*func)(fz_context *ctx, xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*), void *user);
 
 fz_font *xps_lookup_font(fz_context *ctx, xps_document *doc, char *base_uri, char *font_uri, char *style_att);
-fz_text *xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+fz_text *xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 	fz_font *font, float size, float originx, float originy,
 	int is_sideways, int bidi_level,
 	char *indices, char *unicode);
 fz_path *xps_parse_abbreviated_geometry(fz_context *ctx, xps_document *doc, char *geom, int *fill_rule);
 fz_path *xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule);
-void xps_parse_transform(fz_context *ctx, xps_document *doc, char *att, fz_xml *tag, fz_matrix *new_ctm, const fz_matrix *ctm);
-void xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text, fz_rect *rect);
+fz_matrix xps_parse_transform(fz_context *ctx, xps_document *doc, char *att, fz_xml *tag, fz_matrix ctm);
+fz_rect xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text);
 
-void xps_begin_opacity(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag);
+void xps_begin_opacity(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag);
 void xps_end_opacity(fz_context *ctx, xps_document *doc, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag);
 
-void xps_parse_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
-void xps_parse_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
+void xps_parse_element(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *node);
 
-void xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag);
+void xps_clip(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag);
 
 fz_xml *xps_lookup_alternate_content(fz_context *ctx, xps_document *doc, fz_xml *node);
 
diff --git a/source/xps/xps-link.c b/source/xps/xps-link.c
index 59b4d1a5..9da2e5e2 100644
--- a/source/xps/xps-link.c
+++ b/source/xps/xps-link.c
@@ -7,11 +7,11 @@
 /* Quick parsing of document to find links. */
 
 static void
-xps_load_links_in_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_load_links_in_element(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 		char *base_uri, xps_resource *dict, fz_xml *node, fz_link **link);
 
 static void
-xps_add_link(fz_context *ctx, xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri, fz_link **head)
+xps_add_link(fz_context *ctx, xps_document *doc, fz_rect area, char *base_uri, char *target_uri, fz_link **head)
 {
 	fz_link *link = fz_new_link(ctx, area, doc, target_uri);
 	link->next = *head;
@@ -19,7 +19,7 @@ xps_add_link(fz_context *ctx, xps_document *doc, const fz_rect *area, char *base
 }
 
 static void
-xps_load_links_in_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_load_links_in_path(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 		char *base_uri, xps_resource *dict, fz_xml *root, fz_link **link)
 {
 	char *navigate_uri_att = fz_xml_att(root, "FixedPage.NavigateUri");
@@ -33,13 +33,12 @@ xps_load_links_in_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 
 		fz_path *path = NULL;
 		int fill_rule;
-		fz_matrix local_ctm;
 		fz_rect area;
 
 		xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL);
 		xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
 
-		xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+		ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 		if (data_att)
 			path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule);
@@ -47,15 +46,15 @@ xps_load_links_in_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 			path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule);
 		if (path)
 		{
-			fz_bound_path(ctx, path, NULL, &local_ctm, &area);
+			area = fz_bound_path(ctx, path, NULL, ctm);
 			fz_drop_path(ctx, path);
-			xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att, link);
+			xps_add_link(ctx, doc, area, base_uri, navigate_uri_att, link);
 		}
 	}
 }
 
 static void
-xps_load_links_in_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_load_links_in_glyphs(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 		char *base_uri, xps_resource *dict, fz_xml *root, fz_link **link)
 {
 	char *navigate_uri_att = fz_xml_att(root, "FixedPage.NavigateUri");
@@ -76,14 +75,13 @@ xps_load_links_in_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 
 		int is_sideways = 0;
 		int bidi_level = 0;
-		fz_matrix local_ctm;
 		fz_font *font;
 		fz_text *text;
 		fz_rect area;
 
 		xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
 
-		xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+		ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 		if (is_sideways_att)
 			is_sideways = !strcmp(is_sideways_att, "true");
@@ -93,23 +91,22 @@ xps_load_links_in_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 		font = xps_lookup_font(ctx, doc, base_uri, font_uri_att, style_att);
 		if (!font)
 			return;
-		text = xps_parse_glyphs_imp(ctx, doc, &local_ctm, font, fz_atof(font_size_att),
+		text = xps_parse_glyphs_imp(ctx, doc, ctm, font, fz_atof(font_size_att),
 				fz_atof(origin_x_att), fz_atof(origin_y_att),
 				is_sideways, bidi_level, indices_att, unicode_att);
-		fz_bound_text(ctx, text, NULL, &local_ctm, &area);
+		area = fz_bound_text(ctx, text, NULL, ctm);
 		fz_drop_text(ctx, text);
 		fz_drop_font(ctx, font);
 
-		xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att, link);
+		xps_add_link(ctx, doc, area, base_uri, navigate_uri_att, link);
 	}
 }
 
 static void
-xps_load_links_in_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
+xps_load_links_in_canvas(fz_context *ctx, xps_document *doc, fz_matrix ctm,
 		char *base_uri, xps_resource *dict, fz_xml *root, fz_link **link)
 {
 	xps_resource *new_dict = NULL;
-	fz_matrix local_ctm;
 	fz_xml *node;
 
 	char *navigate_uri_att = fz_xml_att(root, "FixedPage.NavigateUri");
@@ -129,20 +126,20 @@ xps_load_links_in_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ct
 
 	xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+	ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 	if (navigate_uri_att)
 		fz_warn(ctx, "FixedPage.NavigateUri attribute on Canvas element");
 
 	for (node = fz_xml_down(root); node; node = fz_xml_next(node))
-		xps_load_links_in_element(ctx, doc, &local_ctm, base_uri, dict, node, link);
+		xps_load_links_in_element(ctx, doc, ctm, base_uri, dict, node, link);
 
 	if (new_dict)
 		xps_drop_resource_dictionary(ctx, doc, new_dict);
 }
 
 static void
-xps_load_links_in_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *node, fz_link **link)
+xps_load_links_in_element(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *node, fz_link **link)
 {
 	if (fz_xml_is_tag(node, "Path"))
 		xps_load_links_in_path(ctx, doc, ctm, base_uri, dict, node, link);
@@ -159,7 +156,7 @@ xps_load_links_in_element(fz_context *ctx, xps_document *doc, const fz_matrix *c
 }
 
 static void
-xps_load_links_in_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_page *page, fz_link **link)
+xps_load_links_in_fixed_page(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_page *page, fz_link **link)
 {
 	fz_xml *root, *node, *resource_tag;
 	xps_resource *dict = NULL;
@@ -193,7 +190,7 @@ xps_load_links(fz_context *ctx, fz_page *page_)
 	xps_page *page = (xps_page*)page_;
 	fz_matrix ctm;
 	fz_link *link = NULL;
-	fz_scale(&ctm, 72.0f / 96.0f, 72.0f / 96.0f);
-	xps_load_links_in_fixed_page(ctx, page->doc, &ctm, page, &link);
+	ctm = fz_scale(72.0f / 96.0f, 72.0f / 96.0f);
+	xps_load_links_in_fixed_page(ctx, page->doc, ctm, page, &link);
 	return link;
 }
diff --git a/source/xps/xps-path.c b/source/xps/xps-path.c
index 021d2021..ad8ea535 100644
--- a/source/xps/xps-path.c
+++ b/source/xps/xps-path.c
@@ -49,7 +49,7 @@ xps_parse_point(fz_context *ctx, xps_document *doc, char *s_in, float *x, float
  * calculated by th0, and on exit, a point is generated for us at th0.
  */
 static void
-xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw)
+xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_matrix mtx, float th0, float th1, int iscw)
 {
 	float t, d;
 	fz_point p;
@@ -63,7 +63,7 @@ xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz
 	{
 		for (t = th0 + d; t < th1 - d/2; t += d)
 		{
-			fz_transform_point_xy(&p, mtx, cosf(t), sinf(t));
+			p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
 			fz_lineto(ctx, path, p.x, p.y);
 		}
 	}
@@ -72,7 +72,7 @@ xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz
 		th0 += FZ_PI * 2;
 		for (t = th0 - d; t > th1 + d/2; t -= d)
 		{
-			fz_transform_point_xy(&p, mtx, cosf(t), sinf(t));
+			p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
 			fz_lineto(ctx, path, p.x, p.y);
 		}
 	}
@@ -80,7 +80,7 @@ xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz
 
 /* Given two vectors find the angle between them. */
 static float
-angle_between(const fz_point u, const fz_point v)
+angle_between(fz_point u, fz_point v)
 {
 	float det = u.x * v.y - u.y * v.x;
 	float sign = (det < 0 ? -1 : 1);
@@ -140,8 +140,8 @@ xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path,
 	else
 		sign = -1;
 
-	fz_rotate(&rotmat, rotation_angle);
-	fz_rotate(&revmat, -rotation_angle);
+	rotmat = fz_rotate(rotation_angle);
+	revmat = fz_rotate(-rotation_angle);
 
 	/* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */
 	/* Conversion from endpoint to center parameterization */
@@ -158,7 +158,7 @@ xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path,
 	/* F.6.5.1 */
 	pt.x = (x1 - x2) / 2;
 	pt.y = (y1 - y2) / 2;
-	fz_transform_vector(&pt, &revmat);
+	pt = fz_transform_vector(pt, revmat);
 	x1t = pt.x;
 	y1t = pt.y;
 
@@ -184,7 +184,7 @@ xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path,
 	/* F.6.5.3 */
 	pt.x = cxt;
 	pt.y = cyt;
-	fz_transform_vector(&pt, &rotmat);
+	pt = fz_transform_vector(pt, rotmat);
 	cx = pt.x + (x1 + x2) / 2;
 	cy = pt.y + (y1 + y2) / 2;
 
@@ -207,8 +207,8 @@ xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path,
 			dth -= ((FZ_PI / 180) * 360);
 	}
 
-	fz_pre_scale(fz_pre_rotate(fz_translate(&mtx, cx, cy), rotation_angle), rx, ry);
-	xps_draw_arc_segment(ctx, doc, path, &mtx, th1, th1 + dth, is_clockwise);
+	mtx = fz_pre_scale(fz_pre_rotate(fz_translate(cx, cy), rotation_angle), rx, ry);
+	xps_draw_arc_segment(ctx, doc, path, mtx, th1, th1 + dth, is_clockwise);
 
 	fz_lineto(ctx, path, point_x, point_y);
 }
@@ -719,7 +719,7 @@ xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict,
 			*fill_rule = 0;
 	}
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &transform, &fz_identity);
+	transform = xps_parse_transform(ctx, doc, transform_att, transform_tag, fz_identity);
 
 	if (figures_att)
 		path = xps_parse_abbreviated_geometry(ctx, doc, figures_att, fill_rule);
@@ -736,7 +736,7 @@ xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict,
 	}
 
 	if (transform_att || transform_tag)
-		fz_transform_path(ctx, path, &transform);
+		fz_transform_path(ctx, path, transform);
 
 	return path;
 }
@@ -755,7 +755,7 @@ xps_parse_line_cap(char *attr)
 }
 
 void
-xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
+xps_clip(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
 {
 	fz_device *dev = doc->dev;
 	fz_path *path;
@@ -767,7 +767,7 @@ xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource
 		path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule);
 	else
 		path = fz_new_path(ctx);
-	fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, NULL);
+	fz_clip_path(ctx, dev, path, fill_rule == 0, &ctm, NULL);
 	fz_drop_path(ctx, path);
 }
 
@@ -777,7 +777,7 @@ xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource
  */
 
 void
-xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root)
+xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_device *dev = doc->dev;
 
@@ -822,7 +822,6 @@ xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *b
 	fz_rect area;
 	int fill_rule;
 	int dash_len = 0;
-	fz_matrix local_ctm;
 
 	/*
 	 * Extract attributes and extended attributes.
@@ -963,10 +962,10 @@ xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *b
 		}
 	}
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+	ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 	if (clip_att || clip_tag)
-		xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag);
+		xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);
 
 	fz_try(ctx)
 	{
@@ -985,17 +984,16 @@ xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *b
 
 		if (stroke_att || stroke_tag)
 		{
-			fz_bound_path(ctx, stroke_path, stroke, &local_ctm, &area);
+			area = fz_bound_path(ctx, stroke_path, stroke, ctm);
 			if (stroke_path != path && (fill_att || fill_tag)) {
-				fz_rect bounds;
-				fz_bound_path(ctx, path, NULL, &local_ctm, &bounds);
-				fz_union_rect(&area, &bounds);
+				fz_rect bounds = fz_bound_path(ctx, path, NULL, ctm);
+				area = fz_union_rect(area, bounds);
 			}
 		}
 		else
-			fz_bound_path(ctx, path, NULL, &local_ctm, &area);
+			area = fz_bound_path(ctx, path, NULL, ctm);
 
-		xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+		xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
 		if (fill_att)
 		{
@@ -1003,14 +1001,14 @@ xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *b
 			if (fill_opacity_att)
 				samples[0] *= fz_atof(fill_opacity_att);
 			xps_set_color(ctx, doc, colorspace, samples);
-			fz_fill_path(ctx, dev, path, fill_rule == 0, &local_ctm,
+			fz_fill_path(ctx, dev, path, fill_rule == 0, &ctm,
 				doc->colorspace, doc->color, doc->alpha, NULL);
 		}
 
 		if (fill_tag)
 		{
-			fz_clip_path(ctx, dev, path, fill_rule == 0, &local_ctm, &area);
-			xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag);
+			fz_clip_path(ctx, dev, path, fill_rule == 0, &ctm, &area);
+			xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
 			fz_pop_clip(ctx, dev);
 		}
 
@@ -1020,14 +1018,14 @@ xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *b
 			if (stroke_opacity_att)
 				samples[0] *= fz_atof(stroke_opacity_att);
 			xps_set_color(ctx, doc, colorspace, samples);
-			fz_stroke_path(ctx, dev, stroke_path, stroke, &local_ctm,
+			fz_stroke_path(ctx, dev, stroke_path, stroke, &ctm,
 				doc->colorspace, doc->color, doc->alpha, NULL);
 		}
 
 		if (stroke_tag)
 		{
-			fz_clip_stroke_path(ctx, dev, stroke_path, stroke, &local_ctm, &area);
-			xps_parse_brush(ctx, doc, &local_ctm, &area, stroke_uri, dict, stroke_tag);
+			fz_clip_stroke_path(ctx, dev, stroke_path, stroke, &ctm, &area);
+			xps_parse_brush(ctx, doc, ctm, area, stroke_uri, dict, stroke_tag);
 			fz_pop_clip(ctx, dev);
 		}
 
diff --git a/source/xps/xps-tile.c b/source/xps/xps-tile.c
index 3e144123..6a75481f 100644
--- a/source/xps/xps-tile.c
+++ b/source/xps/xps-tile.c
@@ -19,28 +19,28 @@ struct closure
 	xps_resource *dict;
 	fz_xml *root;
 	void *user;
-	void (*func)(fz_context *ctx, xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*);
+	void (*func)(fz_context *ctx, xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*);
 };
 
 static void
-xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c)
+xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect viewbox, struct closure *c)
 {
 	fz_device *dev = doc->dev;
 
 	fz_path *path = fz_new_path(ctx);
-	fz_moveto(ctx, path, viewbox->x0, viewbox->y0);
-	fz_lineto(ctx, path, viewbox->x0, viewbox->y1);
-	fz_lineto(ctx, path, viewbox->x1, viewbox->y1);
-	fz_lineto(ctx, path, viewbox->x1, viewbox->y0);
+	fz_moveto(ctx, path, viewbox.x0, viewbox.y0);
+	fz_lineto(ctx, path, viewbox.x0, viewbox.y1);
+	fz_lineto(ctx, path, viewbox.x1, viewbox.y1);
+	fz_lineto(ctx, path, viewbox.x1, viewbox.y0);
 	fz_closepath(ctx, path);
-	fz_clip_path(ctx, dev, path, 0, ctm, NULL);
+	fz_clip_path(ctx, dev, path, 0, &ctm, NULL);
 	fz_drop_path(ctx, path);
 	c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user);
 	fz_pop_clip(ctx, dev);
 }
 
 static void
-xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c)
+xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect viewbox, int tile_mode, struct closure *c)
 {
 	fz_matrix ttm;
 
@@ -48,30 +48,27 @@ xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 
 	if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = *ctm;
-		fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, 0), -1, 1);
-		xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
+		ttm = fz_pre_scale(fz_pre_translate(ctm, viewbox.x1 * 2, 0), -1, 1);
+		xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);
 	}
 
 	if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = *ctm;
-		fz_pre_scale(fz_pre_translate(&ttm, 0, viewbox->y1 * 2), 1, -1);
-		xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
+		ttm = fz_pre_scale(fz_pre_translate(ctm, 0, viewbox.y1 * 2), 1, -1);
+		xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);
 	}
 
 	if (tile_mode == TILE_FLIP_X_Y)
 	{
-		ttm = *ctm;
-		fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, viewbox->y1 * 2), -1, -1);
-		xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
+		ttm = fz_pre_scale(fz_pre_translate(ctm, viewbox.x1 * 2, viewbox.y1 * 2), -1, -1);
+		xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);
 	}
 }
 
 void
-xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root,
-	void (*func)(fz_context *ctx, xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user)
+	void (*func)(fz_context *ctx, xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*), void *user)
 {
 	fz_device *dev = doc->dev;
 	fz_xml *node;
@@ -85,7 +82,6 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 
 	fz_xml *transform_tag = NULL;
 
-	fz_matrix local_ctm;
 	fz_rect viewbox;
 	fz_rect viewport;
 	float xstep, ystep;
@@ -114,15 +110,15 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 
 	xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
 
-	xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+	ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 	viewbox = fz_unit_rect;
 	if (viewbox_att)
-		xps_parse_rectangle(ctx, doc, viewbox_att, &viewbox);
+		viewbox = xps_parse_rectangle(ctx, doc, viewbox_att);
 
 	viewport = fz_unit_rect;
 	if (viewport_att)
-		xps_parse_rectangle(ctx, doc, viewport_att, &viewport);
+		viewport = xps_parse_rectangle(ctx, doc, viewport_att);
 
 	if (fabsf(viewport.x1 - viewport.x0) < 0.01f || fabsf(viewport.y1 - viewport.y0) < 0.01f)
 		fz_warn(ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0);
@@ -161,22 +157,22 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 	if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
 		ystep *= 2;
 
-	xps_begin_opacity(ctx, doc, &local_ctm, area, base_uri, dict, opacity_att, NULL);
+	xps_begin_opacity(ctx, doc, ctm, area, base_uri, dict, opacity_att, NULL);
 
-	fz_pre_translate(&local_ctm, viewport.x0, viewport.y0);
-	fz_pre_scale(&local_ctm, xscale, yscale);
-	fz_pre_translate(&local_ctm, -viewbox.x0, -viewbox.y0);
+	ctm = fz_pre_translate(ctm, viewport.x0, viewport.y0);
+	ctm = fz_pre_scale(ctm, xscale, yscale);
+	ctm = fz_pre_translate(ctm, -viewbox.x0, -viewbox.y0);
 
 	if (tile_mode != TILE_NONE)
 	{
 		int x0, y0, x1, y1;
 		fz_matrix invctm;
-		fz_rect local_area = *area;
-		fz_transform_rect(&local_area, fz_invert_matrix(&invctm, &local_ctm));
-		x0 = floorf(local_area.x0 / xstep);
-		y0 = floorf(local_area.y0 / ystep);
-		x1 = ceilf(local_area.x1 / xstep);
-		y1 = ceilf(local_area.y1 / ystep);
+		invctm = fz_invert_matrix(ctm);
+		area = fz_transform_rect(area, invctm);
+		x0 = floorf(area.x0 / xstep);
+		y0 = floorf(area.y0 / ystep);
+		x1 = ceilf(area.x1 / xstep);
+		y1 = ceilf(area.y1 / ystep);
 
 #ifdef TILE
 		if ((x1 - x0) * (y1 - y0) > 1)
@@ -187,8 +183,8 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 			fz_rect bigview = viewbox;
 			bigview.x1 = bigview.x0 + xstep;
 			bigview.y1 = bigview.y0 + ystep;
-			fz_begin_tile(ctx, dev, &local_area, &bigview, xstep, ystep, &local_ctm);
-			xps_paint_tiling_brush(ctx, doc, &local_ctm, &viewbox, tile_mode, &c);
+			fz_begin_tile(ctx, dev, &area, &bigview, xstep, ystep, &ctm);
+			xps_paint_tiling_brush(ctx, doc, ctm, viewbox, tile_mode, &c);
 			fz_end_tile(ctx, dev);
 		}
 		else
@@ -198,30 +194,29 @@ xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 			{
 				for (x = x0; x < x1; x++)
 				{
-					fz_matrix ttm = local_ctm;
-					fz_pre_translate(&ttm, xstep * x, ystep * y);
-					xps_paint_tiling_brush(ctx, doc, &ttm, &viewbox, tile_mode, &c);
+					fz_matrix ttm = fz_pre_translate(ctm, xstep * x, ystep * y);
+					xps_paint_tiling_brush(ctx, doc, ttm, viewbox, tile_mode, &c);
 				}
 			}
 		}
 	}
 	else
 	{
-		xps_paint_tiling_brush(ctx, doc, &local_ctm, &viewbox, tile_mode, &c);
+		xps_paint_tiling_brush(ctx, doc, ctm, viewbox, tile_mode, &c);
 	}
 
 	xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL);
 }
 
 static void
-xps_paint_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_paint_visual_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root, void *visual_tag)
 {
 	xps_parse_element(ctx, doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag);
 }
 
 void
-xps_parse_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
+xps_parse_visual_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,
 	char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_xml *node;
@@ -249,7 +244,7 @@ xps_parse_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
 }
 
 void
-xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root)
+xps_parse_canvas(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *root)
 {
 	fz_device *dev = doc->dev;
 	xps_resource *new_dict = NULL;
@@ -265,8 +260,6 @@ xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const
 	fz_xml *clip_tag = NULL;
 	fz_xml *opacity_mask_tag = NULL;
 
-	fz_matrix local_ctm;
-
 	transform_att = fz_xml_att(root, "RenderTransform");
 	clip_att = fz_xml_att(root, "Clip");
 	opacity_att = fz_xml_att(root, "Opacity");
@@ -306,15 +299,15 @@ xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const
 		xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL);
 		xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri);
 
-		xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
+		ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
 
 		if (clip_att || clip_tag)
-			xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag);
+			xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);
 
-		xps_begin_opacity(ctx, doc, &local_ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
+		xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
 		for (node = fz_xml_down(root); node; node = fz_xml_next(node))
-			xps_parse_element(ctx, doc, &local_ctm, area, base_uri, dict, node);
+			xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node);
 
 		xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
 
@@ -329,14 +322,13 @@ xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const
 }
 
 void
-xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_page *page)
+xps_parse_fixed_page(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_page *page)
 {
 	fz_xml *root, *node;
 	xps_resource *dict;
 	char base_uri[1024];
 	fz_rect area;
 	char *s;
-	fz_matrix scm;
 
 	fz_strlcpy(base_uri, page->fix->name, sizeof base_uri);
 	s = strrchr(base_uri, '/');
@@ -352,8 +344,7 @@ xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, x
 	if (!root)
 		return;
 
-	area = fz_unit_rect;
-	fz_transform_rect(&area, fz_scale(&scm, page->fix->width, page->fix->height));
+	area = fz_transform_rect(fz_unit_rect, fz_scale(page->fix->width, page->fix->height));
 
 	fz_try(ctx)
 	{
@@ -366,7 +357,7 @@ xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, x
 				else
 					dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node));
 			}
-			xps_parse_element(ctx, doc, ctm, &area, base_uri, dict, node);
+			xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node);
 		}
 	}
 	fz_always(ctx)
@@ -380,13 +371,13 @@ xps_run_page(fz_context *ctx, fz_page *page_, fz_device *dev, const fz_matrix *c
 {
 	xps_page *page = (xps_page*)page_;
 	xps_document *doc = page->doc;
-	fz_matrix page_ctm = *ctm;
+	fz_matrix page_ctm;
 
-	fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f);
+	page_ctm = fz_pre_scale(*ctm, 72.0f / 96.0f, 72.0f / 96.0f);
 
 	doc->cookie = cookie;
 	doc->dev = dev;
-	xps_parse_fixed_page(ctx, doc, &page_ctm, page);
+	xps_parse_fixed_page(ctx, doc, page_ctm, page);
 	doc->cookie = NULL;
 	doc->dev = NULL;
 }