From 4a99615a609eec2b84bb2341d74fac46a5998137 Mon Sep 17 00:00:00 2001
From: Tor Andersson <tor.andersson@artifex.com>
Date: Mon, 25 Jun 2018 13:15:50 +0200
Subject: 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.
---
 source/pdf/pdf-annot.c      | 103 ++++++++++++++++++++------------------------
 source/pdf/pdf-appearance.c |  51 +++++++++++-----------
 source/pdf/pdf-device.c     |  22 +++++-----
 source/pdf/pdf-font.c       |   4 +-
 source/pdf/pdf-form.c       |   6 +--
 source/pdf/pdf-interpret.c  |  16 +++----
 source/pdf/pdf-link.c       |   8 ++--
 source/pdf/pdf-object.c     |  28 ++++++------
 source/pdf/pdf-op-filter.c  |  19 ++++----
 source/pdf/pdf-op-run.c     |  59 +++++++++++--------------
 source/pdf/pdf-page.c       |  33 +++++++-------
 source/pdf/pdf-parse.c      |  38 ++++++++--------
 source/pdf/pdf-pattern.c    |   7 +--
 source/pdf/pdf-run.c        |   8 ++--
 source/pdf/pdf-shade.c      |  15 ++-----
 source/pdf/pdf-signature.c  |   4 +-
 source/pdf/pdf-type3.c      |   6 +--
 source/pdf/pdf-write.c      |   2 +-
 source/pdf/pdf-xobject.c    |  24 +++++------
 19 files changed, 206 insertions(+), 247 deletions(-)

(limited to 'source/pdf')

diff --git a/source/pdf/pdf-annot.c b/source/pdf/pdf-annot.c
index 7dd4784e..e2e2392f 100644
--- a/source/pdf/pdf-annot.c
+++ b/source/pdf/pdf-annot.c
@@ -31,18 +31,18 @@ pdf_drop_annots(fz_context *ctx, pdf_annot *annot)
 }
 
 /* Create transform to fit appearance stream to annotation Rect */
-void
-pdf_annot_transform(fz_context *ctx, pdf_annot *annot, fz_matrix *annot_ctm)
+fz_matrix
+pdf_annot_transform(fz_context *ctx, pdf_annot *annot)
 {
 	fz_rect bbox, rect;
 	fz_matrix matrix;
 	float w, h, x, y;
 
-	pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)), &rect);
-	pdf_xobject_bbox(ctx, annot->ap, &bbox);
-	pdf_xobject_matrix(ctx, annot->ap, &matrix);
+	rect = pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)));
+	bbox = pdf_xobject_bbox(ctx, annot->ap);
+	matrix = pdf_xobject_matrix(ctx, annot->ap);
 
-	fz_transform_rect(&bbox, &matrix);
+	bbox = fz_transform_rect(bbox, matrix);
 	if (bbox.x1 == bbox.x0)
 		w = 0;
 	else
@@ -54,7 +54,7 @@ pdf_annot_transform(fz_context *ctx, pdf_annot *annot, fz_matrix *annot_ctm)
 	x = rect.x0 - bbox.x0;
 	y = rect.y0 - bbox.y0;
 
-	fz_pre_scale(fz_translate(annot_ctm, x, y), w, h);
+	return fz_pre_scale(fz_translate(x, y), w, h);
 }
 
 pdf_annot *pdf_new_annot(fz_context *ctx, pdf_page *page, pdf_obj *obj)
@@ -124,16 +124,13 @@ pdf_next_annot(fz_context *ctx, pdf_annot *annot)
 	return annot ? annot->next : NULL;
 }
 
-fz_rect *
-pdf_bound_annot(fz_context *ctx, pdf_annot *annot, fz_rect *rect)
+fz_rect
+pdf_bound_annot(fz_context *ctx, pdf_annot *annot)
 {
-	pdf_obj *obj = pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect));
-	fz_rect mediabox;
+	fz_rect annot_rect = pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)));
 	fz_matrix page_ctm;
-	pdf_to_rect(ctx, obj, rect);
-	pdf_page_transform(ctx, annot->page, &mediabox, &page_ctm);
-	fz_transform_rect(rect, &page_ctm);
-	return rect;
+	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
+	return fz_transform_rect(annot_rect, page_ctm);
 }
 
 void
@@ -369,26 +366,27 @@ pdf_set_annot_flags(fz_context *ctx, pdf_annot *annot, int flags)
 	pdf_dirty_annot(ctx, annot);
 }
 
-void
-pdf_annot_rect(fz_context *ctx, pdf_annot *annot, fz_rect *rect)
+fz_rect
+pdf_annot_rect(fz_context *ctx, pdf_annot *annot)
 {
 	fz_matrix page_ctm;
+	fz_rect rect;
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)), rect);
-	fz_transform_rect(rect, &page_ctm);
+	rect = pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)));
+	fz_transform_rect(rect, page_ctm);
+	return rect;
 }
 
 void
-pdf_set_annot_rect(fz_context *ctx, pdf_annot *annot, const fz_rect *rect)
+pdf_set_annot_rect(fz_context *ctx, pdf_annot *annot, fz_rect rect)
 {
-	fz_rect trect = *rect;
 	fz_matrix page_ctm, inv_page_ctm;
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
-	fz_transform_rect(&trect, &inv_page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
+	rect = fz_transform_rect(rect, inv_page_ctm);
 
-	pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), &trect);
+	pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), rect);
 	pdf_dirty_annot(ctx, annot);
 }
 
@@ -832,8 +830,8 @@ pdf_annot_line(fz_context *ctx, pdf_annot *annot, fz_point *a, fz_point *b)
 	a->y = pdf_array_get_real(ctx, line, 1);
 	b->x = pdf_array_get_real(ctx, line, 2);
 	b->y = pdf_array_get_real(ctx, line, 3);
-	fz_transform_point(a, &page_ctm);
-	fz_transform_point(b, &page_ctm);
+	*a = fz_transform_point(*a, page_ctm);
+	*b = fz_transform_point(*b, page_ctm);
 }
 
 void
@@ -845,10 +843,10 @@ pdf_set_annot_line(fz_context *ctx, pdf_annot *annot, fz_point a, fz_point b)
 	check_allowed_subtypes(ctx, annot, PDF_NAME(L), line_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
-	fz_transform_point(&a, &inv_page_ctm);
-	fz_transform_point(&b, &inv_page_ctm);
+	a = fz_transform_point(a, inv_page_ctm);
+	b = fz_transform_point(b, inv_page_ctm);
 
 	line = pdf_new_array(ctx, annot->page->doc, 4);
 	pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(L), line);
@@ -896,9 +894,7 @@ pdf_annot_vertex(fz_context *ctx, pdf_annot *annot, int i)
 
 	point.x = pdf_array_get_real(ctx, vertices, i * 2);
 	point.y = pdf_array_get_real(ctx, vertices, i * 2 + 1);
-	fz_transform_point(&point, &page_ctm);
-
-	return point;
+	return fz_transform_point(point, page_ctm);
 }
 
 void
@@ -915,13 +911,12 @@ pdf_set_annot_vertices(fz_context *ctx, pdf_annot *annot, int n, const fz_point
 		fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of vertices");
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	vertices = pdf_new_array(ctx, doc, n * 2);
 	for (i = 0; i < n; ++i)
 	{
-		point = v[i];
-		fz_transform_point(&point, &inv_page_ctm);
+		point = fz_transform_point(v[i], inv_page_ctm);
 		pdf_array_push_real(ctx, vertices, point.x);
 		pdf_array_push_real(ctx, vertices, point.y);
 	}
@@ -945,7 +940,7 @@ void pdf_add_annot_vertex(fz_context *ctx, pdf_annot *annot, fz_point p)
 	check_allowed_subtypes(ctx, annot, PDF_NAME(Vertices), vertices_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
 	if (!pdf_is_array(ctx, vertices))
@@ -954,7 +949,7 @@ void pdf_add_annot_vertex(fz_context *ctx, pdf_annot *annot, fz_point p)
 		pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(Vertices), vertices);
 	}
 
-	fz_transform_point(&p, &inv_page_ctm);
+	p = fz_transform_point(p, inv_page_ctm);
 	pdf_array_push_real(ctx, vertices, p.x);
 	pdf_array_push_real(ctx, vertices, p.y);
 
@@ -969,9 +964,9 @@ void pdf_set_annot_vertex(fz_context *ctx, pdf_annot *annot, int i, fz_point p)
 	check_allowed_subtypes(ctx, annot, PDF_NAME(Vertices), vertices_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
-	fz_transform_point(&p, &inv_page_ctm);
+	p = fz_transform_point(p, inv_page_ctm);
 
 	vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
 	pdf_array_put_drop(ctx, vertices, i * 2 + 0, pdf_new_real(ctx, p.x));
@@ -1018,7 +1013,7 @@ pdf_annot_quad_point(fz_context *ctx, pdf_annot *annot, int idx, float v[8])
 		fz_point point;
 		point.x = pdf_array_get_real(ctx, quad_points, idx * 8 + i + 0);
 		point.y = pdf_array_get_real(ctx, quad_points, idx * 8 + i + 1);
-		fz_transform_point(&point, &page_ctm);
+		point = fz_transform_point(point, page_ctm);
 		v[i+0] = point.x;
 		v[i+1] = point.y;
 	}
@@ -1038,7 +1033,7 @@ pdf_set_annot_quad_points(fz_context *ctx, pdf_annot *annot, int n, const float
 		fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of quadrilaterals");
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	quad_points = pdf_new_array(ctx, doc, n * 8);
 	for (i = 0; i < n; ++i)
@@ -1047,7 +1042,7 @@ pdf_set_annot_quad_points(fz_context *ctx, pdf_annot *annot, int n, const float
 		{
 			point.x = v[i * 8 + k * 2 + 0];
 			point.y = v[i * 8 + k * 2 + 1];
-			fz_transform_point(&point, &inv_page_ctm);
+			point = fz_transform_point(point, inv_page_ctm);
 			pdf_array_push_real(ctx, quad_points, point.x);
 			pdf_array_push_real(ctx, quad_points, point.y);
 		}
@@ -1074,7 +1069,7 @@ pdf_add_annot_quad_point(fz_context *ctx, pdf_annot *annot, fz_quad quad)
 	check_allowed_subtypes(ctx, annot, PDF_NAME(QuadPoints), quad_point_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	quad_points = pdf_dict_get(ctx, annot->obj, PDF_NAME(QuadPoints));
 	if (!pdf_is_array(ctx, quad_points))
@@ -1087,7 +1082,7 @@ pdf_add_annot_quad_point(fz_context *ctx, pdf_annot *annot, fz_quad quad)
 	 * in a counterclockwise fashion. Experiments with Adobe's implementation
 	 * indicates a cross-wise ordering is intended: ul, ur, ll, lr.
 	 */
-	fz_transform_quad(&quad, &inv_page_ctm);
+	quad = fz_transform_quad(quad, inv_page_ctm);
 	pdf_array_push_real(ctx, quad_points, quad.ul.x);
 	pdf_array_push_real(ctx, quad_points, quad.ul.y);
 	pdf_array_push_real(ctx, quad_points, quad.ur.x);
@@ -1148,9 +1143,7 @@ pdf_annot_ink_list_stroke_vertex(fz_context *ctx, pdf_annot *annot, int i, int k
 
 	point.x = pdf_array_get_real(ctx, stroke, k * 2 + 0);
 	point.y = pdf_array_get_real(ctx, stroke, k * 2 + 1);
-	fz_transform_point(&point, &page_ctm);
-
-	return point;
+	return fz_transform_point(point, page_ctm);
 }
 
 void
@@ -1165,7 +1158,7 @@ pdf_set_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, const int *coun
 	check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	// TODO: update Rect (in update appearance perhaps?)
 
@@ -1175,8 +1168,7 @@ pdf_set_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, const int *coun
 		stroke = pdf_new_array(ctx, doc, count[i] * 2);
 		for (k = 0; k < count[i]; ++k)
 		{
-			point = *v++;
-			fz_transform_point(&point, &inv_page_ctm);
+			point = fz_transform_point(*v++, inv_page_ctm);
 			pdf_array_push_real(ctx, stroke, point.x);
 			pdf_array_push_real(ctx, stroke, point.y);
 		}
@@ -1205,7 +1197,7 @@ pdf_add_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, fz_point p[])
 	check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
 	if (!pdf_is_array(ctx, ink_list))
@@ -1219,8 +1211,7 @@ pdf_add_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, fz_point p[])
 	{
 		for (i = 0; i < n; ++i)
 		{
-			fz_point tp = p[i];
-			fz_transform_point(&tp, &inv_page_ctm);
+			fz_point tp = fz_transform_point(p[i], inv_page_ctm);
 			pdf_array_push_real(ctx, stroke, tp.x);
 			pdf_array_push_real(ctx, stroke, tp.y);
 		}
@@ -1244,15 +1235,15 @@ pdf_set_text_annot_position(fz_context *ctx, pdf_annot *annot, fz_point pt)
 	int flags;
 
 	pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
-	fz_invert_matrix(&inv_page_ctm, &page_ctm);
+	inv_page_ctm = fz_invert_matrix(page_ctm);
 
 	rect.x0 = pt.x;
 	rect.x1 = pt.x + TEXT_ANNOT_SIZE;
 	rect.y0 = pt.y;
 	rect.y1 = pt.y + TEXT_ANNOT_SIZE;
-	fz_transform_rect(&rect, &inv_page_ctm);
+	rect = fz_transform_rect(rect, inv_page_ctm);
 
-	pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), &rect);
+	pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), rect);
 
 	flags = pdf_dict_get_int(ctx, annot->obj, PDF_NAME(F));
 	flags |= (PDF_ANNOT_IS_NO_ZOOM|PDF_ANNOT_IS_NO_ROTATE);
diff --git a/source/pdf/pdf-appearance.c b/source/pdf/pdf-appearance.c
index 2c18a813..0e2e2847 100644
--- a/source/pdf/pdf-appearance.c
+++ b/source/pdf/pdf-appearance.c
@@ -113,9 +113,9 @@ static void pdf_write_arrow_appearance(fz_context *ctx, fz_buffer *buf, fz_rect
 	v = rotate_vector(angle, 8.8f*r, -4.5f*r);
 	b = fz_make_point(x + v.x, y + v.y);
 
-	fz_include_point_in_rect(rect, &a);
-	fz_include_point_in_rect(rect, &b);
-	fz_expand_rect(rect, w);
+	*rect = fz_include_point_in_rect(*rect, a);
+	*rect = fz_include_point_in_rect(*rect, b);
+	*rect = fz_expand_rect(*rect, w);
 
 	fz_append_printf(ctx, buf, "%g %g m\n", a.x, a.y);
 	fz_append_printf(ctx, buf, "%g %g l\n", x, y);
@@ -182,8 +182,8 @@ pdf_write_line_cap_appearance(fz_context *ctx, fz_buffer *buf, fz_rect *rect,
 		fz_append_printf(ctx, buf, "%g %g m\n", a.x, a.y);
 		fz_append_printf(ctx, buf, "%g %g l\n", b.x, b.y);
 		fz_append_string(ctx, buf, "S\n");
-		fz_include_point_in_rect(rect, &a);
-		fz_include_point_in_rect(rect, &b);
+		*rect = fz_include_point_in_rect(*rect, a);
+		*rect = fz_include_point_in_rect(*rect, b);
 	}
 	/* PDF 1.6 */
 	else if (cap == PDF_NAME(ROpenArrow))
@@ -208,8 +208,8 @@ pdf_write_line_cap_appearance(fz_context *ctx, fz_buffer *buf, fz_rect *rect,
 		fz_append_printf(ctx, buf, "%g %g m\n", a.x, a.y);
 		fz_append_printf(ctx, buf, "%g %g l\n", b.x, b.y);
 		fz_append_string(ctx, buf, "S\n");
-		fz_include_point_in_rect(rect, &a);
-		fz_include_point_in_rect(rect, &b);
+		*rect = fz_include_point_in_rect(*rect, a);
+		*rect = fz_include_point_in_rect(*rect, b);
 	}
 }
 
@@ -247,7 +247,7 @@ pdf_write_line_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_
 		pdf_write_line_cap_appearance(ctx, buf, rect, a.x, a.y, dx/l, dy/l, w, ic, pdf_array_get(ctx, le, 0));
 		pdf_write_line_cap_appearance(ctx, buf, rect, b.x, b.y, -dx/l, -dy/l, w, ic, pdf_array_get(ctx, le, 1));
 	}
-	fz_expand_rect(rect, fz_max(1, w));
+	*rect = fz_expand_rect(*rect, fz_max(1, w));
 }
 
 static void
@@ -323,14 +323,14 @@ pdf_write_polygon_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf,
 				rect->y0 = rect->y1 = p.y;
 			}
 			else
-				fz_include_point_in_rect(rect, &p);
+				*rect = fz_include_point_in_rect(*rect, p);
 			if (i == 0)
 				fz_append_printf(ctx, buf, "%g %g m\n", p.x, p.y);
 			else
 				fz_append_printf(ctx, buf, "%g %g l\n", p.x, p.y);
 		}
 		fz_append_string(ctx, buf, close ? "s" : "S");
-		fz_expand_rect(rect, lw);
+		*rect = fz_expand_rect(*rect, lw);
 	}
 }
 
@@ -363,12 +363,12 @@ pdf_write_ink_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_r
 				rect->y0 = rect->y1 = p.y;
 			}
 			else
-				fz_include_point_in_rect(rect, &p);
+				*rect = fz_include_point_in_rect(*rect, p);
 			fz_append_printf(ctx, buf, "%g %g %c\n", p.x, p.y, k == 0 ? 'm' : 'l');
 		}
 	}
 	fz_append_printf(ctx, buf, "S");
-	fz_expand_rect(rect, lw);
+	*rect = fz_expand_rect(*rect, lw);
 }
 
 /* Contrary to the specification, the points within a QuadPoint are NOT
@@ -398,13 +398,12 @@ extract_quad(fz_context *ctx, fz_point *quad, pdf_obj *obj, int i)
 static void
 union_quad(fz_rect *rect, const fz_point quad[4], float lw)
 {
-	fz_rect tmp;
-	tmp.x0 = fz_min(fz_min(quad[0].x, quad[1].x), fz_min(quad[2].x, quad[3].x));
-	tmp.y0 = fz_min(fz_min(quad[0].y, quad[1].y), fz_min(quad[2].y, quad[3].y));
-	tmp.x1 = fz_max(fz_max(quad[0].x, quad[1].x), fz_max(quad[2].x, quad[3].x));
-	tmp.y1 = fz_max(fz_max(quad[0].y, quad[1].y), fz_max(quad[2].y, quad[3].y));
-	fz_expand_rect(&tmp, lw);
-	fz_union_rect(rect, &tmp);
+	fz_rect qbox;
+	qbox.x0 = fz_min(fz_min(quad[0].x, quad[1].x), fz_min(quad[2].x, quad[3].x));
+	qbox.y0 = fz_min(fz_min(quad[0].y, quad[1].y), fz_min(quad[2].y, quad[3].y));
+	qbox.x1 = fz_max(fz_max(quad[0].x, quad[1].x), fz_max(quad[2].x, quad[3].x));
+	qbox.y1 = fz_max(fz_max(quad[0].y, quad[1].y), fz_max(quad[2].y, quad[3].y));
+	*rect = fz_union_rect(*rect, fz_expand_rect(qbox, lw));
 }
 
 static fz_point
@@ -745,7 +744,7 @@ pdf_write_stamp_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz
 
 		pdf_write_fill_color_appearance(ctx, annot, buf);
 		pdf_write_stroke_color_appearance(ctx, annot, buf);
-		fz_rotate(&rotate, 0.6f);
+		rotate = fz_rotate(0.6f);
 		fz_append_printf(ctx, buf, "%M cm\n", &rotate);
 		fz_append_string(ctx, buf, "2 w\n2 2 186 44 re\nS\n");
 
@@ -995,7 +994,7 @@ pdf_write_free_text_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf
 	if (r == 90 || r == 270)
 		t = h, h = w, w = t;
 
-	fz_rotate(matrix, r);
+	*matrix = fz_rotate(r);
 	*bbox = fz_make_rect(0, 0, w, h);
 
 	if (pdf_write_fill_color_appearance(ctx, annot, buf))
@@ -1029,7 +1028,7 @@ pdf_write_tx_widget_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf
 	h = rect->y1 - rect->y0;
 	if (r == 90 || r == 270)
 		t = h, h = w, w = t;
-	fz_rotate(matrix, r);
+	*matrix = fz_rotate(r);
 	*bbox = fz_make_rect(0, 0, w, h);
 
 	fz_append_string(ctx, buf, "/Tx BMC\nq\n");
@@ -1253,9 +1252,9 @@ void pdf_update_appearance(fz_context *ctx, pdf_annot *annot)
 
 		fz_try(ctx)
 		{
-			pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)), &rect);
+			rect = pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(Rect)));
 			pdf_write_appearance(ctx, annot, buf, &rect, &bbox, &matrix, &res);
-			pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), &rect);
+			pdf_dict_put_rect(ctx, annot->obj, PDF_NAME(Rect), rect);
 
 			if (!ap_n)
 			{
@@ -1264,13 +1263,13 @@ void pdf_update_appearance(fz_context *ctx, pdf_annot *annot)
 					ap = pdf_new_dict(ctx, annot->page->doc, 1);
 					pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(AP), ap);
 				}
-				new_ap_n = pdf_new_xobject(ctx, annot->page->doc, &bbox, &matrix, res, buf);
+				new_ap_n = pdf_new_xobject(ctx, annot->page->doc, bbox, matrix, res, buf);
 				pdf_dict_put(ctx, ap, PDF_NAME(N), new_ap_n);
 			}
 			else
 			{
 				new_ap_n = pdf_keep_obj(ctx, ap_n);
-				pdf_update_xobject(ctx, annot->page->doc, ap_n, &bbox, &matrix, res, buf);
+				pdf_update_xobject(ctx, annot->page->doc, ap_n, bbox, matrix, res, buf);
 			}
 
 			pdf_drop_obj(ctx, annot->ap);
diff --git a/source/pdf/pdf-device.c b/source/pdf/pdf-device.c
index 9b33e5c9..4358508e 100644
--- a/source/pdf/pdf-device.c
+++ b/source/pdf/pdf-device.c
@@ -207,8 +207,8 @@ pdf_dev_ctm(fz_context *ctx, pdf_device *pdev, const fz_matrix *ctm)
 
 	if (memcmp(&gs->ctm, ctm, sizeof(*ctm)) == 0)
 		return;
-	fz_invert_matrix(&inverse, &gs->ctm);
-	fz_concat(&inverse, ctm, &inverse);
+	inverse = fz_invert_matrix(gs->ctm);
+	inverse = fz_concat(*ctm, inverse);
 	gs->ctm = *ctm;
 	fz_append_printf(ctx, gs->buf, "%M cm\n", &inverse);
 }
@@ -446,7 +446,7 @@ pdf_dev_text_span(fz_context *ctx, pdf_device *pdev, fz_text_span *span)
 	tm.e = span->items[0].x;
 	tm.f = span->items[0].y;
 
-	fz_invert_matrix(&inv_tm, &tm);
+	inv_tm = fz_invert_matrix(tm);
 
 	fz_append_printf(ctx, gs->buf, "%M Tm\n[<", &tm);
 
@@ -459,7 +459,7 @@ pdf_dev_text_span(fz_context *ctx, pdf_device *pdev, fz_text_span *span)
 		/* transform difference from expected pen position into font units. */
 		d.x = it->x - tm.e;
 		d.y = it->y - tm.f;
-		fz_transform_vector(&d, &inv_tm);
+		d = fz_transform_vector(d, inv_tm);
 		dx = (int)(d.x * 1000 + (d.x < 0 ? -0.5f : 0.5f));
 		dy = (int)(d.y * 1000 + (d.y < 0 ? -0.5f : 0.5f));
 
@@ -483,9 +483,9 @@ pdf_dev_text_span(fz_context *ctx, pdf_device *pdev, fz_text_span *span)
 
 		adv = fz_advance_glyph(ctx, span->font, it->gid, span->wmode);
 		if (span->wmode == 0)
-			fz_pre_translate(&tm, adv, 0);
+			tm = fz_pre_translate(tm, adv, 0);
 		else
-			fz_pre_translate(&tm, 0, adv);
+			tm = fz_pre_translate(tm, 0, adv);
 	}
 
 	fz_append_string(ctx, gs->buf, ">]TJ\n");
@@ -605,7 +605,7 @@ pdf_dev_new_form(fz_context *ctx, pdf_obj **form_ref, pdf_device *pdev, const fz
 		pdf_dict_put(ctx, form, PDF_NAME(Subtype), PDF_NAME(Form));
 		pdf_dict_put(ctx, form, PDF_NAME(Group), group_ref);
 		pdf_dict_put_int(ctx, form, PDF_NAME(FormType), 1);
-		pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), bbox);
+		pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), *bbox);
 		*form_ref = pdf_add_object(ctx, doc, form);
 	}
 	fz_always(ctx)
@@ -822,8 +822,8 @@ pdf_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_ma
 	pdf_dev_alpha(ctx, pdev, alpha, 0);
 
 	/* PDF images are upside down, so fiddle the ctm */
-	fz_pre_scale(&local_ctm, 1, -1);
-	fz_pre_translate(&local_ctm, 0, -1);
+	local_ctm = fz_pre_scale(local_ctm, 1, -1);
+	local_ctm = fz_pre_translate(local_ctm, 0, -1);
 	pdf_dev_ctm(ctx, pdev, &local_ctm);
 	fz_append_printf(ctx, gs->buf, "/Img%d Do\n", pdf_to_num(ctx, im_res));
 
@@ -862,8 +862,8 @@ pdf_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const
 	pdf_dev_color(ctx, pdev, colorspace, color, 0, color_params);
 
 	/* PDF images are upside down, so fiddle the ctm */
-	fz_pre_scale(&local_ctm, 1, -1);
-	fz_pre_translate(&local_ctm, 0, -1);
+	local_ctm = fz_pre_scale(local_ctm, 1, -1);
+	local_ctm = fz_pre_translate(local_ctm, 0, -1);
 	pdf_dev_ctm(ctx, pdev, &local_ctm);
 	fz_append_printf(ctx, gs->buf, "/Img%d Do Q\n", pdf_to_num(ctx, im_res));
 
diff --git a/source/pdf/pdf-font.c b/source/pdf/pdf-font.c
index b29a1a18..b540f4ec 100644
--- a/source/pdf/pdf-font.c
+++ b/source/pdf/pdf-font.c
@@ -1591,7 +1591,7 @@ pdf_add_font_descriptor(fz_context *ctx, pdf_document *doc, pdf_obj *fobj, fz_fo
 		bbox.y0 = font->bbox.y0 * 1000;
 		bbox.x1 = font->bbox.x1 * 1000;
 		bbox.y1 = font->bbox.y1 * 1000;
-		pdf_dict_put_rect(ctx, fdobj, PDF_NAME(FontBBox), &bbox);
+		pdf_dict_put_rect(ctx, fdobj, PDF_NAME(FontBBox), bbox);
 
 		pdf_dict_put_int(ctx, fdobj, PDF_NAME(ItalicAngle), 0);
 		pdf_dict_put_int(ctx, fdobj, PDF_NAME(Ascent), face->ascender * 1000.0f / face->units_per_EM);
@@ -2226,7 +2226,7 @@ pdf_add_cjk_font(fz_context *ctx, pdf_document *doc, fz_font *fzfont, int script
 			{
 				pdf_dict_put(ctx, fontdesc, PDF_NAME(Type), PDF_NAME(FontDescriptor));
 				pdf_dict_put_text_string(ctx, fontdesc, PDF_NAME(FontName), basefont);
-				pdf_dict_put_rect(ctx, fontdesc, PDF_NAME(FontBBox), &bbox);
+				pdf_dict_put_rect(ctx, fontdesc, PDF_NAME(FontBBox), bbox);
 				pdf_dict_put_int(ctx, fontdesc, PDF_NAME(Flags), flags);
 				pdf_dict_put_int(ctx, fontdesc, PDF_NAME(ItalicAngle), 0);
 				pdf_dict_put_int(ctx, fontdesc, PDF_NAME(Ascent), 1000);
diff --git a/source/pdf/pdf-form.c b/source/pdf/pdf-form.c
index 16811edd..f5466168 100644
--- a/source/pdf/pdf-form.c
+++ b/source/pdf/pdf-form.c
@@ -534,7 +534,7 @@ int pdf_pass_event(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_ui_ev
 
 	for (annot = page->annots; annot; annot = annot->next)
 	{
-		pdf_bound_annot(ctx, annot, &bbox);
+		bbox = pdf_bound_annot(ctx, annot);
 		if (pt->x >= bbox.x0 && pt->x <= bbox.x1)
 			if (pt->y >= bbox.y0 && pt->y <= bbox.y1)
 				break;
@@ -996,9 +996,9 @@ void pdf_field_set_text_color(fz_context *ctx, pdf_document *doc, pdf_obj *field
 	pdf_field_mark_dirty(ctx, doc, field);
 }
 
-fz_rect *pdf_bound_widget(fz_context *ctx, pdf_widget *widget, fz_rect *rect)
+fz_rect pdf_bound_widget(fz_context *ctx, pdf_widget *widget)
 {
-	return pdf_bound_annot(ctx, (pdf_annot*)widget, rect);
+	return pdf_bound_annot(ctx, (pdf_annot*)widget);
 }
 
 char *pdf_text_widget_text(fz_context *ctx, pdf_document *doc, pdf_widget *tw)
diff --git a/source/pdf/pdf-interpret.c b/source/pdf/pdf-interpret.c
index fe874807..55416b90 100644
--- a/source/pdf/pdf-interpret.c
+++ b/source/pdf/pdf-interpret.c
@@ -1072,8 +1072,7 @@ pdf_process_annot(fz_context *ctx, pdf_processor *proc, pdf_document *doc, pdf_p
 
 	if (proc->op_q && proc->op_cm && proc->op_Do_form && proc->op_Q && annot->ap)
 	{
-		fz_matrix matrix;
-		pdf_annot_transform(ctx, annot, &matrix);
+		fz_matrix matrix = pdf_annot_transform(ctx, annot);
 		proc->op_q(ctx, proc);
 		proc->op_cm(ctx, proc,
 			matrix.a, matrix.b,
@@ -1179,14 +1178,14 @@ pdf_tos_make_trm(fz_context *ctx, pdf_text_object_state *tos, pdf_text_state *te
 		tos->char_ty = w1 * text->size + text->char_space;
 	}
 
-	fz_concat(trm, &tsm, &tos->tm);
+	*trm = fz_concat(tsm, tos->tm);
 
 	tos->cid = cid;
 	tos->gid = pdf_font_cid_to_gid(ctx, fontdesc, cid);
 	tos->fontdesc = fontdesc;
 
 	/* Compensate for the glyph cache limited positioning precision */
-	fz_expand_rect(fz_bound_glyph(ctx, fontdesc->font, tos->gid, trm, &tos->char_bbox), 1);
+	tos->char_bbox = fz_expand_rect(fz_bound_glyph(ctx, fontdesc->font, tos->gid, *trm), 1);
 
 	return tos->gid;
 }
@@ -1194,15 +1193,14 @@ pdf_tos_make_trm(fz_context *ctx, pdf_text_object_state *tos, pdf_text_state *te
 void
 pdf_tos_move_after_char(fz_context *ctx, pdf_text_object_state *tos)
 {
-	fz_union_rect(&tos->text_bbox, &tos->char_bbox);
-
-	fz_pre_translate(&tos->tm, tos->char_tx, tos->char_ty);
+	tos->text_bbox = fz_union_rect(tos->text_bbox, tos->char_bbox);
+	tos->tm = fz_pre_translate(tos->tm, tos->char_tx, tos->char_ty);
 }
 
 void
 pdf_tos_translate(pdf_text_object_state *tos, float tx, float ty)
 {
-	fz_pre_translate(&tos->tlm, tx, ty);
+	tos->tlm = fz_pre_translate(tos->tlm, tx, ty);
 	tos->tm = tos->tlm;
 }
 
@@ -1221,6 +1219,6 @@ pdf_tos_set_matrix(pdf_text_object_state *tos, float a, float b, float c, float
 void
 pdf_tos_newline(pdf_text_object_state *tos, float leading)
 {
-	fz_pre_translate(&tos->tlm, 0, -leading);
+	tos->tlm = fz_pre_translate(tos->tlm, 0, -leading);
 	tos->tm = tos->tlm;
 }
diff --git a/source/pdf/pdf-link.c b/source/pdf/pdf-link.c
index e9f1c36f..6fe6f334 100644
--- a/source/pdf/pdf-link.c
+++ b/source/pdf/pdf-link.c
@@ -255,8 +255,8 @@ pdf_load_link(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int pagenum, co
 	if (!obj)
 		return NULL;
 
-	pdf_to_rect(ctx, obj, &bbox);
-	fz_transform_rect(&bbox, page_ctm);
+	bbox = pdf_to_rect(ctx, obj);
+	bbox = fz_transform_rect(bbox, *page_ctm);
 
 	obj = pdf_dict_get(ctx, dict, PDF_NAME(Dest));
 	if (obj)
@@ -274,7 +274,7 @@ pdf_load_link(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int pagenum, co
 		return NULL;
 
 	fz_try(ctx)
-		link = fz_new_link(ctx, &bbox, doc, uri);
+		link = fz_new_link(ctx, bbox, doc, uri);
 	fz_always(ctx)
 		fz_free(ctx, uri);
 	fz_catch(ctx)
@@ -343,7 +343,7 @@ pdf_resolve_link(fz_context *ctx, pdf_document *doc, const char *uri, float *xp,
 				p.y = y ? fz_atoi(y + 1) : 0;
 				obj = pdf_lookup_page_obj(ctx, doc, page);
 				pdf_page_obj_transform(ctx, obj, NULL, &ctm);
-				fz_transform_point(&p, &ctm);
+				p = fz_transform_point(p, ctm);
 
 				if (xp) *xp = p.x;
 				if (yp) *yp = p.y;
diff --git a/source/pdf/pdf-object.c b/source/pdf/pdf-object.c
index ff425a8f..32a02b9b 100644
--- a/source/pdf/pdf-object.c
+++ b/source/pdf/pdf-object.c
@@ -811,15 +811,15 @@ pdf_array_find(fz_context *ctx, pdf_obj *arr, pdf_obj *obj)
 	return -1;
 }
 
-pdf_obj *pdf_new_rect(fz_context *ctx, pdf_document *doc, const fz_rect *rect)
+pdf_obj *pdf_new_rect(fz_context *ctx, pdf_document *doc, fz_rect rect)
 {
 	pdf_obj *arr = pdf_new_array(ctx, doc, 4);
 	fz_try(ctx)
 	{
-		pdf_array_push_real(ctx, arr, rect->x0);
-		pdf_array_push_real(ctx, arr, rect->y0);
-		pdf_array_push_real(ctx, arr, rect->x1);
-		pdf_array_push_real(ctx, arr, rect->y1);
+		pdf_array_push_real(ctx, arr, rect.x0);
+		pdf_array_push_real(ctx, arr, rect.y0);
+		pdf_array_push_real(ctx, arr, rect.x1);
+		pdf_array_push_real(ctx, arr, rect.y1);
 	}
 	fz_catch(ctx)
 	{
@@ -829,17 +829,17 @@ pdf_obj *pdf_new_rect(fz_context *ctx, pdf_document *doc, const fz_rect *rect)
 	return arr;
 }
 
-pdf_obj *pdf_new_matrix(fz_context *ctx, pdf_document *doc, const fz_matrix *mtx)
+pdf_obj *pdf_new_matrix(fz_context *ctx, pdf_document *doc, fz_matrix mtx)
 {
 	pdf_obj *arr = pdf_new_array(ctx, doc, 6);
 	fz_try(ctx)
 	{
-		pdf_array_push_real(ctx, arr, mtx->a);
-		pdf_array_push_real(ctx, arr, mtx->b);
-		pdf_array_push_real(ctx, arr, mtx->c);
-		pdf_array_push_real(ctx, arr, mtx->d);
-		pdf_array_push_real(ctx, arr, mtx->e);
-		pdf_array_push_real(ctx, arr, mtx->f);
+		pdf_array_push_real(ctx, arr, mtx.a);
+		pdf_array_push_real(ctx, arr, mtx.b);
+		pdf_array_push_real(ctx, arr, mtx.c);
+		pdf_array_push_real(ctx, arr, mtx.d);
+		pdf_array_push_real(ctx, arr, mtx.e);
+		pdf_array_push_real(ctx, arr, mtx.f);
 	}
 	fz_catch(ctx)
 	{
@@ -2198,12 +2198,12 @@ void pdf_dict_put_text_string(fz_context *ctx, pdf_obj *dict, pdf_obj *key, cons
 	pdf_dict_put_drop(ctx, dict, key, pdf_new_text_string(ctx, x));
 }
 
-void pdf_dict_put_rect(fz_context *ctx, pdf_obj *dict, pdf_obj *key, const fz_rect *x)
+void pdf_dict_put_rect(fz_context *ctx, pdf_obj *dict, pdf_obj *key, const fz_rect x)
 {
 	pdf_dict_put_drop(ctx, dict, key, pdf_new_rect(ctx, NULL, x));
 }
 
-void pdf_dict_put_matrix(fz_context *ctx, pdf_obj *dict, pdf_obj *key, const fz_matrix *x)
+void pdf_dict_put_matrix(fz_context *ctx, pdf_obj *dict, pdf_obj *key, fz_matrix x)
 {
 	pdf_dict_put_drop(ctx, dict, key, pdf_new_matrix(ctx, NULL, x));
 }
diff --git a/source/pdf/pdf-op-filter.c b/source/pdf/pdf-op-filter.c
index cea60db5..10138cda 100644
--- a/source/pdf/pdf-op-filter.c
+++ b/source/pdf/pdf-op-filter.c
@@ -176,7 +176,7 @@ static void filter_flush(fz_context *ctx, pdf_filter_processor *p, int flush)
 					gstate->pending.ctm.e,
 					gstate->pending.ctm.f);
 
-			fz_concat(&gstate->sent.ctm, &current, &gstate->pending.ctm);
+			gstate->sent.ctm = fz_concat(current, gstate->pending.ctm);
 			gstate->pending.ctm.a = 1;
 			gstate->pending.ctm.b = 0;
 			gstate->pending.ctm.c = 0;
@@ -450,9 +450,9 @@ filter_show_space(fz_context *ctx, pdf_filter_processor *p, float tadj)
 	pdf_font_desc *fontdesc = gstate->pending.text.font;
 
 	if (fontdesc->wmode == 0)
-		fz_pre_translate(&p->tos.tm, tadj * gstate->pending.text.scale, 0);
+		p->tos.tm = fz_pre_translate(p->tos.tm, tadj * gstate->pending.text.scale, 0);
 	else
-		fz_pre_translate(&p->tos.tm, 0, tadj);
+		p->tos.tm = fz_pre_translate(p->tos.tm, 0, tadj);
 }
 
 /* Process a string (from buf, of length len), from position *pos onwards.
@@ -633,12 +633,12 @@ filter_show_text(fz_context *ctx, pdf_filter_processor *p, pdf_obj *text)
 				if (fontdesc->wmode == 0)
 				{
 					skip.x += tadj;
-					fz_pre_translate(&p->tos.tm, tadj * p->gstate->pending.text.scale, 0);
+					p->tos.tm = fz_pre_translate(p->tos.tm, tadj * p->gstate->pending.text.scale, 0);
 				}
 				else
 				{
 					skip.y += tadj;
-					fz_pre_translate(&p->tos.tm, 0, tadj);
+					p->tos.tm = fz_pre_translate(p->tos.tm, 0, tadj);
 				}
 
 			}
@@ -822,7 +822,7 @@ pdf_filter_cm(fz_context *ctx, pdf_processor *proc, float a, float b, float c, f
 {
 	pdf_filter_processor *p = (pdf_filter_processor*)proc;
 	filter_gstate *gstate = gstate_to_update(ctx, p);
-	fz_matrix old, ctm;
+	fz_matrix ctm;
 
 	/* If we're being given an identity matrix, don't bother sending it */
 	if (a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0)
@@ -835,8 +835,7 @@ pdf_filter_cm(fz_context *ctx, pdf_processor *proc, float a, float b, float c, f
 	ctm.e = e;
 	ctm.f = f;
 
-	old = gstate->pending.ctm;
-	fz_concat(&gstate->pending.ctm, &ctm, &old);
+	gstate->pending.ctm = fz_concat(ctm, gstate->pending.ctm);
 }
 
 /* path construction */
@@ -1038,9 +1037,7 @@ pdf_filter_ET(fz_context *ctx, pdf_processor *proc)
 		p->chain->op_ET(ctx, p->chain);
 	if (p->after_text)
 	{
-		fz_matrix ctm;
-
-		fz_concat(&ctm, &p->gstate->sent.ctm, &p->gstate->pending.ctm);
+		fz_matrix ctm = fz_concat(p->gstate->sent.ctm, p->gstate->pending.ctm);
 		if (p->chain->op_q)
 			p->chain->op_q(ctx, p->chain);
 		p->after_text(ctx, p->opaque, p->doc, p->chain, &ctm);
diff --git a/source/pdf/pdf-op-run.c b/source/pdf/pdf-op-run.c
index 8ef1943a..61729f0c 100644
--- a/source/pdf/pdf-op-run.c
+++ b/source/pdf/pdf-op-run.c
@@ -116,8 +116,8 @@ begin_softmask(fz_context *ctx, pdf_run_processor *pr, softmask_save *save)
 	save->ctm = gstate->softmask_ctm;
 	save_ctm = gstate->ctm;
 
-	pdf_xobject_bbox(ctx, softmask, &mask_bbox);
-	pdf_xobject_matrix(ctx, softmask, &mask_matrix);
+	mask_bbox = pdf_xobject_bbox(ctx, softmask);
+	mask_matrix = pdf_xobject_matrix(ctx, softmask);
 
 	pdf_tos_save(ctx, &pr->tos, tos_save);
 
@@ -125,8 +125,8 @@ begin_softmask(fz_context *ctx, pdf_run_processor *pr, softmask_save *save)
 		mask_bbox = fz_infinite_rect;
 	else
 	{
-		fz_transform_rect(&mask_bbox, &mask_matrix);
-		fz_transform_rect(&mask_bbox, &gstate->softmask_ctm);
+		mask_bbox = fz_transform_rect(mask_bbox, mask_matrix);
+		mask_bbox = fz_transform_rect(mask_bbox, gstate->softmask_ctm);
 	}
 	gstate->softmask = NULL;
 	gstate->softmask_resources = NULL;
@@ -208,7 +208,7 @@ pdf_show_shade(fz_context *ctx, pdf_run_processor *pr, fz_shade *shd)
 	if (pr->super.hidden)
 		return;
 
-	fz_bound_shade(ctx, shd, &gstate->ctm, &bbox);
+	bbox = fz_bound_shade(ctx, shd, gstate->ctm);
 
 	gstate = pdf_begin_group(ctx, pr, &bbox, &softmask);
 
@@ -389,8 +389,8 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 		gstate->softmask = NULL;
 	}
 
-	fz_concat(&ptm, &pat->matrix, &pat_gstate->ctm);
-	fz_invert_matrix(&invptm, &ptm);
+	ptm = fz_concat(pat->matrix, pat_gstate->ctm);
+	invptm = fz_invert_matrix(ptm);
 
 	/* The parent_ctm is amended with our pattern matrix */
 	gparent_save = pr->gparent;
@@ -403,8 +403,7 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 		/* patterns are painted using the parent_ctm. area = bbox of
 		 * shape to be filled in device space. Map it back to pattern
 		 * space. */
-		local_area = *area;
-		fz_transform_rect(&local_area, &invptm);
+		local_area = fz_transform_rect(*area, invptm);
 
 		fx0 = (local_area.x0 - pat->bbox.x0) / pat->xstep;
 		fy0 = (local_area.y0 - pat->bbox.y0) / pat->ystep;
@@ -474,8 +473,7 @@ pdf_show_pattern(fz_context *ctx, pdf_run_processor *pr, pdf_pattern *pat, pdf_g
 			{
 				for (x = x0; x < x1; x++)
 				{
-					gstate->ctm = ptm;
-					fz_pre_translate(&gstate->ctm, x * pat->xstep, y * pat->ystep);
+					gstate->ctm = fz_pre_translate(ptm, x * pat->xstep, y * pat->ystep);
 					pdf_gsave(ctx, pr);
 					fz_try(ctx)
 						pdf_process_contents(ctx, (pdf_processor*)pr, pat->document, pat->resources, pat->contents, NULL);
@@ -547,11 +545,9 @@ pdf_show_image(fz_context *ctx, pdf_run_processor *pr, fz_image *image)
 		return;
 
 	/* PDF has images bottom-up, so flip them right side up here */
-	image_ctm = gstate->ctm;
-	fz_pre_scale(fz_pre_translate(&image_ctm, 0, 1), 1, -1);
+	image_ctm = fz_pre_scale(fz_pre_translate(gstate->ctm, 0, 1), 1, -1);
 
-	bbox = fz_unit_rect;
-	fz_transform_rect(&bbox, &image_ctm);
+	bbox = fz_transform_rect(fz_unit_rect, image_ctm);
 
 	if (image->mask && gstate->blendmode)
 	{
@@ -631,7 +627,7 @@ pdf_show_path(fz_context *ctx, pdf_run_processor *pr, int doclose, int dofill, i
 		if (doclose)
 			fz_closepath(ctx, path);
 
-		fz_bound_path(ctx, path, (dostroke ? gstate->stroke_state : NULL), &gstate->ctm, &bbox);
+		bbox = fz_bound_path(ctx, path, (dostroke ? gstate->stroke_state : NULL), gstate->ctm);
 
 		if (pr->super.hidden)
 			dostroke = dofill = 0;
@@ -778,11 +774,9 @@ pdf_flush_text(fz_context *ctx, pdf_run_processor *pr)
 
 	fz_try(ctx)
 	{
-		fz_rect tb = pr->tos.text_bbox;
-
-		fz_transform_rect(&tb, &gstate->ctm);
+		fz_rect tb = fz_transform_rect(pr->tos.text_bbox, gstate->ctm);
 		if (dostroke)
-			fz_adjust_rect_for_stroke(ctx, &tb, gstate->stroke_state, &gstate->ctm);
+			tb = fz_adjust_rect_for_stroke(ctx, tb, gstate->stroke_state, gstate->ctm);
 
 		/* Don't bother sending a text group with nothing in it */
 		if (!text->head)
@@ -925,8 +919,7 @@ pdf_show_char(fz_context *ctx, pdf_run_processor *pr, int cid)
 		/* Render the glyph stream direct here (only happens for
 		 * type3 glyphs that seem to inherit current graphics
 		 * attributes, or type 3 glyphs within type3 glyphs). */
-		fz_matrix composed;
-		fz_concat(&composed, &trm, &gstate->ctm);
+		fz_matrix composed = fz_concat(trm, gstate->ctm);
 		fz_render_t3_glyph_direct(ctx, pr->dev, fontdesc->font, gid, &composed, gstate, pr->nested_depth, pr->default_cs);
 		/* Render text invisibly so that it can still be extracted. */
 		pr->tos.text_mode = 3;
@@ -947,11 +940,11 @@ pdf_show_char(fz_context *ctx, pdf_run_processor *pr, int cid)
 	}
 
 	/* add glyph to textobject */
-	fz_show_glyph(ctx, pr->tos.text, fontdesc->font, &trm, gid, ucsbuf[0], fontdesc->wmode, 0, FZ_BIDI_NEUTRAL, FZ_LANG_UNSET);
+	fz_show_glyph(ctx, pr->tos.text, fontdesc->font, trm, gid, ucsbuf[0], fontdesc->wmode, 0, FZ_BIDI_NEUTRAL, FZ_LANG_UNSET);
 
 	/* add filler glyphs for one-to-many unicode mapping */
 	for (i = 1; i < ucslen; i++)
-		fz_show_glyph(ctx, pr->tos.text, fontdesc->font, &trm, -1, ucsbuf[i], fontdesc->wmode, 0, FZ_BIDI_NEUTRAL, FZ_LANG_UNSET);
+		fz_show_glyph(ctx, pr->tos.text, fontdesc->font, trm, -1, ucsbuf[i], fontdesc->wmode, 0, FZ_BIDI_NEUTRAL, FZ_LANG_UNSET);
 
 	pdf_tos_move_after_char(ctx, &pr->tos);
 }
@@ -963,9 +956,9 @@ pdf_show_space(fz_context *ctx, pdf_run_processor *pr, float tadj)
 	pdf_font_desc *fontdesc = gstate->text.font;
 
 	if (fontdesc->wmode == 0)
-		fz_pre_translate(&pr->tos.tm, tadj * gstate->text.scale, 0);
+		pr->tos.tm = fz_pre_translate(pr->tos.tm, tadj * gstate->text.scale, 0);
 	else
-		fz_pre_translate(&pr->tos.tm, 0, tadj);
+		pr->tos.tm = fz_pre_translate(pr->tos.tm, 0, tadj);
 }
 
 static void
@@ -1232,13 +1225,13 @@ pdf_run_xobject(fz_context *ctx, pdf_run_processor *proc, pdf_obj *xobj, pdf_obj
 
 		gstate = pr->gstate + pr->gtop;
 
-		pdf_xobject_bbox(ctx, xobj, &xobj_bbox);
-		pdf_xobject_matrix(ctx, xobj, &xobj_matrix);
+		xobj_bbox = pdf_xobject_bbox(ctx, xobj);
+		xobj_matrix = pdf_xobject_matrix(ctx, xobj);
 		transparency = pdf_xobject_transparency(ctx, xobj);
 
 		/* apply xobject's transform matrix */
-		fz_concat(&local_transform, &xobj_matrix, &local_transform);
-		fz_concat(&gstate->ctm, &local_transform, &gstate->ctm);
+		local_transform = fz_concat(xobj_matrix, local_transform);
+		gstate->ctm = fz_concat(local_transform, gstate->ctm);
 
 		/* The gparent is updated with the modified ctm */
 		gparent_save_ctm = pr->gstate[pr->gparent].ctm;
@@ -1247,11 +1240,9 @@ pdf_run_xobject(fz_context *ctx, pdf_run_processor *proc, pdf_obj *xobj, pdf_obj
 		/* apply soft mask, create transparency group and reset state */
 		if (transparency)
 		{
-			fz_rect bbox;
 			int isolated = pdf_xobject_isolated(ctx, xobj);
 
-			bbox = xobj_bbox;
-			fz_transform_rect(&bbox, &gstate->ctm);
+			fz_rect bbox = fz_transform_rect(xobj_bbox, gstate->ctm);
 
 			/* Remember that we tried to call begin_softmask. Even
 			 * if it throws an error, we must call end_softmask. */
@@ -1582,7 +1573,7 @@ static void pdf_run_cm(fz_context *ctx, pdf_processor *proc, float a, float b, f
 	m.d = d;
 	m.e = e;
 	m.f = f;
-	fz_concat(&gstate->ctm, &m, &gstate->ctm);
+	gstate->ctm = fz_concat(m, gstate->ctm);
 }
 
 /* path construction */
diff --git a/source/pdf/pdf-page.c b/source/pdf/pdf-page.c
index 8300fdb3..f8131b2c 100644
--- a/source/pdf/pdf-page.c
+++ b/source/pdf/pdf-page.c
@@ -623,13 +623,13 @@ pdf_page_presentation(fz_context *ctx, pdf_page *page, fz_transition *transition
 	return transition;
 }
 
-fz_rect *
-pdf_bound_page(fz_context *ctx, pdf_page *page, fz_rect *mediabox)
+fz_rect
+pdf_bound_page(fz_context *ctx, pdf_page *page)
 {
 	fz_matrix page_ctm;
-	pdf_page_transform(ctx, page, mediabox, &page_ctm);
-	fz_transform_rect(mediabox, &page_ctm);
-	return mediabox;
+	fz_rect mediabox;
+	pdf_page_transform(ctx, page, &mediabox, &page_ctm);
+	return fz_transform_rect(mediabox, page_ctm);
 }
 
 fz_link *
@@ -661,7 +661,6 @@ pdf_page_obj_transform(fz_context *ctx, pdf_obj *pageobj, fz_rect *page_mediabox
 {
 	pdf_obj *obj;
 	fz_rect mediabox, cropbox, realbox, pagebox;
-	fz_matrix tmp;
 	float userunit = 1;
 	int rotate;
 
@@ -672,8 +671,8 @@ pdf_page_obj_transform(fz_context *ctx, pdf_obj *pageobj, fz_rect *page_mediabox
 	if (pdf_is_real(ctx, obj))
 		userunit = pdf_to_real(ctx, obj);
 
-	pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, pageobj, PDF_NAME(MediaBox)), &mediabox);
-	if (fz_is_empty_rect(&mediabox))
+	mediabox = pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, pageobj, PDF_NAME(MediaBox)));
+	if (fz_is_empty_rect(mediabox))
 	{
 		mediabox.x0 = 0;
 		mediabox.y0 = 0;
@@ -681,9 +680,9 @@ pdf_page_obj_transform(fz_context *ctx, pdf_obj *pageobj, fz_rect *page_mediabox
 		mediabox.y1 = 792;
 	}
 
-	pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, pageobj, PDF_NAME(CropBox)), &cropbox);
-	if (!fz_is_empty_rect(&cropbox))
-		fz_intersect_rect(&mediabox, &cropbox);
+	cropbox = pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, pageobj, PDF_NAME(CropBox)));
+	if (!fz_is_empty_rect(cropbox))
+		mediabox = fz_intersect_rect(mediabox, cropbox);
 
 	page_mediabox->x0 = fz_min(mediabox.x0, mediabox.x1);
 	page_mediabox->y0 = fz_min(mediabox.y0, mediabox.y1);
@@ -708,16 +707,14 @@ pdf_page_obj_transform(fz_context *ctx, pdf_obj *pageobj, fz_rect *page_mediabox
 	 * to PDF user space (arbitrary page origin, y ascending, UserUnit dpi). */
 
 	/* Make left-handed and scale by UserUnit */
-	fz_scale(page_ctm, userunit, -userunit);
+	*page_ctm = fz_scale(userunit, -userunit);
 
 	/* Rotate */
-	fz_pre_rotate(page_ctm, -rotate);
+	*page_ctm = fz_pre_rotate(*page_ctm, -rotate);
 
 	/* Translate page origin to 0,0 */
-	realbox = *page_mediabox;
-	fz_transform_rect(&realbox, page_ctm);
-	fz_translate(&tmp, -realbox.x0, -realbox.y0);
-	fz_concat(page_ctm, page_ctm, &tmp);
+	realbox = fz_transform_rect(*page_mediabox, *page_ctm);
+	*page_ctm = fz_concat(*page_ctm, fz_translate(-realbox.x0, -realbox.y0));
 }
 
 void
@@ -1166,7 +1163,7 @@ pdf_delete_page_range(fz_context *ctx, pdf_document *doc, int start, int end)
 }
 
 pdf_obj *
-pdf_add_page(fz_context *ctx, pdf_document *doc, const fz_rect *mediabox, int rotate, pdf_obj *resources, fz_buffer *contents)
+pdf_add_page(fz_context *ctx, pdf_document *doc, fz_rect mediabox, int rotate, pdf_obj *resources, fz_buffer *contents)
 {
 	pdf_obj *page_obj = pdf_new_dict(ctx, doc, 5);
 	fz_try(ctx)
diff --git a/source/pdf/pdf-parse.c b/source/pdf/pdf-parse.c
index fb1cc595..501c5626 100644
--- a/source/pdf/pdf-parse.c
+++ b/source/pdf/pdf-parse.c
@@ -3,40 +3,42 @@
 
 #include <string.h>
 
-fz_rect *
-pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *r)
+fz_rect
+pdf_to_rect(fz_context *ctx, pdf_obj *array)
 {
 	if (!pdf_is_array(ctx, array))
-		*r = fz_empty_rect;
+		return fz_empty_rect;
 	else
 	{
 		float a = pdf_array_get_real(ctx, array, 0);
 		float b = pdf_array_get_real(ctx, array, 1);
 		float c = pdf_array_get_real(ctx, array, 2);
 		float d = pdf_array_get_real(ctx, array, 3);
-		r->x0 = fz_min(a, c);
-		r->y0 = fz_min(b, d);
-		r->x1 = fz_max(a, c);
-		r->y1 = fz_max(b, d);
+		fz_rect r;
+		r.x0 = fz_min(a, c);
+		r.y0 = fz_min(b, d);
+		r.x1 = fz_max(a, c);
+		r.y1 = fz_max(b, d);
+		return r;
 	}
-	return r;
 }
 
-fz_matrix *
-pdf_to_matrix(fz_context *ctx, pdf_obj *array, fz_matrix *m)
+fz_matrix
+pdf_to_matrix(fz_context *ctx, pdf_obj *array)
 {
 	if (!pdf_is_array(ctx, array))
-		*m = fz_identity;
+		return fz_identity;
 	else
 	{
-		m->a = pdf_array_get_real(ctx, array, 0);
-		m->b = pdf_array_get_real(ctx, array, 1);
-		m->c = pdf_array_get_real(ctx, array, 2);
-		m->d = pdf_array_get_real(ctx, array, 3);
-		m->e = pdf_array_get_real(ctx, array, 4);
-		m->f = pdf_array_get_real(ctx, array, 5);
+		fz_matrix m;
+		m.a = pdf_array_get_real(ctx, array, 0);
+		m.b = pdf_array_get_real(ctx, array, 1);
+		m.c = pdf_array_get_real(ctx, array, 2);
+		m.d = pdf_array_get_real(ctx, array, 3);
+		m.e = pdf_array_get_real(ctx, array, 4);
+		m.f = pdf_array_get_real(ctx, array, 5);
+		return m;
 	}
-	return m;
 }
 
 static int
diff --git a/source/pdf/pdf-pattern.c b/source/pdf/pdf-pattern.c
index f1f94352..5574a565 100644
--- a/source/pdf/pdf-pattern.c
+++ b/source/pdf/pdf-pattern.c
@@ -58,13 +58,10 @@ pdf_load_pattern(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
 		pat->ystep = pdf_dict_get_real(ctx, dict, PDF_NAME(YStep));
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(BBox));
-		pdf_to_rect(ctx, obj, &pat->bbox);
+		pat->bbox = pdf_to_rect(ctx, obj);
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
-		if (obj)
-			pdf_to_matrix(ctx, obj, &pat->matrix);
-		else
-			pat->matrix = fz_identity;
+		pat->matrix = pdf_to_matrix(ctx, obj);
 
 		pat->resources = pdf_dict_get(ctx, dict, PDF_NAME(Resources));
 		if (pat->resources)
diff --git a/source/pdf/pdf-run.c b/source/pdf/pdf-run.c
index 2cc56edb..15339373 100644
--- a/source/pdf/pdf-run.c
+++ b/source/pdf/pdf-run.c
@@ -16,7 +16,7 @@ pdf_run_annot_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf
 		fz_set_default_colorspaces(ctx, dev, default_cs);
 
 	pdf_page_transform(ctx, page, &mediabox, &page_ctm);
-	fz_concat(&local_ctm, &page_ctm, ctm);
+	local_ctm = fz_concat(page_ctm, *ctm);
 
 	fz_try(ctx)
 	{
@@ -54,12 +54,12 @@ pdf_run_page_contents_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *p
 	fz_try(ctx)
 	{
 		pdf_page_transform(ctx, page, &mediabox, &page_ctm);
-		fz_concat(&local_ctm, &page_ctm, ctm);
+		local_ctm = fz_concat(page_ctm, *ctm);
+		mediabox = fz_transform_rect(mediabox, local_ctm);
 
 		resources = pdf_page_resources(ctx, page);
 		contents = pdf_page_contents(ctx, page);
 
-
 		if (page->transparency)
 		{
 			pdf_obj *group = pdf_page_group(ctx, page);
@@ -78,7 +78,7 @@ pdf_run_page_contents_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *p
 			else
 				colorspace = fz_keep_colorspace(ctx, fz_default_output_intent(ctx, default_cs));
 
-			fz_begin_group(ctx, dev, fz_transform_rect(&mediabox, &local_ctm), colorspace, 1, 0, 0, 1);
+			fz_begin_group(ctx, dev, &mediabox, colorspace, 1, 0, 0, 1);
 			fz_drop_colorspace(ctx, colorspace);
 			colorspace = NULL;
 		}
diff --git a/source/pdf/pdf-shade.c b/source/pdf/pdf-shade.c
index 5476c8b8..d34e8440 100644
--- a/source/pdf/pdf-shade.c
+++ b/source/pdf/pdf-shade.c
@@ -54,7 +54,6 @@ pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *sh
 	pdf_obj *obj;
 	float x0, y0, x1, y1;
 	float fv[2];
-	fz_matrix matrix;
 	int xx, yy;
 	float *p;
 	int n = fz_colorspace_n(ctx, shade->colorspace);
@@ -70,12 +69,7 @@ pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *sh
 		y1 = pdf_array_get_real(ctx, obj, 3);
 	}
 
-	obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
-	if (obj)
-		pdf_to_matrix(ctx, obj, &matrix);
-	else
-		matrix = fz_identity;
-	shade->u.f.matrix = matrix;
+	shade->u.f.matrix = pdf_to_matrix(ctx, pdf_dict_get(ctx, dict, PDF_NAME(Matrix)));
 	shade->u.f.xdivs = FUNSEGS;
 	shade->u.f.ydivs = FUNSEGS;
 	shade->u.f.fn_vals = fz_malloc(ctx, (FUNSEGS+1)*(FUNSEGS+1)*n*sizeof(float));
@@ -346,7 +340,7 @@ pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, pdf_obj *dict, const f
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(BBox));
 		if (pdf_is_array(ctx, obj))
-			pdf_to_rect(ctx, obj, &shade->bbox);
+			shade->bbox = pdf_to_rect(ctx, obj);
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(Function));
 		if (pdf_is_dict(ctx, obj))
@@ -449,10 +443,7 @@ pdf_load_shading(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
 	if (pdf_dict_get(ctx, dict, PDF_NAME(PatternType)))
 	{
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
-		if (obj)
-			pdf_to_matrix(ctx, obj, &mat);
-		else
-			mat = fz_identity;
+		mat = pdf_to_matrix(ctx, obj);
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(ExtGState));
 		if (obj)
diff --git a/source/pdf/pdf-signature.c b/source/pdf/pdf-signature.c
index 6ccb7ab2..cfb623d9 100644
--- a/source/pdf/pdf-signature.c
+++ b/source/pdf/pdf-signature.c
@@ -71,10 +71,10 @@ void pdf_sign_signature(fz_context *ctx, pdf_document *doc, pdf_widget *widget,
 
 		pdf_signature_set_value(ctx, doc, wobj, signer);
 
-		pdf_to_rect(ctx, pdf_dict_get(ctx, wobj, PDF_NAME(Rect)), &rect);
+		rect = pdf_to_rect(ctx, pdf_dict_get(ctx, wobj, PDF_NAME(Rect)));
 
 		/* Create an appearance stream only if the signature is intended to be visible */
-		if (!fz_is_empty_rect(&rect))
+		if (!fz_is_empty_rect(rect))
 		{
 			dn = signer->designated_name(signer);
 			fzbuf = fz_new_buffer(ctx, 256);
diff --git a/source/pdf/pdf-type3.c b/source/pdf/pdf-type3.c
index cd7693cf..9d32797e 100644
--- a/source/pdf/pdf-type3.c
+++ b/source/pdf/pdf-type3.c
@@ -56,12 +56,12 @@ pdf_load_type3_font(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *d
 		fontdesc = pdf_new_font_desc(ctx);
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(FontMatrix));
-		pdf_to_matrix(ctx, obj, &matrix);
+		matrix = pdf_to_matrix(ctx, obj);
 
 		obj = pdf_dict_get(ctx, dict, PDF_NAME(FontBBox));
-		fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix);
+		bbox = fz_transform_rect(pdf_to_rect(ctx, obj), matrix);
 
-		font = fz_new_type3_font(ctx, buf, &matrix);
+		font = fz_new_type3_font(ctx, buf, matrix);
 		fontdesc->font = font;
 		fontdesc->size += sizeof(fz_font) + 256 * (sizeof(fz_buffer*) + sizeof(float));
 
diff --git a/source/pdf/pdf-write.c b/source/pdf/pdf-write.c
index 0a66365e..63863104 100644
--- a/source/pdf/pdf-write.c
+++ b/source/pdf/pdf-write.c
@@ -3304,7 +3304,7 @@ pdf_writer_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
 	fz_try(ctx)
 	{
 		fz_close_device(ctx, dev);
-		obj = pdf_add_page(ctx, wri->pdf, &wri->mediabox, 0, wri->resources, wri->contents);
+		obj = pdf_add_page(ctx, wri->pdf, wri->mediabox, 0, wri->resources, wri->contents);
 		pdf_insert_page(ctx, wri->pdf, -1, obj);
 	}
 	fz_always(ctx)
diff --git a/source/pdf/pdf-xobject.c b/source/pdf/pdf-xobject.c
index 871f001a..2cfe1f8f 100644
--- a/source/pdf/pdf-xobject.c
+++ b/source/pdf/pdf-xobject.c
@@ -7,16 +7,16 @@ pdf_xobject_resources(fz_context *ctx, pdf_obj *xobj)
 	return pdf_dict_get(ctx, xobj, PDF_NAME(Resources));
 }
 
-fz_rect *
-pdf_xobject_bbox(fz_context *ctx, pdf_obj *xobj, fz_rect *bbox)
+fz_rect
+pdf_xobject_bbox(fz_context *ctx, pdf_obj *xobj)
 {
-	return pdf_to_rect(ctx, pdf_dict_get(ctx, xobj, PDF_NAME(BBox)), bbox);
+	return pdf_to_rect(ctx, pdf_dict_get(ctx, xobj, PDF_NAME(BBox)));
 }
 
-fz_matrix *
-pdf_xobject_matrix(fz_context *ctx, pdf_obj *xobj, fz_matrix *matrix)
+fz_matrix
+pdf_xobject_matrix(fz_context *ctx, pdf_obj *xobj)
 {
-	return pdf_to_matrix(ctx, pdf_dict_get(ctx, xobj, PDF_NAME(Matrix)), matrix);
+	return pdf_to_matrix(ctx, pdf_dict_get(ctx, xobj, PDF_NAME(Matrix)));
 }
 
 int pdf_xobject_isolated(fz_context *ctx, pdf_obj *xobj)
@@ -65,7 +65,7 @@ pdf_xobject_colorspace(fz_context *ctx, pdf_obj *xobj)
 }
 
 pdf_obj *
-pdf_new_xobject(fz_context *ctx, pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat, pdf_obj *res, fz_buffer *contents)
+pdf_new_xobject(fz_context *ctx, pdf_document *doc, fz_rect bbox, fz_matrix matrix, pdf_obj *res, fz_buffer *contents)
 {
 	pdf_obj *ind = NULL;
 	pdf_obj *form = pdf_new_dict(ctx, doc, 5);
@@ -74,8 +74,7 @@ pdf_new_xobject(fz_context *ctx, pdf_document *doc, const fz_rect *bbox, const f
 		pdf_dict_put(ctx, form, PDF_NAME(Type), PDF_NAME(XObject));
 		pdf_dict_put(ctx, form, PDF_NAME(Subtype), PDF_NAME(Form));
 		pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), bbox);
-		if (mat)
-			pdf_dict_put_matrix(ctx, form, PDF_NAME(Matrix), mat);
+		pdf_dict_put_matrix(ctx, form, PDF_NAME(Matrix), matrix);
 		if (res)
 			pdf_dict_put(ctx, form, PDF_NAME(Resources), res);
 		ind = pdf_add_stream(ctx, doc, contents, form, 0);
@@ -88,13 +87,10 @@ pdf_new_xobject(fz_context *ctx, pdf_document *doc, const fz_rect *bbox, const f
 }
 
 void
-pdf_update_xobject(fz_context *ctx, pdf_document *doc, pdf_obj *form, const fz_rect *bbox, const fz_matrix *mat, pdf_obj *res, fz_buffer *contents)
+pdf_update_xobject(fz_context *ctx, pdf_document *doc, pdf_obj *form, fz_rect bbox, fz_matrix matrix, pdf_obj *res, fz_buffer *contents)
 {
 	pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), bbox);
-	if (mat)
-		pdf_dict_put_matrix(ctx, form, PDF_NAME(Matrix), mat);
-	else
-		pdf_dict_del(ctx, form, PDF_NAME(Matrix));
+	pdf_dict_put_matrix(ctx, form, PDF_NAME(Matrix), matrix);
 	if (res)
 		pdf_dict_put(ctx, form, PDF_NAME(Resources), res);
 	else
-- 
cgit v1.2.3